# Git

URL: https://docs.hanzo.ai/docs/cli/git

> The `hanzo git` commands.

Also for this capability: [API](https://docs.hanzo.ai/docs/openapi/git) · **CLI** · [MCP](https://docs.hanzo.ai/docs/mcp-tools/git) · [SDKs](https://docs.hanzo.ai/docs/sdks)

Git hosting for your org: create repos, clone, push, and see what they cost.

[API reference →](https://docs.hanzo.ai/docs/openapi/git)

```bash
hanzo git list
```

Every command takes `--json` for the raw response and `--help` for its own flags. Sign in once with `hanzo auth login`; the commands below use that session, and the org they act in is the one it carries.

| Command                 | What it does                                                                                                                                                              |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hanzo git explore`     | Discover public repositories across every org                                                                                                                             |
| `hanzo git list`        | Browse your org's repositories                                                                                                                                            |
| `hanzo git runners`     | Returns the daemons registered into this org's pools, newest first, with when each was last heard from.                                                                   |
| `hanzo git usage`       | Returns per-repo and total storage bytes for the caller's org — the queryable, per-tenant number commerce and o11y meter on.                                              |
| `hanzo git webhook`     | Retired — push-to-deploy has no inbound webhook                                                                                                                           |
| `hanzo git workflows`   | Reports the workflows a repository declares at a ref and which declared pool would execute each job — the answer to "would a push here run, and where".                   |
| `hanzo runner declare`  | Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.                            |
| `hanzo runner log`      | Adds console output to a task's log and answers with how far that log is durable, so the runner knows where to resend from.                                               |
| `hanzo runner register` | Trades a pool's join secret for a runner identity and the token that authenticates every later call.                                                                      |
| `hanzo runner state`    | Records a task's progress and that of its steps, and answers with the result this side now holds — which is how a runner learns its task was stopped from somewhere else. |
| `hanzo runner task`     | Hands the runner a job to execute, if its pool has one, and answers immediately either way.                                                                               |

### Keys

| Command                  | What it does                                                                                                                                       |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hanzo git keys create`  | Registers an SSH public key so it can authenticate `git clone git@&lt;host&gt;:&lt;org&gt;/&lt;repo&gt;.git` for the caller's org.                 |
| `hanzo git keys list`    | Returns the SSH public keys registered to the caller's org — the keys that authenticate `git clone git@&lt;host&gt;:&lt;org&gt;/&lt;repo&gt;.git`. |
| `hanzo git keys rm <id>` | Removes a registered SSH key, scoped to the caller's org: an org can only delete its own, and a key id it does not own is not found.               |

### Org

| Command                                                         | What it does                                  |
| --------------------------------------------------------------- | --------------------------------------------- |
| `hanzo git org commits <org> <repo>`                            | Read a repository's commit log                |
| `hanzo git org get <org> <repo>`                                | Open a repository's home page                 |
| `hanzo git org git-receive-pack <org> <repo>`                   | Accept a push, and turn it into a build       |
| `hanzo git org git-upload-pack <org> <repo>`                    | Serve a clone or fetch                        |
| `hanzo git org info refs <org> <repo>`                          | Advertise a repository's refs to a git client |
| `hanzo git org project git-receive-pack <org> <project> <repo>` | Accept a push, and turn it into a build       |
| `hanzo git org project git-upload-pack <org> <project> <repo>`  | Serve a clone or fetch                        |
| `hanzo git org project info refs <org> <project> <repo>`        | Advertise a repository's refs to a git client |

### Pools

| Command                  | What it does                                                                                       |
| ------------------------ | -------------------------------------------------------------------------------------------------- |
| `hanzo git pools create` | Records the capacity an org has, and answers with the secret a runner daemon presents to enter it. |
| `hanzo git pools get`    | Returns the capacity this org has declared and how many daemons have entered each pool.            |

### Repos

| Command                                        | What it does                                                                                                                                         |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `hanzo git repos blob <name>`                  | Returns one file's bytes at one revision.                                                                                                            |
| `hanzo git repos commits <name>`               | Walks a ref's history newest first, or one path's history when a path is given.                                                                      |
| `hanzo git repos create`                       | Provisions an empty bare repository in the caller's scope and returns it with its clone URLs.                                                        |
| `hanzo git repos files <name>`                 | Returns every file a glob selects at one revision, WITH its bytes and the revision they came from.                                                   |
| `hanzo git repos gc <name>`                    | Repacks a repo into one bitmapped pack and rewrites its commit-graph, so the next clone reuses the bitmap instead of walking the whole object graph. |
| `hanzo git repos get <name>`                   | Returns one repo with its live ref state: every branch name and the resolved HEAD commit.                                                            |
| `hanzo git repos list`                         | Returns the repos in the caller's scope, most recently updated first.                                                                                |
| `hanzo git repos mirror <name>`                | Imports an external git repository into the caller's repo, provisioning it on first use.                                                             |
| `hanzo git repos pulls create <name>`          | Proposes a branch for merging and returns it with its number.                                                                                        |
| `hanzo git repos pulls get <name> 1`           | Returns one pull request by its per-repo number.                                                                                                     |
| `hanzo git repos pulls list <name>`            | Returns a repo's pull requests, newest number first — what is waiting to be reviewed, and what has already landed.                                   |
| `hanzo git repos pulls merge <name> 1`         | Merges an open pull request by FAST-FORWARDING base to head, and answers the proposal in its merged state with the revision base now points at.      |
| `hanzo git repos push <name>`                  | Lands a set of files as one commit without a git client — the hanzo.app builder's push.                                                              |
| `hanzo git repos readme <name>`                | Returns the README at the tree root as plain text — unrendered, so the caller decides how to present it.                                             |
| `hanzo git repos refs <name>`                  | Lists a repo's branches, tags and default branch — what a branch picker needs in one call.                                                           |
| `hanzo git repos rm <name>`                    | Removes a repo's metadata and purges its storage.                                                                                                    |
| `hanzo git repos subscriptions create <name>`  | Binds a Slack channel to a repo, so the lifecycle notifier posts that repo's push and deploy events there.                                           |
| `hanzo git repos subscriptions list <name>`    | Returns a repo's Slack subscriptions — which channels the lifecycle notifier posts this repo's push and deploy events to.                            |
| `hanzo git repos subscriptions rm <name> <id>` | Removes one Slack subscription from a repo; the notifier stops posting that repo's events to that channel.                                           |
| `hanzo git repos targets create <name>`        | Registers a downstream remote the repo's advanced refs are pushed to whenever a push lands here.                                                     |
| `hanzo git repos targets list <name>`          | Returns a repo's outbound mirror targets — the downstream remotes the mirror reactor pushes to whenever a push lands here.                           |
| `hanzo git repos targets rm <name> <id>`       | Removes one outbound mirror target; later pushes stop being forwarded to it.                                                                         |
| `hanzo git repos tree <name>`                  | Lists the immediate children of one directory at one revision, directories before files.                                                             |
| `hanzo git repos update <name>`                | Flips a repo's public bit, the one mutable repo setting today.                                                                                       |

### Runs

| Command                   | What it does                                       |
| ------------------------- | -------------------------------------------------- |
| `hanzo git runs create`   | Runs a repository's workflows at a ref, on demand. |
| `hanzo git runs get <id>` | Returns one run.                                   |
| `hanzo git runs list`     | Returns this org's runs, newest first.             |
