@lizard-build/sdk 0.1.71 → 0.1.73

package/dist/index.js

@@ -27,10 +27,26 @@ __export(index_exports, {
   CodeSandbox: () => CodeSandbox,
   ConfigApplyError: () => ConfigApplyError,
   ConflictError: () => ConflictError,
+  DEFAULT_GIT_URL: () => DEFAULT_GIT_URL,
   DeployHandle: () => DeployHandle,
   Desktop: () => Desktop,
   DomainsAPI: () => DomainsAPI,
+  GitAPI: () => GitAPI,
+  GitActionsAPI: () => GitActionsAPI,
+  GitBranchRulesAPI: () => GitBranchRulesAPI,
+  GitClient: () => GitClient,
+  GitCollaboratorsAPI: () => GitCollaboratorsAPI,
   GitHubAPI: () => GitHubAPI,
+  GitIssuesOnlyAPI: () => GitIssuesOnlyAPI,
+  GitLabelsAPI: () => GitLabelsAPI,
+  GitNotificationsAPI: () => GitNotificationsAPI,
+  GitPullsAPI: () => GitPullsAPI,
+  GitReleasesAPI: () => GitReleasesAPI,
+  GitReposAPI: () => GitReposAPI,
+  GitSecretsAPI: () => GitSecretsAPI,
+  GitStatusesAPI: () => GitStatusesAPI,
+  GitTokensAPI: () => GitTokensAPI,
+  GitWebhooksAPI: () => GitWebhooksAPI,
   LimitExceededError: () => LimitExceededError,
   Lizard: () => Lizard,
   LizardCLI: () => LizardCLI,
@@ -179,9 +195,9 @@ async function handleApiError(res) {
 // src/platform/client.ts
 var segment = (value) => encodeURIComponent(value);
 function query(path, values) {
-  const qs = new URLSearchParams();
-  for (const [key, value] of Object.entries(values)) if (value !== void 0) qs.set(key, String(value));
-  return qs.size ? `${path}?${qs}` : path;
+  const qs2 = new URLSearchParams();
+  for (const [key, value] of Object.entries(values)) if (value !== void 0) qs2.set(key, String(value));
+  return qs2.size ? `${path}?${qs2}` : path;
 }
 var PlatformClient = class {
   constructor(opts) {
@@ -535,6 +551,525 @@ var GitHubAPI = class {
   }
 };
 
+// src/platform/git.ts
+var DEFAULT_GIT_URL = "https://git.lizard.build";
+var seg = encodeURIComponent;
+function qs(path, values) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(values)) if (v !== void 0 && v !== "") q.set(k, String(v));
+  return q.size ? `${path}?${q}` : path;
+}
+function repoPath(repo) {
+  const m = /^([^/\s]+)\/([^/\s]+?)(\.git)?$/.exec(repo);
+  if (!m) throw new Error(`repository must be "owner/name", got "${repo}"`);
+  return `/api/repos/${seg(m[1])}/${seg(m[2])}`;
+}
+var GitClient = class {
+  constructor(config, url) {
+    this.config = config;
+    this.url = (url ?? process.env.LIZARD_GIT_URL ?? DEFAULT_GIT_URL).replace(/\/+$/, "");
+  }
+  async raw(method, path, body, headers = {}) {
+    const res = await fetch(this.url + path, {
+      method,
+      body,
+      headers: { "X-API-Key": this.config.apiKey, ...headers },
+      signal: AbortSignal.timeout(this.config.requestTimeoutMs)
+    });
+    if (!res.ok) await handleApiError(res);
+    return res;
+  }
+  async request(method, path, body, headers = {}) {
+    const res = await this.raw(
+      method,
+      path,
+      body === void 0 ? void 0 : JSON.stringify(body),
+      body === void 0 ? headers : { "Content-Type": "application/json", ...headers }
+    );
+    const text = res.status === 204 ? "" : await res.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body ?? {});
+  }
+  put(path, body) {
+    return this.request("PUT", path, body ?? {});
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+  async bytes(path) {
+    return new Uint8Array(await (await this.raw("GET", path)).arrayBuffer());
+  }
+};
+var GitReposAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  /** Yours and the ones you collaborate on by default; `owner`, `q`, `starred` narrow it. */
+  list(opts = {}) {
+    return this.c.get(qs("/api/repos", opts));
+  }
+  /** Answers the new repository's `owner` and `name`. */
+  create(opts) {
+    return this.c.post("/api/repos", opts);
+  }
+  get(repo) {
+    return this.c.get(repoPath(repo));
+  }
+  update(repo, opts) {
+    return this.c.patch(repoPath(repo), opts);
+  }
+  delete(repo) {
+    return this.c.delete(repoPath(repo));
+  }
+  star(repo) {
+    return this.c.put(`${repoPath(repo)}/star`);
+  }
+  unstar(repo) {
+    return this.c.delete(`${repoPath(repo)}/star`);
+  }
+  /** Fork into your account (`name` defaults to the same name). */
+  fork(repo, opts = {}) {
+    return this.c.post(`${repoPath(repo)}/forks`, opts);
+  }
+  forks(repo) {
+    return this.c.get(`${repoPath(repo)}/forks`);
+  }
+  /** Branches and tags. */
+  refs(repo) {
+    return this.c.get(`${repoPath(repo)}/refs`);
+  }
+  createBranch(repo, name, from) {
+    return this.c.post(`${repoPath(repo)}/branches`, { name, from });
+  }
+  deleteBranch(repo, name) {
+    return this.c.delete(`${repoPath(repo)}/branches/${name.split("/").map(seg).join("/")}`);
+  }
+  tree(repo, opts = {}) {
+    return this.c.get(qs(`${repoPath(repo)}/tree`, opts));
+  }
+  /** A file as JSON (text in `content`). */
+  file(repo, path, ref) {
+    return this.c.get(qs(`${repoPath(repo)}/blob`, { path, ref }));
+  }
+  /** A file's bytes, whatever its size or type. */
+  raw(repo, path, ref) {
+    const [owner, name] = repo.split("/");
+    return this.c.bytes(`/raw/${seg(owner)}/${seg(name)}/${ref.split("/").map(seg).join("/")}/${path.split("/").map(seg).join("/")}`);
+  }
+  /** Every file path at a ref. */
+  files(repo, ref) {
+    return this.c.get(qs(`${repoPath(repo)}/files`, { ref }));
+  }
+  search(repo, q, ref) {
+    return this.c.get(qs(`${repoPath(repo)}/search`, { q, ref }));
+  }
+  commits(repo, opts = {}) {
+    return this.c.get(qs(`${repoPath(repo)}/commits`, opts));
+  }
+  commit(repo, sha) {
+    return this.c.get(`${repoPath(repo)}/commits/${seg(sha)}`);
+  }
+  compare(repo, base, head) {
+    return this.c.get(qs(`${repoPath(repo)}/compare`, { base, head }));
+  }
+  /** Commit files on the server: no clone, no push. Answers 409 when `expect` no longer matches. */
+  commitFiles(repo, opts) {
+    const { idempotencyKey, ...body } = opts;
+    return this.c.request("POST", `${repoPath(repo)}/commits`, body, idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {});
+  }
+  /** Rebase `head` (branch or commit) onto `onto` on the server and move `onto` there; retried on races. */
+  land(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/land`, opts);
+  }
+  /** Who moved which branch, when. */
+  reflog(repo, ref) {
+    return this.c.get(qs(`${repoPath(repo)}/reflog`, { ref }));
+  }
+  archive(repo, ref, format = "tar.gz") {
+    return this.c.bytes(`${repoPath(repo)}/archive/${seg(ref)}.${format}`);
+  }
+  /** The HTTPS clone URL. With `withKey`, it carries the API key, so plain `git clone` works without a helper. */
+  cloneUrl(repo, opts = {}) {
+    repoPath(repo);
+    const u = new URL(`${this.c.url}/${repo.replace(/\.git$/, "")}.git`);
+    if (opts.withKey) {
+      u.username = "lizard";
+      u.password = this.c.config.apiKey;
+    }
+    return u.toString();
+  }
+};
+var GitIssuesAPI = class {
+  constructor(c, pulls = false) {
+    this.c = c;
+    this.pulls = pulls;
+  }
+  base(repo) {
+    return `${repoPath(repo)}/issues`;
+  }
+  list(repo, opts = {}) {
+    return this.c.get(qs(this.base(repo), { ...opts, pulls: this.pulls ? 1 : void 0 }));
+  }
+  get(repo, number) {
+    return this.c.get(`${this.base(repo)}/${number}`);
+  }
+  update(repo, number, opts) {
+    return this.c.patch(`${this.base(repo)}/${number}`, opts);
+  }
+  comment(repo, number, body) {
+    return this.c.post(`${this.base(repo)}/${number}/comments`, { body });
+  }
+  close(repo, number) {
+    return this.update(repo, number, { state: "closed" });
+  }
+  reopen(repo, number) {
+    return this.update(repo, number, { state: "open" });
+  }
+};
+var GitIssuesOnlyAPI = class extends GitIssuesAPI {
+  constructor(c) {
+    super(c, false);
+  }
+  create(repo, opts) {
+    return this.c.post(this.base(repo), opts);
+  }
+};
+var GitPullsAPI = class extends GitIssuesAPI {
+  constructor(c) {
+    super(c, true);
+  }
+  create(repo, opts) {
+    return this.c.post(this.base(repo), opts);
+  }
+  /** Mark a draft ready for review. */
+  ready(repo, number) {
+    return this.update(repo, number, { draft: false });
+  }
+  merge(repo, number, opts = {}) {
+    return this.c.post(`${repoPath(repo)}/pulls/${number}/merge`, opts);
+  }
+  diff(repo, number) {
+    return this.c.get(`${repoPath(repo)}/pulls/${number}/diff`);
+  }
+  commits(repo, number) {
+    return this.c.get(`${repoPath(repo)}/pulls/${number}/commits`);
+  }
+  reviews(repo, number) {
+    return this.c.get(`${repoPath(repo)}/pulls/${number}/reviews`);
+  }
+  review(repo, number, opts) {
+    return this.c.post(`${repoPath(repo)}/pulls/${number}/reviews`, opts);
+  }
+  approve(repo, number, body = "") {
+    return this.review(repo, number, { event: "APPROVE", body });
+  }
+  requestChanges(repo, number, body) {
+    return this.review(repo, number, { event: "REQUEST_CHANGES", body });
+  }
+  lineComment(repo, number, c) {
+    return this.c.post(`${repoPath(repo)}/pulls/${number}/comments`, c);
+  }
+  deleteLineComment(repo, number, id) {
+    return this.c.delete(`${repoPath(repo)}/pulls/${number}/comments/${id}`);
+  }
+  /** The combined commit status of the pull request's head (CI and external checks). */
+  async checks(repo, number) {
+    const { pull } = await this.get(repo, number);
+    if (!pull?.headSha) throw new Error(`pull request #${number} has no head commit`);
+    return this.c.get(`${repoPath(repo)}/commits/${pull.headSha}/status`);
+  }
+};
+var GitSecretsAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/actions/secrets`);
+  }
+  set(repo, name, value) {
+    return this.c.put(`${repoPath(repo)}/actions/secrets/${seg(name)}`, { value });
+  }
+  delete(repo, name) {
+    return this.c.delete(`${repoPath(repo)}/actions/secrets/${seg(name)}`);
+  }
+};
+var GitActionsAPI = class {
+  constructor(c) {
+    this.c = c;
+    this.secrets = new GitSecretsAPI(c);
+  }
+  runs(repo, opts = {}) {
+    return this.c.get(qs(`${repoPath(repo)}/actions/runs`, { ...opts }));
+  }
+  run(repo, number) {
+    return this.c.get(`${repoPath(repo)}/actions/runs/${number}`);
+  }
+  cancel(repo, number) {
+    return this.c.post(`${repoPath(repo)}/actions/runs/${number}/cancel`);
+  }
+  /** Run the same workflow at the same commit again (a new run). */
+  rerun(repo, number) {
+    return this.c.post(`${repoPath(repo)}/actions/runs/${number}/rerun`);
+  }
+  /** Let a run from a fork's pull request start (it waits for someone with write access). */
+  approve(repo, number) {
+    return this.c.post(`${repoPath(repo)}/actions/runs/${number}/approve`);
+  }
+  /** Part of a job's log from `offset`; follow `next` until `done`. */
+  log(repo, jobId, offset = 0) {
+    return this.c.get(qs(`${repoPath(repo)}/actions/jobs/${jobId}/log`, { offset }));
+  }
+  async fullLog(repo, jobId) {
+    return new TextDecoder().decode(await this.c.bytes(`${repoPath(repo)}/actions/jobs/${jobId}/log.txt`));
+  }
+  /** Each new piece of the log as it's written, until the job ends. */
+  async *followLog(repo, jobId, opts = {}) {
+    let offset = 0;
+    while (!opts.signal?.aborted) {
+      const chunk = await this.log(repo, jobId, offset);
+      if (chunk.text) yield chunk.text;
+      offset = chunk.next;
+      if (chunk.done && offset >= chunk.size) return;
+      if (!chunk.text) await new Promise((r) => setTimeout(r, opts.intervalMs ?? 1500));
+    }
+  }
+  /** Wait until the run ends (success, failure, cancelled, ...). */
+  async wait(repo, number, opts = {}) {
+    const until = Date.now() + (opts.timeoutMs ?? 30 * 6e4);
+    for (; ; ) {
+      const run = await this.run(repo, number);
+      if (!["queued", "running", "waiting", "pending"].includes(run.status)) return run;
+      if (Date.now() > until) throw new Error(`run ${number} is still ${run.status}`);
+      await new Promise((r) => setTimeout(r, opts.intervalMs ?? 3e3));
+    }
+  }
+  artifacts(repo, number) {
+    return this.c.get(`${repoPath(repo)}/actions/runs/${number}/artifacts`);
+  }
+  /** An artifact as a .tar.gz. */
+  downloadArtifact(repo, number, name) {
+    return this.c.bytes(`${repoPath(repo)}/actions/runs/${number}/artifacts/${seg(name)}`);
+  }
+  workflows(repo) {
+    return this.c.get(`${repoPath(repo)}/actions/workflows`);
+  }
+  /** Start a workflow that has `on: workflow_dispatch`. */
+  dispatch(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/actions/workflows/dispatch`, opts);
+  }
+  /** Latest run status per commit, for the given commits. */
+  status(repo, shas) {
+    return this.c.get(qs(`${repoPath(repo)}/actions/status`, { shas: shas.join(",") }));
+  }
+};
+var GitCollaboratorsAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/collaborators`);
+  }
+  /** Invite someone with a Lizard Git account (they sign in once first); they're in once they accept. */
+  invite(repo, login, role = "write") {
+    return this.c.post(`${repoPath(repo)}/collaborators`, { login, role });
+  }
+  setRole(repo, login, role) {
+    return this.c.patch(`${repoPath(repo)}/collaborators/${seg(login)}`, { role });
+  }
+  /** Remove someone (or yourself: leave). */
+  remove(repo, login) {
+    return this.c.delete(`${repoPath(repo)}/collaborators/${seg(login)}`);
+  }
+  cancelInvitation(repo, id) {
+    return this.c.delete(`${repoPath(repo)}/invitations/${id}`);
+  }
+  /** Invitations waiting for you. */
+  invitations() {
+    return this.c.get("/api/user/invitations");
+  }
+  accept(id) {
+    return this.c.post(`/api/user/invitations/${id}/accept`);
+  }
+  decline(id) {
+    return this.c.post(`/api/user/invitations/${id}/decline`);
+  }
+};
+var GitWebhooksAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/hooks`);
+  }
+  /** GitHub-style payloads, signed with `X-Hub-Signature-256` when there's a secret. */
+  create(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/hooks`, opts);
+  }
+  get(repo, id) {
+    return this.c.get(`${repoPath(repo)}/hooks/${id}`);
+  }
+  update(repo, id, opts) {
+    return this.c.patch(`${repoPath(repo)}/hooks/${id}`, opts);
+  }
+  delete(repo, id) {
+    return this.c.delete(`${repoPath(repo)}/hooks/${id}`);
+  }
+  ping(repo, id) {
+    return this.c.post(`${repoPath(repo)}/hooks/${id}/pings`);
+  }
+  deliveries(repo, id) {
+    return this.c.get(`${repoPath(repo)}/hooks/${id}/deliveries`);
+  }
+  delivery(repo, id, deliveryId) {
+    return this.c.get(`${repoPath(repo)}/hooks/${id}/deliveries/${deliveryId}`);
+  }
+  redeliver(repo, id, deliveryId) {
+    return this.c.post(`${repoPath(repo)}/hooks/${id}/deliveries/${deliveryId}/redeliver`);
+  }
+};
+var GitBranchRulesAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/branch-rules`);
+  }
+  create(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/branch-rules`, opts);
+  }
+  update(repo, id, opts) {
+    return this.c.patch(`${repoPath(repo)}/branch-rules/${id}`, opts);
+  }
+  delete(repo, id) {
+    return this.c.delete(`${repoPath(repo)}/branch-rules/${id}`);
+  }
+};
+var GitLabelsAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/labels`);
+  }
+  create(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/labels`, opts);
+  }
+  update(repo, name, opts) {
+    return this.c.patch(`${repoPath(repo)}/labels/${seg(name)}`, opts);
+  }
+  delete(repo, name) {
+    return this.c.delete(`${repoPath(repo)}/labels/${seg(name)}`);
+  }
+};
+var GitReleasesAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(repo) {
+    return this.c.get(`${repoPath(repo)}/releases`);
+  }
+  /** Creates the tag too when it doesn't exist (at `target`, default branch by default). */
+  create(repo, opts) {
+    return this.c.post(`${repoPath(repo)}/releases`, opts);
+  }
+  get(repo, id) {
+    return this.c.get(`${repoPath(repo)}/releases/${id}`);
+  }
+  getByTag(repo, tag) {
+    return this.c.get(`${repoPath(repo)}/releases/tags/${seg(tag)}`);
+  }
+  update(repo, id, opts) {
+    return this.c.patch(`${repoPath(repo)}/releases/${id}`, opts);
+  }
+  delete(repo, id) {
+    return this.c.delete(`${repoPath(repo)}/releases/${id}`);
+  }
+  async uploadAsset(repo, id, name, data, contentType = "application/octet-stream") {
+    const body = typeof data === "string" || data instanceof Blob ? data : new Blob([new Uint8Array(data)]);
+    const res = await this.c.raw("POST", qs(`${repoPath(repo)}/releases/${id}/assets`, { name }), body, { "Content-Type": contentType });
+    return res.json();
+  }
+  downloadAsset(repo, id, assetId) {
+    return this.c.bytes(`${repoPath(repo)}/releases/${id}/assets/${assetId}`);
+  }
+  deleteAsset(repo, id, assetId) {
+    return this.c.delete(`${repoPath(repo)}/releases/${id}/assets/${assetId}`);
+  }
+};
+var GitStatusesAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  /** Report a check on a commit (what required checks in branch rules wait for). */
+  create(repo, sha, status) {
+    return this.c.post(`${repoPath(repo)}/statuses/${seg(sha)}`, status);
+  }
+  list(repo, ref) {
+    return this.c.get(`${repoPath(repo)}/commits/${seg(ref)}/statuses`);
+  }
+  combined(repo, ref) {
+    return this.c.get(`${repoPath(repo)}/commits/${seg(ref)}/status`);
+  }
+};
+var GitNotificationsAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list(opts = {}) {
+    return this.c.get(qs("/api/notifications", { all: opts.all ? 1 : void 0 }));
+  }
+  markRead(ids) {
+    return this.c.post("/api/notifications/read", ids?.length ? { ids } : { all: true });
+  }
+};
+var GitTokensAPI = class {
+  constructor(c) {
+    this.c = c;
+  }
+  list() {
+    return this.c.get("/api/user/tokens");
+  }
+  /** A Lizard Git token (lzg_...), optionally limited to repos, refs, paths, or read-only. The secret is in `token`, once. */
+  create(opts) {
+    return this.c.post("/api/user/tokens", opts);
+  }
+  delete(id) {
+    return this.c.delete(`/api/user/tokens/${id}`);
+  }
+};
+var GitAPI = class {
+  constructor(config, url) {
+    const c = this.client = new GitClient(config, url);
+    this.repos = new GitReposAPI(c);
+    this.issues = new GitIssuesOnlyAPI(c);
+    this.pulls = new GitPullsAPI(c);
+    this.actions = new GitActionsAPI(c);
+    this.collaborators = new GitCollaboratorsAPI(c);
+    this.webhooks = new GitWebhooksAPI(c);
+    this.branchRules = new GitBranchRulesAPI(c);
+    this.labels = new GitLabelsAPI(c);
+    this.releases = new GitReleasesAPI(c);
+    this.statuses = new GitStatusesAPI(c);
+    this.notifications = new GitNotificationsAPI(c);
+    this.tokens = new GitTokensAPI(c);
+  }
+  /** Who the key signs in as on Lizard Git. */
+  me() {
+    return this.client.get("/api/session");
+  }
+  user(login) {
+    return this.client.get(`/api/users/${seg(login)}`);
+  }
+};
+
 // src/project.ts
 var import_node_crypto = require("crypto");
 var projectIdCache = /* @__PURE__ */ new Map();
@@ -866,7 +1401,7 @@ var Fs = class {
    * }, 1000)
    * ```
    *
-   * Not available on Firecracker sandboxes yet: the call throws `LizardError` (501).
+   * Not available yet: the call throws `LizardError` (501).
    */
   async watch(path, opts) {
     const res = await fetch(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files/watch`, {
@@ -1331,7 +1866,7 @@ var Sandbox = class extends SandboxClient {
    * snapshot. A Firecracker snapshot is `ready` as soon as this returns: about 2 s, up to
    * a few minutes for a sandbox that filled most of its memory (its memory is uploaded
    * first), so the call waits up to 11 minutes. Start copies of it with {@link Sandbox.restore}
-   * (about 0.4 s each). The source keeps running. `poolSize` applies to container sandboxes only.
+   * (about 0.4 s each). The source keeps running. Firecracker snapshots ignore `poolSize`.
    */
   snapshot(name = `Snapshot ${this.sandboxId}`, opts = {}) {
     return new PlatformClient(this.resolveOpts()).post(`/api/sandboxes/${this.sandboxId}/snapshot`, { name, poolSize: opts.poolSize ?? 5, scope: opts.scope }, SNAPSHOT_TIMEOUT_MS);
@@ -1339,7 +1874,7 @@ var Sandbox = class extends SandboxClient {
   unexpose(port) {
     return new PlatformClient(this.resolveOpts()).delete(`/api/sandboxes/${this.sandboxId}/expose/${port}`);
   }
-  /** Stream the sandbox's logs. Not available on Firecracker sandboxes yet (`LizardError`, 501). */
+  /** Stream the sandbox's logs. Not available yet (`LizardError`, 501). */
   logs(opts = {}) {
     return new PlatformClient(this.resolveOpts()).events(query(`/api/sandboxes/${this.sandboxId}/logs`, { tail: opts.tail }), { signal: opts.signal });
   }
@@ -1378,7 +1913,7 @@ var Sandbox = class extends SandboxClient {
   static setSnapshotWarmPool(snapshotId, poolSize, opts) {
     return new PlatformClient(opts ?? {}).patch(`/api/sandbox-snapshots/${encodeURIComponent(snapshotId)}`, { poolSize });
   }
-  /** Release idle warm copies (container snapshots); retain saved state and existing claimed sandboxes. */
+  /** Release idle warm copies of an older snapshot; retain saved state and existing claimed sandboxes. Firecracker snapshots have no warm copies. */
   static pauseSnapshot(snapshotId, opts) {
     return new PlatformClient(opts ?? {}).post(`/api/sandbox-snapshots/${encodeURIComponent(snapshotId)}/pause`, {});
   }
@@ -1414,8 +1949,8 @@ var ProjectsAPI = class {
   }
   /** List all projects the API key can access. */
   list(opts) {
-    const qs = opts?.workspaceId ? `?workspaceId=${opts.workspaceId}` : "";
-    return this.client.get(`/api/projects${qs}`);
+    const qs2 = opts?.workspaceId ? `?workspaceId=${opts.workspaceId}` : "";
+    return this.client.get(`/api/projects${qs2}`);
   }
   /** Get a project by ID. */
   get(id) {
@@ -1808,8 +2343,8 @@ var WorkspacesAPI = class {
    * volumes and snapshots first.
    */
   delete(id, opts) {
-    const qs = opts?.force ? "" : "?requireEmpty=true";
-    return this.client.delete(`/api/workspaces/${id}${qs}`);
+    const qs2 = opts?.force ? "" : "?requireEmpty=true";
+    return this.client.delete(`/api/workspaces/${id}${qs2}`);
   }
   /**
    * Find a workspace by name, slug, or id, or `null` if there is no such workspace.
@@ -1999,13 +2534,11 @@ var Volume = class _Volume {
   /**
    * Resize a volume, by name or by id, to `sizeGb`.
    *
-   * A Firecracker volume (the default) can only grow. The change is in place and
-   * online: a sandbox with the volume attached keeps running and sees the new size.
-   * A smaller size throws `LizardError` (400) with `code: 'volume_shrink_unsupported'`.
+   * A volume grows in place and online: a sandbox with the volume attached keeps
+   * running and sees the new size. A smaller size throws `LizardError` (400) with
+   * `code: 'volume_shrink_unsupported'`.
    *
-   * On a container volume the change is in place and online: the size is a quota,
-   * so no data is copied and a mounted sandbox sees the new size immediately. Both
-   * growing and shrinking are allowed, but a shrink must leave at least 10% of the
+   * An older volume can also shrink, but the shrink must leave at least 10% of the
    * new size free — otherwise it throws `ConflictError` with
    * `code: 'volume_too_full_to_shrink'`.
    *
@@ -2015,7 +2548,7 @@ var Volume = class _Volume {
    * `volume_capacity_unavailable`, and `volume_resize_timeout` (a `TimeoutError`;
    * the size is left unchanged).
    *
-   * @returns The volume's updated info, including `sizeEnforced` for a container volume.
+   * @returns The volume's updated info, including `sizeEnforced` for an older volume.
    */
   static async resize(projectId, nameOrId, sizeGb, opts) {
     const config = new ConnectionConfig(opts);
@@ -2093,6 +2626,7 @@ var Lizard = class {
     this.metrics = new MetricsAPI(platform);
     this.storage = new StorageAPI(platform);
     this.github = new GitHubAPI(platform);
+    this.git = new GitAPI(this.config, opts.gitUrl);
   }
   // ── Sandbox convenience methods (backward-compatible) ──────────────────
   /** Resolve the client's project reference to a stable project ID (cached). */
@@ -2705,10 +3239,26 @@ var LizardCLI = class {
   CodeSandbox,
   ConfigApplyError,
   ConflictError,
+  DEFAULT_GIT_URL,
   DeployHandle,
   Desktop,
   DomainsAPI,
+  GitAPI,
+  GitActionsAPI,
+  GitBranchRulesAPI,
+  GitClient,
+  GitCollaboratorsAPI,
   GitHubAPI,
+  GitIssuesOnlyAPI,
+  GitLabelsAPI,
+  GitNotificationsAPI,
+  GitPullsAPI,
+  GitReleasesAPI,
+  GitReposAPI,
+  GitSecretsAPI,
+  GitStatusesAPI,
+  GitTokensAPI,
+  GitWebhooksAPI,
   LimitExceededError,
   Lizard,
   LizardCLI,