Create home

Moves a repository whose history is HERE to the forge (git.hanzo.ai), the one home of a repository no other host holds, and links it there: the repository is made in the org's own namespace on the forge, every branch and tag is pushed to it, the forge's refs are read back and must equal these, and only then does the row name the forge as its link, so this copy becomes the cache it can be fetched back into.

POST /v1/git/repos/{name}/home

Git → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/git/repos/{name}/home`
Method	`POST`
Operation	`post_git_repos_by_name_home`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Moves a repository whose history is HERE to the forge (git.hanzo.ai), the one home of a repository no other host holds, and links it there: the repository is made in the org's own namespace on the forge, every branch and tag is pushed to it, the forge's refs are read back and must equal these, and only then does the row name the forge as its link, so this copy becomes the cache it can be fetched back into. A forge repository of that name that already exists is refused, never overwritten. Org admins only.

Request

1 field.

Field	In	Type	Required	Description
`name`	path	string	yes	Name is the repository, from the :name path segment.

Response

Status	Body	Meaning
`200`	git.repoView	ok
`default`	problem-details	refused

200 body — 19 fields.

Field	In	Type	Always	Description
`branches`	body	string[]	—	Branches are the repo's branch names.
`cloneUrl`	body	string	—	CloneURL is the HTTPS smart-HTTP remote `git clone` takes.
`createdAt`	body	string	—	CreatedAt is RFC 3339 UTC.
`defaultBranch`	body	string	—	DefaultBranch is where HEAD points on a fresh repo ("main").
`description`	body	string	—	Description is the caller-supplied blurb (max 4KiB).
`head`	body	string	—	Head is the resolved HEAD commit, empty on an empty repo.
`id`	body	string	—	ID is the repo's stable, prefixed identifier ("repo_" + 128 random bits).
`link`	body	git.link	—
`link.cloneUrl`	body	string	—	CloneURL is the address its history is fetched from and pushed to.
`link.name`	body	string	—	Name is the repository's name on its provider.
`link.owner`	body	string	—	Owner is the account the repository belongs to on its provider.
`link.provider`	body	string	—	Provider is "github", "forge" (git.hanzo.ai, Hanzo's own), or "git" for any other host.
`name`	body	string	—	Name is the org-unique handle, and the last path segment of both URLs below.
`org`	body	string	—	Org owns the repo — the gateway-minted X-Org-Id, and the isolation key.
`project`	body	string	—	Project is the optional sub-scope the repo lives in; absent for the org's default scope.
`public`	body	boolean	—	Public grants ANONYMOUS read (fetch) only; push and the whole control plane stay org-authed.
`sizeBytes`	body	integer (int64)	—	SizeBytes is the repo's measured on-disk size, re-measured on create, after each push, and after a gc.
`sshUrl`	body	string	—	SSHURL is the scp-style SSH remote (git@host:org/repo.git).
`updatedAt`	body	string	—	UpdatedAt is RFC 3339 UTC, empty until the first write.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo git repos home <name>

.ts

.py

.go

.rs

.java

import { Configuration, GitApi } from 'hanzoai';

const api = new GitApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postGitReposByNameHome({ name: 'name' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import GitApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = GitApi(client).post_git_repos_by_name_home(name='name')

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.GitAPI.PostGitReposByNameHome(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, git_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = git_api::post_git_repos_by_name_home(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.GitApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new GitApi(client).postGitReposByNameHome();

curl -X POST https://api.hanzo.ai/v1/git/repos/<name>/home \
  -H "Authorization: Bearer $HANZO_API_KEY"

MCP reaches git through the git tool, which names its 41 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "get_git_activity"
         }
       }
     }'

Git API · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousCreate gc NextCreate link — POST /v1/git/repos/{name}/link