@gitterm/sdk 0.10.0 → 0.12.0

package/dist/sandbox/index.js

@@ -0,0 +1,3974 @@
+// ../agent-runtime/src/sandbox/types.ts
+import { createHash } from "node:crypto";
+class SandboxProviderError extends Error {
+  code;
+  leftoverId;
+  constructor(code, message) {
+    super(message);
+    this.name = "SandboxProviderError";
+    this.code = code;
+  }
+}
+async function discardFailedCreate(destroy, id, error) {
+  const deleted = await destroy(id).then(() => true, () => false);
+  if (deleted)
+    throw error;
+  const failed = error instanceof SandboxProviderError ? error : new SandboxProviderError("provider", error instanceof Error ? error.message : String(error));
+  failed.leftoverId = id;
+  throw failed;
+}
+var GITTERM_PREVIEW_PROVIDERS = [
+  "e2b",
+  "daytona",
+  "boat",
+  "exedev",
+  "gitterm"
+];
+var DAY = 24 * 60 * 60000;
+var SANDBOX_PROVIDER_PROFILES = {
+  e2b: {
+    home: "/home/user",
+    capabilities: {
+      expiry: "hard",
+      previews: "either",
+      pause: "stateful",
+      maxLifetimeMs: DAY,
+      snapshots: "pauses"
+    }
+  },
+  daytona: {
+    home: "/home/daytona",
+    capabilities: {
+      expiry: "hard",
+      previews: "either",
+      pause: "stateful",
+      maxLifetimeMs: DAY,
+      snapshots: "pauses"
+    }
+  },
+  vercel: {
+    home: "/home/vercel-sandbox",
+    capabilities: {
+      expiry: "hard",
+      previews: "public",
+      pause: "stateful",
+      maxLifetimeMs: 5 * 60 * 60000,
+      snapshots: "stops"
+    }
+  },
+  boat: {
+    home: "/home/user",
+    capabilities: {
+      expiry: "archive",
+      previews: "private",
+      pause: "stateful",
+      maxLifetimeMs: DAY,
+      snapshots: "pauses"
+    }
+  },
+  exedev: {
+    home: "/home/exedev",
+    capabilities: {
+      expiry: "none",
+      previews: "private",
+      pause: "stateful",
+      maxLifetimeMs: DAY,
+      snapshots: "none"
+    }
+  },
+  railway: {
+    home: "/root",
+    capabilities: {
+      expiry: "none",
+      previews: "private",
+      pause: "state-losing",
+      maxLifetimeMs: DAY,
+      snapshots: "none"
+    }
+  },
+  aws: {
+    home: "/root",
+    capabilities: {
+      expiry: "none",
+      previews: "private",
+      pause: "state-losing",
+      maxLifetimeMs: DAY,
+      snapshots: "none"
+    }
+  },
+  gitterm: {
+    home: "/home/user",
+    capabilities: {
+      expiry: "hard",
+      previews: "private",
+      pause: "stateful",
+      maxLifetimeMs: DAY,
+      snapshots: "none"
+    }
+  }
+};
+function accountHash(account) {
+  return createHash("sha256").update(account).digest("hex").slice(0, 10);
+}
+var shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+function terminated(id) {
+  return { id, state: "terminated", labels: {}, startedAt: null, expiresAt: null };
+}
+function validatePort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw new Error("Port must be between 1 and 65535");
+}
+function validateLifetime(timeoutMs, maxLifetimeMs) {
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 60000)
+    throw new Error("Sandbox lifetime must be at least one minute");
+  if (timeoutMs > maxLifetimeMs)
+    throw new Error(`Sandbox lifetime cannot exceed ${Math.floor(maxLifetimeMs / 60000)} minutes on this provider`);
+}
+function classifyFailure(provider, error, action, hints = {}) {
+  if (error instanceof SandboxProviderError)
+    return error;
+  const status = error?.status ?? error?.statusCode ?? error?.response?.status;
+  const message = error instanceof Error ? error.message : String(error);
+  if (hints.auth?.(error) || status === 401 || status === 403 || /unauthori[sz]ed|not authori[sz]ed|invalid (api )?(key|token)|forbidden/i.test(message))
+    return new SandboxProviderError("auth", `${provider} rejected the credential while trying to ${action}.`);
+  if (hints.notFound?.(error) || status === 404 || /not found|does not exist|no such/i.test(message))
+    return new SandboxProviderError("not_found", `${provider} could not find the sandbox while trying to ${action}. It may have expired or belong to another account.`);
+  if (status === 429 || /rate limit|too many requests/i.test(message))
+    return new SandboxProviderError("rate_limited", `${provider} rate-limited the request to ${action}.`);
+  if (/timed? ?out|timeout/i.test(message))
+    return new SandboxProviderError("timeout", `${provider} timed out while trying to ${action}.`);
+  return new SandboxProviderError("provider", `${provider} failed to ${action}.`);
+}
+
+// src/errors.ts
+var WORKSPACE_LIFECYCLE_ERROR_CODES = [
+  "WORKSPACE_NOT_RUNNING",
+  "WORKSPACE_TERMINATED",
+  "WORKSPACE_NON_RECOVERABLE",
+  "WORKSPACE_START_TIMEOUT",
+  "WORKSPACE_RESTART_FAILED"
+];
+
+class GittermError extends Error {
+  code;
+  status;
+  constructor(code, message, options = {}) {
+    super(message, "cause" in options ? { cause: options.cause } : undefined);
+    this.name = "GittermError";
+    this.code = code;
+    this.status = options.status;
+  }
+}
+
+class WorkspaceLifecycleError extends GittermError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+    this.name = "WorkspaceLifecycleError";
+  }
+}
+
+class AgentRunError extends GittermError {
+  run;
+  constructor(run, code) {
+    super(code, run.error ?? (code === "INPUT_REQUIRED" ? "The agent needs input; supply a handler or use runs.respond()" : `Agent run ${run.status}`));
+    this.run = run;
+    this.name = "AgentRunError";
+  }
+}
+
+// src/sandbox/backend.ts
+function managedCapabilities(provider) {
+  const { capabilities } = SANDBOX_PROVIDER_PROFILES[provider];
+  return GITTERM_PREVIEW_PROVIDERS.includes(provider) ? { ...capabilities, previews: "either" } : capabilities;
+}
+
+class SandboxAccountError extends GittermError {
+  constructor(message) {
+    super("FORBIDDEN", message);
+    this.name = "SandboxAccountError";
+  }
+}
+var ACCOUNT_LABEL = "gitterm_account";
+var WORKLOAD_LABEL = "gitterm_workload";
+var NAME_LABEL = "gitterm_name";
+function validateAccountName(name) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/.test(name))
+    throw new Error(`Invalid sandbox account name: ${JSON.stringify(name)}`);
+  return name;
+}
+function createDirectSandboxBackend(options) {
+  const account = validateAccountName(options.account);
+  const { transport } = options;
+  const identity = { mode: "direct", provider: transport.provider, account };
+  const toInfo = (info) => ({
+    ...identity,
+    id: info.id,
+    state: info.state,
+    name: info.labels[NAME_LABEL] ?? null,
+    createdAt: info.startedAt,
+    expiresAt: info.expiresAt,
+    labels: info.labels
+  });
+  const owned = async (id) => {
+    const info = await transport.info(id);
+    const ownedByAccount = info.labels[ACCOUNT_LABEL] === account || info.labels.gitterm_account_hash === accountHash(account);
+    if (info.state !== "terminated" && !ownedByAccount)
+      throw new SandboxAccountError(`Sandbox ${id} was not created by direct account ${JSON.stringify(account)}. Select the account that created it.`);
+    return info;
+  };
+  const running = async (id) => {
+    const info = await owned(id);
+    if (info.state === "terminated")
+      throw new SandboxProviderError("not_found", `Sandbox ${id} no longer exists.`);
+  };
+  return {
+    identity,
+    home: transport.home,
+    capabilities: transport.capabilities,
+    async create(input) {
+      if (transport.capabilities.expiry === "none" && !options.allowUnboundedLifetime)
+        throw new Error(`${transport.provider} never deletes an abandoned sandbox, so a crashed caller would leave it running and billing. Set "allowUnboundedLifetime": true on account ${account} to accept that and clean up with destroy, or use a managed account (the Gitterm worker enforces lifetimes).`);
+      return toInfo(await transport.create({
+        labels: {
+          ...input.labels,
+          [ACCOUNT_LABEL]: account,
+          [WORKLOAD_LABEL]: "sandbox",
+          [NAME_LABEL]: input.name.slice(0, 120)
+        },
+        timeoutMs: input.lifetimeMs,
+        onTimeout: "kill",
+        publicPreviews: input.publicPreviews,
+        ...input.snapshot ? { snapshot: input.snapshot } : {}
+      }));
+    },
+    async get(id) {
+      return toInfo(await owned(id));
+    },
+    async list() {
+      return (await transport.list({ [ACCOUNT_LABEL]: account, [WORKLOAD_LABEL]: "sandbox" })).map(toInfo);
+    },
+    async destroy(id) {
+      await owned(id);
+      await transport.destroy(id);
+    },
+    async run(id, command, runOptions) {
+      await running(id);
+      return transport.run(id, command, runOptions);
+    },
+    async writeFile(id, path, data) {
+      await running(id);
+      return transport.writeFile(id, path, data);
+    },
+    async readFile(id, path) {
+      await running(id);
+      return transport.readFile(id, path);
+    },
+    async preview(id, port) {
+      await running(id);
+      return transport.preview(id, port);
+    },
+    ...transport.snapshots ? {
+      snapshots: {
+        effect: transport.capabilities.snapshots,
+        async create(id, name) {
+          await running(id);
+          return transport.snapshots.create(id, name);
+        },
+        delete: (snapshotId) => transport.snapshots.delete(snapshotId)
+      }
+    } : {}
+  };
+}
+var MANAGED_CHUNK_BYTES = 6 * 1024 * 1024;
+function createManagedSandboxBackend(options) {
+  const account = validateAccountName(options.account);
+  const { client, provider } = options;
+  const identity = { mode: "managed", provider, account };
+  const toInfo = (sandbox) => {
+    if (sandbox.provider !== provider)
+      throw new SandboxAccountError(`Sandbox ${sandbox.id} runs on ${sandbox.provider}, but managed account ${JSON.stringify(account)} is configured for ${provider}.`);
+    return {
+      ...identity,
+      id: sandbox.id,
+      state: sandbox.status === "terminated" && !sandbox.deleted ? "deleting" : sandbox.status,
+      name: sandbox.name,
+      createdAt: sandbox.createdAt,
+      expiresAt: sandbox.expiresAt,
+      labels: sandbox.metadata
+    };
+  };
+  return {
+    identity,
+    home: SANDBOX_PROVIDER_PROFILES[provider].home,
+    capabilities: managedCapabilities(provider),
+    async create(input) {
+      return toInfo(await client.sandboxes.create({
+        provider,
+        name: input.name.slice(0, 120),
+        machine: options.machine,
+        lifetimeMinutes: Math.ceil(input.lifetimeMs / 60000),
+        publicPreviews: input.publicPreviews,
+        metadata: input.labels,
+        ...input.snapshot ? { snapshotId: input.snapshot } : {}
+      }));
+    },
+    async get(id) {
+      try {
+        return toInfo(await client.sandboxes.get(id));
+      } catch (error) {
+        if (error instanceof GittermError && error.code === "NOT_FOUND")
+          return {
+            ...identity,
+            id,
+            state: "terminated",
+            name: null,
+            createdAt: null,
+            expiresAt: null,
+            labels: {}
+          };
+        throw error;
+      }
+    },
+    async list() {
+      return (await client.sandboxes.list()).filter((sandbox) => sandbox.provider === provider).map(toInfo);
+    },
+    destroy: (id) => client.sandboxes.terminate(id),
+    resume: (id) => client.sandboxes.resume(id),
+    ...provider === "gitterm" ? { onJobFinished: (listener) => client.sandboxes.onJobFinished(listener) } : {},
+    run: (id, command, runOptions) => client.sandboxes.run(id, command, runOptions),
+    async writeFile(id, path, data) {
+      if (data.byteLength <= MANAGED_CHUNK_BYTES)
+        return client.sandboxes.writeFile(id, path, data);
+      const parts = [];
+      for (let offset = 0;offset < data.byteLength; offset += MANAGED_CHUNK_BYTES) {
+        const part = `${path}.part${parts.length}`;
+        await client.sandboxes.writeFile(id, part, data.subarray(offset, offset + MANAGED_CHUNK_BYTES));
+        parts.push(part);
+      }
+      const quoted = parts.map((part) => `'${part.replaceAll("'", `'"'"'`)}'`).join(" ");
+      const target = `'${path.replaceAll("'", `'"'"'`)}'`;
+      const joined = await client.sandboxes.run(id, `cat ${quoted} > ${target} && rm -f ${quoted}`);
+      if (joined.exitCode !== 0)
+        throw new Error("Could not assemble the uploaded file in the sandbox");
+    },
+    readFile: (id, path) => client.sandboxes.readFile(id, path),
+    preview: (id, port, previewOptions) => client.sandboxes.preview(id, port, previewOptions),
+    ...SANDBOX_PROVIDER_PROFILES[provider].capabilities.snapshots !== "none" ? {
+      snapshots: {
+        effect: SANDBOX_PROVIDER_PROFILES[provider].capabilities.snapshots,
+        create: async (id, name) => (await client.sandboxes.saveSnapshot(id, name)).id,
+        delete: (snapshotId) => client.sandboxes.deleteSnapshot(snapshotId)
+      }
+    } : {}
+  };
+}
+// src/sandbox/types.ts
+function isSandboxProviderError(error) {
+  return error instanceof Error && error.name === "SandboxProviderError" && "code" in error;
+}
+// src/sandbox/client.ts
+import path5 from "node:path";
+
+// src/sandbox/artifacts.ts
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { chmod, lstat as lstat2, mkdir, readFile as readFile2, realpath as realpath2, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path2 from "node:path";
+
+// src/sandbox/source.ts
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { lstat, readFile, readlink, realpath } from "node:fs/promises";
+import path from "node:path";
+
+// src/sandbox/tar.ts
+import { gzipSync } from "node:zlib";
+var BLOCK = 512;
+function octal(value, width) {
+  return value.toString(8).padStart(width - 1, "0") + "\x00";
+}
+function header(name, options) {
+  const block = Buffer.alloc(BLOCK);
+  block.write(name, 0, 100, "utf8");
+  block.write(octal(options.mode, 8), 100, "ascii");
+  block.write(octal(0, 8), 108, "ascii");
+  block.write(octal(0, 8), 116, "ascii");
+  block.write(octal(options.size, 12), 124, "ascii");
+  block.write(octal(0, 12), 136, "ascii");
+  block.write("        ", 148, "ascii");
+  block.write(options.type, 156, "ascii");
+  if (options.link)
+    block.write(options.link, 157, 100, "utf8");
+  block.write("ustar\x00", 257, "ascii");
+  block.write("00", 263, "ascii");
+  let sum = 0;
+  for (const byte of block)
+    sum += byte;
+  block.write(octal(sum, 7) + " ", 148, "ascii");
+  return block;
+}
+function paxRecord(key, value) {
+  const body = ` ${key}=${value}
+`;
+  const bytes = Buffer.byteLength(body);
+  let length = bytes + 1;
+  while (String(length).length + bytes !== length)
+    length = String(length).length + bytes;
+  return Buffer.from(`${length}${body}`);
+}
+function padded(data) {
+  const remainder = data.byteLength % BLOCK;
+  return remainder ? [Buffer.from(data), Buffer.alloc(BLOCK - remainder)] : [Buffer.from(data)];
+}
+function createTarGz(entries) {
+  const chunks = [];
+  for (const entry of entries) {
+    const link = entry.type === "symlink" ? entry.target : undefined;
+    const needsPax = Buffer.byteLength(entry.path) > 99 || /[^\x20-\x7e]/.test(entry.path) || link !== undefined && (Buffer.byteLength(link) > 99 || /[^\x20-\x7e]/.test(link));
+    if (needsPax) {
+      const records = Buffer.concat([
+        paxRecord("path", entry.path),
+        ...link !== undefined ? [paxRecord("linkpath", link)] : []
+      ]);
+      chunks.push(header("pax-header", { size: records.length, mode: 420, type: "x" }));
+      chunks.push(...padded(records));
+    }
+    const name = needsPax ? `gitterm-pax/${chunks.length}` : entry.path;
+    if (entry.type === "symlink") {
+      chunks.push(header(name, { size: 0, mode: 511, type: "2", link: needsPax ? "" : link }));
+    } else {
+      chunks.push(header(name, {
+        size: entry.data.byteLength,
+        mode: entry.executable ? 493 : 420,
+        type: "0"
+      }));
+      chunks.push(...padded(entry.data));
+    }
+  }
+  chunks.push(Buffer.alloc(BLOCK * 2));
+  return gzipSync(Buffer.concat(chunks));
+}
+
+// src/sandbox/source.ts
+var projectDir = (home) => `${home}/project`;
+var stateDir = (home) => `${home}/.gitterm/source`;
+var MAX_SOURCE_BYTES = 100 * 1024 * 1024;
+function git(cwd, args) {
+  return new Promise((resolve, reject) => {
+    execFile("git", ["-c", "core.quotePath=false", ...args], {
+      cwd,
+      encoding: "buffer",
+      maxBuffer: 64 * 1024 * 1024,
+      timeout: 60000,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0" }
+    }, (error, stdout) => error ? reject(new Error(`git ${args[0]} failed in the source checkout`)) : resolve(stdout));
+  });
+}
+var nulList = (buffer) => buffer.toString("utf8").split("\x00").filter(Boolean);
+function safeRelativePath(file) {
+  return Boolean(file) && !["\\", "\x00", `
+`, "\r"].some((character) => file.includes(character)) && !path.posix.isAbsolute(file) && file.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part.toLowerCase() !== ".git");
+}
+function sensitivePath(file) {
+  return /(^|\/)(\.env($|\.(?!(?:[^/]*\.)?(?:example|sample|template)$))|\.npmrc$|\.netrc$|\.pypirc$|id_(rsa|ed25519|ecdsa)($|\.)|credentials(?:\.json)?$)|\.(pem|p12|pfx|key)$/i.test(file);
+}
+var PRIVATE_KEY = /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----(?:\r?\n|(?:\\r)?\\n)(?:[A-Za-z-]+: [^\r\n]*(?:\r?\n|(?:\\r)?\\n))*(?:\r?\n|(?:\\r)?\\n)?[A-Za-z0-9+/]{16}/;
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\/?/g, "\x00").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replaceAll("\x00", ".*");
+  return new RegExp(glob.includes("/") ? `^${escaped}$` : `(^|/)${escaped}$`);
+}
+async function captureSource(directory, options = {}) {
+  let root;
+  try {
+    root = await realpath((await git(directory, ["rev-parse", "--show-toplevel"])).toString().trim());
+  } catch {
+    throw new Error("Sandbox sync needs a Git checkout so ignored files can be excluded.");
+  }
+  if ((await git(root, ["ls-files", "--unmerged", "-z"])).length)
+    throw new Error("Resolve merge conflicts before syncing to a sandbox.");
+  const staged = (await git(root, ["ls-files", "--stage", "-z"])).toString().split("\x00");
+  if (staged.some((line) => line.startsWith("160000 ")))
+    throw new Error("Submodules are not supported by sandbox sync yet.");
+  const head = await git(root, ["rev-parse", "--verify", "-q", "HEAD"]).then((value) => value.toString().trim()).catch(() => null);
+  const tracked = nulList(await git(root, ["ls-files", "-z", "--cached"]));
+  const deleted = new Set(nulList(await git(root, ["ls-files", "-z", "--deleted"])));
+  const modified = nulList(await git(root, ["ls-files", "-z", "--modified"])).filter((file) => !deleted.has(file));
+  const untracked = nulList(await git(root, ["ls-files", "-z", "--others", "--exclude-standard"]));
+  const exclude = (options.exclude ?? []).map(globToRegExp);
+  const maxBytes = options.maxBytes ?? MAX_SOURCE_BYTES;
+  const candidates = [...new Set([...tracked.filter((file) => !deleted.has(file)), ...untracked])].toSorted((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+  const files = [];
+  const entries = [];
+  const excluded = [];
+  let bytes = 0;
+  for (const file of candidates) {
+    if (!safeRelativePath(file)) {
+      excluded.push({ path: file, reason: "unsupported path" });
+      continue;
+    }
+    if (sensitivePath(file)) {
+      excluded.push({ path: file, reason: "secret-like file name" });
+      continue;
+    }
+    if (exclude.some((pattern) => pattern.test(file))) {
+      excluded.push({ path: file, reason: "excluded by configuration" });
+      continue;
+    }
+    const full = path.join(root, file);
+    const info = await lstat(full).catch(() => null);
+    if (!info)
+      continue;
+    if (info.isSymbolicLink()) {
+      const target = await readlink(full);
+      files.push({
+        path: file,
+        kind: "symlink",
+        size: 0,
+        sha256: createHash2("sha256").update(target).digest("hex")
+      });
+      entries.push({ path: file, type: "symlink", target });
+      continue;
+    }
+    if (!info.isFile()) {
+      excluded.push({ path: file, reason: "not a regular file" });
+      continue;
+    }
+    bytes += info.size;
+    if (bytes > maxBytes)
+      throw new Error(`Source exceeds the ${Math.round(maxBytes / 1024 / 1024)} MiB sandbox sync limit. Exclude build output or large files.`);
+    const data = await readFile(full);
+    if (PRIVATE_KEY.test(data.subarray(0, 4 * 1024 * 1024).toString("latin1"))) {
+      excluded.push({ path: file, reason: "contains private key material" });
+      bytes -= info.size;
+      continue;
+    }
+    const executable = Boolean(info.mode & 73);
+    files.push({
+      path: file,
+      kind: executable ? "executable" : "file",
+      size: data.byteLength,
+      sha256: createHash2("sha256").update(data).digest("hex")
+    });
+    entries.push({ path: file, type: "file", data, executable });
+  }
+  const digest = createHash2("sha256").update(manifestText(files)).digest("hex");
+  const included = new Set(files.map((file) => file.path));
+  return {
+    snapshot: {
+      id: `snap_${digest.slice(0, 16)}`,
+      digest,
+      root,
+      head,
+      files,
+      deleted: [...deleted].toSorted(),
+      modified: modified.filter((file) => included.has(file)),
+      untracked: untracked.filter((file) => included.has(file)),
+      excluded,
+      bytes
+    },
+    archive: createTarGz(entries)
+  };
+}
+function manifestText(files) {
+  return files.map((file) => `${file.kind} ${file.sha256} ${file.path}
+`).join("");
+}
+var q = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+async function uploadSource(backend, sandboxId, captured) {
+  const { snapshot, archive } = captured;
+  const STATE_DIR = stateDir(backend.home);
+  const PROJECT_DIR = projectDir(backend.home);
+  const base = `${STATE_DIR}/${snapshot.id}-${randomBytes(4).toString("hex")}`;
+  const list = snapshot.files.map((file) => `${file.path}
+`).join("");
+  const sums = snapshot.files.filter((file) => file.kind !== "symlink").map((file) => `${file.sha256}  ${file.path}
+`).join("");
+  const prepared = await backend.run(sandboxId, `mkdir -p ${q(STATE_DIR)} ${q(PROJECT_DIR)}`);
+  if (prepared.exitCode !== 0)
+    throw new Error("Could not prepare the sandbox for upload");
+  await backend.writeFile(sandboxId, `${base}.tgz`, archive);
+  await backend.writeFile(sandboxId, `${base}.files`, Buffer.from(list));
+  await backend.writeFile(sandboxId, `${base}.sha256`, Buffer.from(sums));
+  const result = await backend.run(sandboxId, [
+    "set -eu",
+    "export LC_ALL=C",
+    `B=${q(base)}; P=${q(PROJECT_DIR)}; S=${q(STATE_DIR)}`,
+    `trap 'rm -rf "$B.stage" "$B.tgz" "$B.sha256" "$B.files"' EXIT`,
+    'mkdir "$B.stage"',
+    'tar -xzf "$B.tgz" -C "$B.stage" --no-same-owner',
+    'for f in "$B.stage"/gitterm-pax/*; do [ -e "$f" ] || break; echo "unexpected pax placeholder" >&2; exit 4; done',
+    'verify() { [ ! -s "$B.sha256" ] || (cd "$1" && sha256sum -c --quiet --strict "$B.sha256"); }',
+    'verify "$B.stage" || { echo "staged files failed verification" >&2; exit 5; }',
+    'L="$S/publish.lock"; n=0',
+    'until mkdir "$L" 2>/dev/null; do',
+    '  if [ -n "$(find "$L" -maxdepth 0 -mmin +5 2>/dev/null)" ]; then rm -rf "$L"; continue; fi',
+    '  n=$((n + 1)); [ "$n" -lt 450 ] || { echo "another sync is still publishing" >&2; exit 7; }',
+    "  sleep 0.2",
+    "done",
+    `trap 'rm -rf "$B.stage" "$B.tgz" "$B.sha256" "$B.files" "$L"' EXIT`,
+    'sort -o "$B.files" "$B.files"',
+    'if [ -f "$S/current.files" ]; then comm -23 "$S/current.files" "$B.files" | while IFS= read -r f; do rm -f -- "$P/$f"; done; fi',
+    'while IFS= read -r f; do if [ -d "$P/$f" ] && [ ! -L "$P/$f" ]; then rm -rf -- "$P/$f"; fi; done < "$B.files"',
+    'cp -a "$B.stage/." "$P/"',
+    'verify "$P" || { echo "project files failed verification" >&2; exit 6; }',
+    'mv "$B.files" "$S/current.files"',
+    `printf %s ${q(snapshot.digest)} > "$S/current.digest"`,
+    "echo GITTERM_SOURCE_VERIFIED"
+  ].join(`
+`), { timeoutMs: 120000 });
+  if (result.exitCode !== 0 || !result.stdout.includes("GITTERM_SOURCE_VERIFIED"))
+    throw new Error(`Source upload failed verification in the sandbox (exit ${result.exitCode}). ${result.stderr.trim().slice(-300)}`);
+  return { verified: true, digest: snapshot.digest };
+}
+
+// src/sandbox/artifacts.ts
+var MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
+function artifactDirectory() {
+  const base = process.env.XDG_CACHE_HOME || path2.join(homedir(), ".cache");
+  return path2.join(base, "gitterm", "sandbox-artifacts");
+}
+var q2 = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+function remotePath(home, file) {
+  const resolved = file.startsWith("/") ? path2.posix.normalize(file) : path2.posix.join(projectDir(home), file);
+  if (resolved.includes("\x00") || resolved.split("/").includes(".."))
+    throw new Error("Invalid sandbox path");
+  return resolved;
+}
+async function fetchArtifact(backend, sandboxId, file, options = {}) {
+  const remote = remotePath(backend.home, file);
+  const maxBytes = options.maxBytes ?? MAX_ARTIFACT_BYTES;
+  const probe = await backend.run(sandboxId, `[ -f ${q2(remote)} ] || exit 3; wc -c < ${q2(remote)}; sha256sum ${q2(remote)} | cut -d' ' -f1`, { timeoutMs: 60000 });
+  if (probe.exitCode === 3)
+    throw new Error(`No regular file at ${remote} in the sandbox`);
+  if (probe.exitCode !== 0)
+    throw new Error("Could not inspect the artifact in the sandbox");
+  const [sizeLine, remoteHash] = probe.stdout.trim().split(`
+`);
+  if (Number(sizeLine) > maxBytes)
+    throw new Error(`Artifact is larger than ${Math.round(maxBytes / 1024 / 1024)} MiB`);
+  const data = await backend.readFile(sandboxId, remote);
+  const sha256 = createHash3("sha256").update(data).digest("hex");
+  if (sha256 !== remoteHash?.trim())
+    throw new Error(`${remote} changed while it was downloaded. Fetch it again once nothing is writing it.`);
+  const directory = path2.join(artifactDirectory(), `${backend.identity.mode}-${backend.identity.account}`, sandboxId);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const localPath = path2.join(directory, `${sha256.slice(0, 12)}-${path2.posix.basename(remote)}`);
+  await writeFile(localPath, data, { mode: 384 });
+  return {
+    remotePath: remote,
+    localPath,
+    sha256,
+    bytes: data.byteLength,
+    verified: true
+  };
+}
+
+class ArtifactConflictError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArtifactConflictError";
+  }
+}
+async function applyArtifact(input) {
+  if (!safeRelativePath(input.target))
+    throw new Error("Target must be a relative path inside the checkout");
+  const data = await readFile2(input.artifact.localPath);
+  if (createHash3("sha256").update(data).digest("hex") !== input.artifact.sha256)
+    throw new ArtifactConflictError("The fetched artifact changed on disk since it was downloaded.");
+  const root = await realpath2(input.snapshot.root);
+  const parts = input.target.split("/");
+  let directory = root;
+  for (const part of parts.slice(0, -1)) {
+    directory = path2.join(directory, part);
+    const info = await lstat2(directory).catch(() => null);
+    if (!info)
+      await mkdir(directory);
+    else if (info.isSymbolicLink() || !info.isDirectory())
+      throw new ArtifactConflictError(`${path2.relative(root, directory)} is not a directory inside the checkout.`);
+  }
+  const destination = path2.join(directory, parts.at(-1));
+  const expected = input.snapshot.files.find((file) => file.path === input.target);
+  const current = await lstat2(destination).catch(() => null);
+  if (current?.isSymbolicLink() || current && !current.isFile())
+    throw new ArtifactConflictError(`${input.target} is not a regular file locally.`);
+  const currentHash = current ? createHash3("sha256").update(await readFile2(destination)).digest("hex") : null;
+  if ((expected?.sha256 ?? null) !== currentHash)
+    throw new ArtifactConflictError(`${input.target} changed locally since snapshot ${input.snapshot.id}. Sync again and rerun before applying.`);
+  const temporary = path2.join(directory, `.gitterm-${randomBytes2(6).toString("hex")}`);
+  try {
+    await writeFile(temporary, data, { flag: "wx" });
+    if (current)
+      await chmod(temporary, current.mode & 4095);
+    if (await realpath2(directory) !== directory)
+      throw new ArtifactConflictError("The checkout changed while applying the artifact.");
+    await rename(temporary, destination);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+  return { path: input.target, sha256: input.artifact.sha256 };
+}
+
+// src/sandbox/jobs.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+var jobRoot = (home) => `${home}/.gitterm/jobs`;
+var q3 = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+function newJobId() {
+  return `job_${randomBytes3(10).toString("hex")}`;
+}
+function jobDir(backend, id) {
+  if (!/^job_[a-f0-9]{20}$/.test(id))
+    throw new Error(`Invalid job id: ${id}`);
+  return `${jobRoot(backend.home)}/${id}`;
+}
+var NOW = "date -u +%Y-%m-%dT%H:%M:%S.%3NZ";
+var LIVENESS = `group_alive() {
+  g=$1
+  for s in /proc/[0-9]*/stat; do
+    read -r line < "$s" 2>/dev/null || continue
+    set -- \${line##*) }
+    [ "$3" = "$g" ] || continue
+    [ "$1" = Z ] || return 0
+  done
+  return 1
+}
+pid_alive() {
+  read -r line < "/proc/$1/stat" 2>/dev/null || return 1
+  set -- \${line##*) }
+  [ "$1" != Z ]
+}`;
+var RUNNER = `J="$1"; T="$2"; C="$3"
+${LIVENESS}
+echo $$ > "$J/runner.pid"
+exec > "$J/output.log" 2>&1 < /dev/null
+# On gitterm.dev, Gitterm's own sandboxes have ~/.gitterm/callback.env, so a finished job is
+# reported at once instead of polled. No other sandbox has the file, so nothing is sent.
+report() {
+  F="$J/../../callback.env"
+  [ -r "$F" ] || return 0
+  ( . "$F"
+    S=failed; [ "$1" = 0 ] && S=succeeded
+    [ -e "$J/timed_out" ] && S=timed_out; [ -e "$J/cancelled" ] && S=cancelled
+    B="{\\"sandboxId\\":\\"$GITTERM_CALLBACK_SANDBOX\\",\\"jobId\\":\\"$(basename "$J")\\",\\"status\\":\\"$S\\",\\"exitCode\\":$1}"
+    for i in 1 2 3; do
+      if command -v curl >/dev/null 2>&1; then
+        curl -fsS -m 10 -H "authorization: Bearer $GITTERM_CALLBACK_TOKEN" -H "content-type: application/json" -d "$B" "$GITTERM_CALLBACK_URL" >/dev/null 2>&1 && break
+      elif command -v wget >/dev/null 2>&1; then
+        wget -q -T 10 -O /dev/null --header="authorization: Bearer $GITTERM_CALLBACK_TOKEN" --header="content-type: application/json" --post-data="$B" "$GITTERM_CALLBACK_URL" && break
+      else break; fi
+      sleep "$i"
+    done ) > /dev/null 2>&1 || true
+}
+finish() { ${NOW} > "$J/finished"; echo "$1" > "$J/exit.tmp"; mv "$J/exit.tmp" "$J/exit"; report "$1"; exit "$1"; }
+cd "$C" 2>/dev/null || { echo "gitterm: working directory not found: $C"; finish 127; }
+if [ -s "$J/secret-names" ]; then
+  setsid -w sh -c 'echo $$ > "$0/pgid"; . "$0/env.sh"; { sh "$0/command.sh"; echo $? > "$0/command-exit"; } 2>&1 | awk -v names="$0/secret-names" -f "$0/redact.awk"; [ -e "$0/command-exit" ] && exit "$(cat "$0/command-exit")"; exit 143' "$J" &
+else
+  setsid -w sh -c 'echo $$ > "$0/pgid"; . "$0/env.sh"; exec sh "$0/command.sh"' "$J" &
+fi
+child=$!
+setsid sh -c 'sleep "$1"; [ -e "$0/exit" ] && exit 0; : > "$0/timed_out"; P=$(cat "$0/pgid"); kill -TERM -"$P" 2>/dev/null; sleep 10; kill -KILL -"$P" 2>/dev/null' "$J" "$T" > /dev/null 2>&1 &
+dog=$!
+wait "$child"; code=$?
+P=$(cat "$J/pgid" 2>/dev/null || true)
+if [ -n "$P" ] && group_alive "$P"; then
+  kill -TERM -"$P" 2>/dev/null
+  i=0; while [ $i -lt 50 ] && group_alive "$P"; do sleep 0.1; i=$((i+1)); done
+  kill -KILL -"$P" 2>/dev/null
+fi
+kill -TERM -"$dog" 2>/dev/null || kill "$dog" 2>/dev/null
+finish "$code"
+`;
+var REDACT_AWK = `BEGIN { while ((getline name < names) > 0) if ((name in ENVIRON) && length(ENVIRON[name]) >= 4) secret[++n] = ENVIRON[name] }
+{
+  line = $0
+  for (i = 1; i <= n; i++) {
+    out = ""
+    while ((at = index(line, secret[i])) > 0) { out = out substr(line, 1, at - 1) "[redacted]"; line = substr(line, at + length(secret[i])) }
+    line = out line
+  }
+  print line
+  fflush()
+}
+`;
+function assertRedactableSecrets(env = {}) {
+  for (const [name, value] of Object.entries(env)) {
+    if (/[\r\n]/.test(value))
+      throw new Error(`${name} contains a line break, which cannot be redacted from output. Base64-encode it and decode it in the command, e.g. "$(printf %s "$${name}" | base64 -d)".`);
+    if (value.length < 4)
+      throw new Error(`${name} is shorter than 4 characters and cannot be redacted reliably.`);
+  }
+}
+function envScript(env = {}) {
+  return Object.entries(env).map(([key, value]) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+      throw new Error(`Invalid variable name: ${key}`);
+    return `export ${key}=${q3(value)}`;
+  }).join(`
+`);
+}
+async function startJob(backend, sandboxId, id, input) {
+  assertRedactableSecrets(input.env);
+  const dir = jobDir(backend, id);
+  const seconds = Math.max(1, Math.ceil(input.timeoutMs / 1000));
+  const prepared = await backend.run(sandboxId, `mkdir -p ${q3(dir)} && chmod 700 ${q3(dir)} && [ ! -e ${q3(`${dir}/started`)} ]`, { timeoutMs: 30000 });
+  if (prepared.exitCode !== 0)
+    throw new Error(`Could not prepare job ${id} in the sandbox`);
+  await backend.writeFile(sandboxId, `${dir}/env.sh`, Buffer.from(envScript(input.env)));
+  await backend.writeFile(sandboxId, `${dir}/command.sh`, Buffer.from(input.command));
+  const names = Object.keys(input.env ?? {});
+  if (names.length) {
+    await backend.writeFile(sandboxId, `${dir}/secret-names`, Buffer.from(`${names.join(`
+`)}
+`));
+    await backend.writeFile(sandboxId, `${dir}/redact.awk`, Buffer.from(REDACT_AWK));
+  }
+  await backend.writeFile(sandboxId, `${dir}/runner.sh`, Buffer.from(RUNNER));
+  const launched = await backend.run(sandboxId, [
+    `set -e`,
+    `cd ${q3(dir)}`,
+    `chmod 600 env.sh`,
+    `[ ! -e started ] || { echo "job already started" >&2; exit 17; }`,
+    `${NOW} > started`,
+    `nohup setsid sh runner.sh ${q3(dir)} ${seconds} ${q3(input.cwd)} > /dev/null 2>&1 < /dev/null &`,
+    `i=0; until [ -s runner.pid ]; do i=$((i+1)); [ $i -le 100 ] || { echo "the job runner did not start" >&2; exit 1; }; sleep 0.1; done`,
+    `echo started`
+  ].join(`
+`), { timeoutMs: 30000 });
+  if (launched.exitCode !== 0)
+    throw new Error(`Could not start the job in the sandbox (exit ${launched.exitCode})`);
+}
+async function readJobState(backend, sandboxId, id) {
+  const dir = jobDir(backend, id);
+  const result = await backend.run(sandboxId, [
+    LIVENESS,
+    `J=${q3(dir)}`,
+    `[ -e "$J/started" ] || { echo missing=1; exit 0; }`,
+    `echo "started=$(cat "$J/started")"`,
+    `echo "finished=$(cat "$J/finished" 2>/dev/null)"`,
+    `echo "exit=$(cat "$J/exit" 2>/dev/null)"`,
+    `[ ! -e "$J/cancelled" ] || echo cancelled=1`,
+    `[ ! -e "$J/timed_out" ] || echo timed_out=1`,
+    `P=$(cat "$J/pgid" 2>/dev/null || true)`,
+    `[ -z "$P" ] || ! group_alive "$P" || echo group_alive=1`,
+    `R=$(cat "$J/runner.pid" 2>/dev/null || true)`,
+    `[ -z "$R" ] || ! pid_alive "$R" || echo runner_alive=1`,
+    `echo "log_bytes=$(wc -c < "$J/output.log" 2>/dev/null || echo 0)"`
+  ].join(`
+`), { timeoutMs: 30000 });
+  if (result.exitCode !== 0)
+    throw new Error("Could not read job state from the sandbox");
+  const values = Object.fromEntries(result.stdout.split(`
+`).filter((line) => line.includes("=")).map((line) => [line.slice(0, line.indexOf("=")), line.slice(line.indexOf("=") + 1).trim()]));
+  if (values.missing)
+    return null;
+  const exitCode = values.exit ? Number(values.exit) : null;
+  const status = exitCode !== null ? values.cancelled ? "cancelled" : values.timed_out ? "timed_out" : exitCode === 0 ? "succeeded" : "failed" : values.runner_alive ? "running" : "lost";
+  return {
+    id,
+    status,
+    exitCode,
+    startedAt: values.started || null,
+    finishedAt: values.finished || null,
+    processAlive: Boolean(values.group_alive),
+    logBytes: Number(values.log_bytes) || 0
+  };
+}
+async function readJobLog(backend, sandboxId, id, offset, limit) {
+  if (!Number.isSafeInteger(offset) || offset < 0)
+    throw new Error("Invalid log offset");
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1024 * 1024)
+    throw new Error("Log reads are limited to 1 MiB");
+  const result = await backend.run(sandboxId, `tail -c +${offset + 1} ${q3(`${jobDir(backend, id)}/output.log`)} 2>/dev/null | head -c ${limit} | base64 | tr -d '\\n'`, { timeoutMs: 30000 });
+  if (result.exitCode !== 0)
+    throw new Error("Could not read the job log");
+  return Buffer.from(result.stdout.trim(), "base64");
+}
+async function cancelJob(backend, sandboxId, id, graceSeconds = 5) {
+  const dir = jobDir(backend, id);
+  const result = await backend.run(sandboxId, [
+    LIVENESS,
+    `J=${q3(dir)}`,
+    `[ -e "$J/started" ] || { echo "unknown job" >&2; exit 3; }`,
+    `P=$(cat "$J/pgid" 2>/dev/null || true)`,
+    `if [ -e "$J/exit" ]; then [ -n "$P" ] && group_alive "$P" || exit 0; else : > "$J/cancelled"; fi`,
+    `[ -n "$P" ] || exit 0`,
+    `kill -TERM -"$P" 2>/dev/null || true`,
+    `i=0; while [ $i -lt ${graceSeconds * 10} ] && group_alive "$P"; do sleep 0.1; i=$((i+1)); done`,
+    `kill -KILL -"$P" 2>/dev/null || true`,
+    `i=0; while [ $i -lt 50 ] && [ ! -e "$J/exit" ]; do sleep 0.1; i=$((i+1)); done`
+  ].join(`
+`), { timeoutMs: (graceSeconds + 15) * 1000 });
+  if (result.exitCode === 3)
+    throw new Error(`Unknown job ${id}`);
+  if (result.exitCode !== 0)
+    throw new Error("Could not cancel the job");
+}
+
+// src/sandbox/setup-snapshots.ts
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import path4 from "node:path";
+
+// src/sandbox/store.ts
+import { createHash as createHash4, randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir2, readdir, readFile as readFile3, rename as rename2, rm as rm2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path3 from "node:path";
+function defaultStoreDirectory() {
+  const base = process.env.XDG_STATE_HOME || path3.join(homedir2(), ".local", "state");
+  return path3.join(base, "gitterm", "sandboxes");
+}
+var fileName = (ref) => `${ref.mode}-${ref.provider}-${ref.account}-${ref.id}`.replace(/[^A-Za-z0-9_.-]/g, "_") + ".json";
+var snapshotFile = (id, root) => `${id.replace(/[^A-Za-z0-9_]/g, "")}-${createHash4("sha256").update(root).digest("hex").slice(0, 16)}.json`;
+var LOCK_STALE_MS = 30000;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function withFileLock(target, action) {
+  const lock = `${target}.lock`;
+  const deadline = Date.now() + 2 * LOCK_STALE_MS;
+  while (true) {
+    try {
+      await writeFile2(lock, String(process.pid), { flag: "wx", mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      const age = await stat(lock).then((info) => Date.now() - info.mtimeMs, () => 0);
+      if (age > LOCK_STALE_MS)
+        await rm2(lock, { force: true });
+      else if (Date.now() > deadline)
+        throw new Error(`Timed out waiting for ${lock}`);
+      else
+        await sleep(5 + Math.random() * 20);
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    await rm2(lock, { force: true });
+  }
+}
+function createFileSandboxStore(directory = defaultStoreDirectory()) {
+  const read = async (file) => JSON.parse(await readFile3(path3.join(directory, file), "utf8"));
+  const write = async (target, record) => {
+    const temporary = `${target}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`;
+    try {
+      await writeFile2(temporary, JSON.stringify(record, null, 2), { mode: 384 });
+      await rename2(temporary, target);
+    } finally {
+      await rm2(temporary, { force: true });
+    }
+  };
+  const queues = new Map;
+  const serialized = (target, action) => {
+    const next = (queues.get(target) ?? Promise.resolve()).catch(() => {}).then(() => withFileLock(target, action));
+    queues.set(target, next);
+    next.then(() => queues.get(target) === next && queues.delete(target), () => queues.get(target) === next && queues.delete(target));
+    return next;
+  };
+  return {
+    async list() {
+      const files = await readdir(directory).catch(() => []);
+      const records = await Promise.all(files.filter((file) => file.endsWith(".json")).map((file) => read(file).catch(() => null)));
+      return records.filter((record) => record !== null);
+    },
+    async get(ref) {
+      return read(fileName(ref)).catch(() => null);
+    },
+    async put(record) {
+      await mkdir2(directory, { recursive: true, mode: 448 });
+      const target = path3.join(directory, fileName(record));
+      await serialized(target, () => write(target, record));
+    },
+    async update(ref, mutate, create) {
+      await mkdir2(directory, { recursive: true, mode: 448 });
+      const target = path3.join(directory, fileName(ref));
+      return serialized(target, async () => {
+        const current = await read(fileName(ref)).catch(() => null) ?? create?.() ?? null;
+        if (!current)
+          return null;
+        mutate(current);
+        current.updatedAt = new Date().toISOString();
+        await write(target, current);
+        return current;
+      });
+    },
+    async remove(ref) {
+      await rm2(path3.join(directory, fileName(ref)), { force: true });
+    },
+    async putSnapshot(snapshot) {
+      const target = path3.join(directory, "snapshots", snapshotFile(snapshot.id, snapshot.root));
+      await mkdir2(path3.dirname(target), { recursive: true, mode: 448 });
+      await writeFile2(target, JSON.stringify(snapshot), { mode: 384 });
+    },
+    async getSnapshot(id, root) {
+      return readFile3(path3.join(directory, "snapshots", snapshotFile(id, root)), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    }
+  };
+}
+
+// src/sandbox/setup-snapshots.ts
+var SETUP_FILES = [
+  "package.json",
+  "bun.lock",
+  "bun.lockb",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  ".nvmrc",
+  ".node-version",
+  ".tool-versions",
+  ".python-version",
+  "requirements.txt",
+  "requirements-dev.txt",
+  "pyproject.toml",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "Cargo.lock",
+  "go.sum",
+  "Gemfile.lock",
+  "composer.lock",
+  "mix.lock",
+  "pubspec.lock",
+  "Dockerfile",
+  "docker-compose.yml",
+  "compose.yaml"
+];
+async function setupFingerprint(project) {
+  const entries = await Promise.all(SETUP_FILES.map(async (file) => {
+    const data = await readFile4(path4.join(project, file)).catch(() => null);
+    return data ? [file, createHash5("sha256").update(data).digest("hex").slice(0, 16)] : null;
+  }));
+  return Object.fromEntries(entries.filter((entry) => entry !== null));
+}
+function changedSetupFiles(saved, current) {
+  return [...new Set([...Object.keys(saved), ...Object.keys(current)])].filter((file) => saved[file] !== current[file]).toSorted();
+}
+function setupSnapshotName(label, project) {
+  const slug = (text) => text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+  const scope = project ? `${slug(path4.basename(project)) || "project"}-${createHash5("sha256").update(project).digest("hex").slice(0, 8)}` : "shared";
+  return `gitterm-setup-${scope}-${slug(label) || "setup"}-${Date.now().toString(36)}`;
+}
+function createFileSetupSnapshotStore(directory = path4.join(defaultStoreDirectory(), "setup-snapshots")) {
+  const prefix = (identity) => `${identity.mode}-${identity.provider}-${identity.account}-`.replace(/[^A-Za-z0-9_.-]/g, "_");
+  const file = (identity, snapshotId) => path4.join(directory, `${prefix(identity)}${createHash5("sha256").update(snapshotId).digest("hex").slice(0, 16)}.json`);
+  return {
+    async list(identity) {
+      const names = (await readdir2(directory).catch(() => [])).filter((name) => name.startsWith(prefix(identity)) && name.endsWith(".json"));
+      const records = await Promise.all(names.map((name) => readFile4(path4.join(directory, name), "utf8").then((text) => JSON.parse(text)).catch(() => null)));
+      return records.filter((record) => record !== null).toSorted((a, b) => b.createdAt.localeCompare(a.createdAt));
+    },
+    async put(record) {
+      await mkdir3(directory, { recursive: true, mode: 448 });
+      await writeFile3(file(record, record.snapshotId), JSON.stringify(record, null, 2), {
+        mode: 384
+      });
+    },
+    async remove(identity, snapshotId) {
+      await rm3(file(identity, snapshotId), { force: true });
+    }
+  };
+}
+
+// src/sandbox/client.ts
+var DEFAULT_SANDBOX_LIMITS = {
+  maxSandboxes: 2,
+  maxLifetimeMinutes: 60,
+  defaultLifetimeMinutes: 30,
+  maxJobMinutes: 30
+};
+var DEFAULT_LOG_TAIL_BYTES = 8 * 1024;
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function sanitizeOutput(text, secrets = []) {
+  let clean = text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+  for (const secret of secrets)
+    if (secret.length >= 4)
+      clean = clean.replaceAll(secret, "[redacted]");
+  return clean;
+}
+function resolveCwd(home, cwd) {
+  if (!cwd)
+    return projectDir(home);
+  const resolved = cwd.startsWith("/") ? path5.posix.normalize(cwd) : path5.posix.join(projectDir(home), cwd);
+  if (resolved.split("/").includes(".."))
+    throw new Error("Invalid working directory");
+  return resolved;
+}
+function createSandboxClient(options) {
+  const { backend } = options;
+  const identity = backend.identity;
+  const store = options.store ?? createFileSandboxStore();
+  const setupSnapshots = options.setupSnapshots ?? createFileSetupSnapshotStore();
+  const limits = { ...DEFAULT_SANDBOX_LIMITS, ...options.limits };
+  const secrets = new Set;
+  function assertRef(ref) {
+    if (ref.mode !== identity.mode || ref.provider !== identity.provider || ref.account !== identity.account)
+      throw new SandboxAccountError(`Sandbox ${ref.id} belongs to ${ref.mode} account ${JSON.stringify(ref.account)} (${ref.provider}), but ${identity.mode} account ${JSON.stringify(identity.account)} is selected. Select that account; Gitterm will not switch accounts automatically.`);
+  }
+  const refOf = (id) => ({ ...identity, id });
+  function recordFrom(info, existing) {
+    return {
+      ...existing ?? {
+        name: info.name ?? info.id,
+        purpose: info.labels.gitterm_purpose ?? "",
+        project: null,
+        sessionId: null,
+        publicPreviews: false,
+        createdAt: info.createdAt ?? new Date().toISOString(),
+        snapshot: null,
+        jobs: {},
+        previews: {}
+      },
+      ...refOf(info.id),
+      state: info.state,
+      expiresAt: info.expiresAt ?? existing?.expiresAt ?? null,
+      updatedAt: new Date().toISOString()
+    };
+  }
+  const applyInfo = (info) => (record) => {
+    record.state = info.state;
+    record.expiresAt = info.expiresAt ?? record.expiresAt;
+  };
+  async function load(ref) {
+    assertRef(ref);
+    const info = await backend.get(ref.id);
+    const stored = await store.update(ref, applyInfo(info), () => info.state === "terminated" ? null : recordFrom(info, null));
+    return stored ?? recordFrom(info, null);
+  }
+  async function resumeSandbox(ref, resume) {
+    await resume(ref.id);
+    const record = await settled(ref);
+    if (record.state !== "running" || backend.capabilities.pause !== "state-losing")
+      return { record, filesLost: false };
+    const cleared = await store.update(ref, (stored) => {
+      stored.snapshot = null;
+    });
+    return { record: cleared ?? record, filesLost: true };
+  }
+  async function settled(ref) {
+    const deadline = Date.now() + 120000;
+    let record = await load(ref);
+    while (record.state === "pending" && Date.now() < deadline) {
+      await sleep2(1000);
+      record = await load(ref);
+    }
+    return record;
+  }
+  async function running(ref, use = "other") {
+    let record = await settled(ref);
+    if (record.state === "paused" && backend.resume) {
+      const resumed = await resumeSandbox(ref, backend.resume);
+      record = resumed.record;
+      if (resumed.filesLost && use !== "sync")
+        throw new Error(`Sandbox ${ref.id} was paused and is running again, but ${ref.provider} discards files and processes on pause. Sync again, then retry; earlier jobs cannot be reattached.`);
+    }
+    if (record.state === "terminated")
+      throw new SandboxProviderError("not_found", `Sandbox ${ref.id} no longer exists (deleted or expired).`);
+    if (record.state !== "running")
+      throw new Error(`Sandbox ${ref.id} is ${record.state}.`);
+    return record;
+  }
+  async function view(record, jobId, read) {
+    const job = record.jobs[jobId];
+    if (!job)
+      throw new Error(`Unknown job ${jobId} for sandbox ${record.id}`);
+    const state = await readJobState(backend, record.id, jobId);
+    if (!state)
+      throw new Error(`Job ${jobId} was not found in the sandbox`);
+    const limit = Math.min(read.limit ?? read.tailBytes ?? DEFAULT_LOG_TAIL_BYTES, 1024 * 1024);
+    const offset = read.offset ?? Math.max(0, state.logBytes - limit);
+    const bytes = state.logBytes > offset ? await readJobLog(backend, record.id, jobId, offset, limit) : Buffer.alloc(0);
+    const progress = {
+      status: state.status,
+      exitCode: state.exitCode,
+      startedAt: state.startedAt,
+      finishedAt: state.finishedAt
+    };
+    Object.assign(job, progress);
+    await store.update(record, (stored) => {
+      if (stored.jobs[jobId])
+        Object.assign(stored.jobs[jobId], progress);
+    });
+    return {
+      job,
+      state,
+      log: {
+        text: sanitizeOutput(bytes.toString("utf8"), [...secrets]),
+        offset,
+        nextOffset: offset + bytes.byteLength,
+        totalBytes: state.logBytes,
+        truncated: offset > 0 || offset + bytes.byteLength < state.logBytes
+      }
+    };
+  }
+  async function launchJob(ref, input, maxMinutes) {
+    const record = await running(ref);
+    const timeoutMinutes = input.timeoutMinutes ?? Math.min(10, maxMinutes);
+    if (!(timeoutMinutes > 0) || timeoutMinutes > maxMinutes)
+      throw new Error(`Job timeout must be between 0 and ${maxMinutes} minutes`);
+    assertRedactableSecrets(input.env);
+    for (const value of Object.values(input.env ?? {}))
+      secrets.add(value);
+    const id = newJobId();
+    const cwd = resolveCwd(backend.home, input.cwd);
+    const job = {
+      id,
+      command: input.command,
+      cwd,
+      snapshotId: record.snapshot?.id ?? null,
+      snapshotDigest: record.snapshot?.digest ?? null,
+      snapshotRoot: record.snapshot?.root ?? null,
+      status: "running",
+      exitCode: null,
+      startedAt: null,
+      finishedAt: null,
+      timeoutMs: Math.round(timeoutMinutes * 60000),
+      secretNames: Object.keys(input.env ?? {}),
+      sessionId: input.sessionId ?? null
+    };
+    await store.update(record, (stored) => {
+      stored.jobs[id] = job;
+    });
+    await startJob(backend, ref.id, id, {
+      command: input.command,
+      cwd,
+      timeoutMs: job.timeoutMs,
+      env: input.env
+    });
+    return api.wait(ref, id, input.waitMs ?? 0);
+  }
+  const api = {
+    identity,
+    home: backend.home,
+    capabilities: backend.capabilities,
+    limits,
+    store,
+    onJobFinished: backend.onJobFinished?.bind(backend),
+    async create(input) {
+      const lifetimeMinutes = input.lifetimeMinutes ?? limits.defaultLifetimeMinutes;
+      if (!Number.isInteger(lifetimeMinutes) || lifetimeMinutes < 1)
+        throw new Error("Lifetime must be a whole number of minutes");
+      if (lifetimeMinutes > limits.maxLifetimeMinutes)
+        throw new Error(`Lifetime ${lifetimeMinutes} min exceeds the approved limit of ${limits.maxLifetimeMinutes} min`);
+      const live = (await backend.list()).filter((item) => item.state !== "terminated");
+      if (live.length >= limits.maxSandboxes)
+        throw new Error(`Account ${identity.account} already has ${live.length} live sandbox(es); the approved limit is ${limits.maxSandboxes}. Destroy one first.`);
+      const info = await backend.create({
+        name: input.name,
+        lifetimeMs: lifetimeMinutes * 60000,
+        publicPreviews: input.publicPreviews === true,
+        ...input.snapshot ? { snapshot: input.snapshot } : {},
+        labels: {
+          ...input.purpose ? { gitterm_purpose: input.purpose.slice(0, 120) } : {},
+          ...input.sessionId ? { gitterm_session: input.sessionId.slice(0, 120) } : {}
+        }
+      });
+      const record = {
+        ...recordFrom(info, null),
+        name: input.name,
+        purpose: input.purpose ?? "",
+        project: input.project ?? null,
+        sessionId: input.sessionId ?? null,
+        publicPreviews: input.publicPreviews === true,
+        createdAt: info.createdAt ?? new Date().toISOString()
+      };
+      try {
+        await store.put(record);
+        const prepared = await backend.run(info.id, `mkdir -p '${projectDir(backend.home)}'`, {
+          timeoutMs: 30000
+        });
+        if (prepared.exitCode !== 0)
+          throw new Error("Could not prepare the sandbox project directory");
+      } catch (error) {
+        await backend.destroy(info.id).catch(() => {});
+        await store.remove(record).catch(() => {});
+        throw error;
+      }
+      return record;
+    },
+    async list() {
+      const remote = new Map((await backend.list()).map((item) => [item.id, item]));
+      const records = [];
+      for (const record of await store.list()) {
+        if (record.mode !== identity.mode || record.provider !== identity.provider || record.account !== identity.account)
+          continue;
+        const info = remote.get(record.id) ?? (record.state === "terminated" ? null : await backend.get(record.id));
+        remote.delete(record.id);
+        records.push(info ? await store.update(record, applyInfo(info)) ?? record : record);
+      }
+      for (const info of remote.values()) {
+        const record = recordFrom(info, null);
+        records.push(await store.update(record, applyInfo(info), () => record) ?? record);
+      }
+      return records;
+    },
+    get: load,
+    async sync(ref, captured) {
+      const record = await running(ref, "sync");
+      await store.putSnapshot(captured.snapshot);
+      const result = await uploadSource(backend, ref.id, captured);
+      await store.update(record, (stored) => {
+        stored.snapshot = {
+          id: captured.snapshot.id,
+          digest: result.digest,
+          root: captured.snapshot.root,
+          syncedAt: new Date().toISOString()
+        };
+      });
+      return { snapshot: captured.snapshot, verified: result.verified };
+    },
+    exec: (ref, input) => launchJob(ref, input, limits.maxJobMinutes),
+    async wait(ref, jobId, waitMs, read = {}) {
+      const deadline = Date.now() + Math.max(0, waitMs);
+      while (true) {
+        const result = await view(await running(ref), jobId, read);
+        if (result.state.status !== "running" || Date.now() >= deadline)
+          return result;
+        await sleep2(Math.min(2000, Math.max(250, deadline - Date.now())));
+      }
+    },
+    async job(ref, jobId, read = {}) {
+      return view(await running(ref), jobId, read);
+    },
+    async cancel(ref, jobId) {
+      const record = await running(ref);
+      if (!record.jobs[jobId])
+        throw new Error(`Unknown job ${jobId} for sandbox ${ref.id}`);
+      await cancelJob(backend, ref.id, jobId);
+      return view(record, jobId, {});
+    },
+    async preview(ref, input) {
+      const record = await running(ref);
+      if (backend.capabilities.previews === "none")
+        throw new Error(`${ref.provider} sandboxes cannot expose ports.`);
+      if (backend.capabilities.previews === "public" && !record.publicPreviews)
+        throw new Error(`${ref.provider} previews are reachable by anyone with the URL. Create the sandbox with publicPreviews to approve that.`);
+      let jobId = null;
+      if (input.command) {
+        const minutes = Math.max(limits.maxJobMinutes, record.expiresAt ? (Date.parse(record.expiresAt) - Date.now()) / 60000 : 0);
+        jobId = (await launchJob(ref, { command: input.command, cwd: input.cwd, timeoutMinutes: minutes }, minutes)).job.id;
+      }
+      const { gittermUrl, ...access } = await backend.preview(ref.id, input.port, {
+        public: record.publicPreviews
+      });
+      const url = gittermUrl ?? access.url;
+      const isPublic = backend.capabilities.previews === "public" || backend.capabilities.previews === "either" && record.publicPreviews;
+      const deadline = Date.now() + (input.readyTimeoutMs ?? 60000);
+      let ready = false;
+      while (!ready && Date.now() < deadline) {
+        const status = await fetch(access.url, {
+          headers: access.headers,
+          redirect: "manual",
+          signal: AbortSignal.timeout(5000)
+        }).then(async (response) => {
+          await response.body?.cancel();
+          return response.status;
+        }).catch(() => 0);
+        ready = status > 0 && ![502, 503, 504].includes(status);
+        if (!ready) {
+          if (jobId) {
+            const state = await readJobState(backend, ref.id, jobId);
+            if (state && state.status !== "running")
+              throw new Error(`Preview command exited (${state.status}, exit ${state.exitCode}) before port ${input.port} answered. Read job ${jobId} logs.`);
+          }
+          await sleep2(1000);
+        }
+      }
+      const unauthenticatedStatus = await fetch(url, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(5000)
+      }).then(async (response) => {
+        await response.body?.cancel();
+        return response.status;
+      }).catch(() => null);
+      await store.update(record, (stored) => {
+        stored.previews[String(input.port)] = {
+          port: input.port,
+          jobId,
+          url,
+          public: isPublic
+        };
+      });
+      return {
+        url,
+        port: input.port,
+        public: isPublic,
+        viaGitterm: Boolean(gittermUrl),
+        access,
+        ready,
+        unauthenticatedStatus,
+        jobId
+      };
+    },
+    async fetchArtifact(ref, file, producedBy) {
+      const record = await running(ref);
+      if (!record.jobs[producedBy.jobId])
+        throw new Error(`Unknown job ${producedBy.jobId} for sandbox ${ref.id}`);
+      const artifact = await fetchArtifact(backend, ref.id, file);
+      await store.update(record, (stored) => {
+        stored.artifacts = {
+          ...stored.artifacts,
+          [artifact.localPath]: {
+            localPath: artifact.localPath,
+            remotePath: artifact.remotePath,
+            sha256: artifact.sha256,
+            bytes: artifact.bytes,
+            jobId: producedBy.jobId,
+            fetchedAt: new Date().toISOString()
+          }
+        };
+      });
+      return { ...artifact, jobId: producedBy.jobId };
+    },
+    async applyArtifact(ref, input) {
+      assertRef(ref);
+      const record = await store.get(ref);
+      const artifact = record?.artifacts?.[input.localPath];
+      if (!record || !artifact)
+        throw new Error("Unknown artifact. Fetch it with the job that produced it first.");
+      const job = record.jobs[artifact.jobId];
+      if (!job?.snapshotId || !job.snapshotRoot)
+        throw new Error(`Job ${artifact.jobId} did not run on a synced snapshot, so there is nothing to check the checkout against.`);
+      const snapshot = await store.getSnapshot(job.snapshotId, job.snapshotRoot);
+      if (!snapshot)
+        throw new Error(`Snapshot ${job.snapshotId} manifest is not available locally.`);
+      await input.beforeWrite?.({
+        root: snapshot.root,
+        target: input.target,
+        sha256: artifact.sha256,
+        jobId: job.id,
+        snapshotId: snapshot.id
+      });
+      return {
+        ...await applyArtifact({ artifact, snapshot, target: input.target }),
+        root: snapshot.root,
+        snapshotId: snapshot.id,
+        jobId: job.id
+      };
+    },
+    async resume(ref) {
+      assertRef(ref);
+      if (!backend.resume)
+        throw new Error("Only managed sandboxes pause, so direct sandboxes cannot be resumed.");
+      return (await resumeSandbox(ref, backend.resume)).record;
+    },
+    snapshotEffect: backend.snapshots?.effect ?? null,
+    async setupSnapshots(project) {
+      const records = (await setupSnapshots.list(identity)).filter((record) => !project || record.project === null || record.project === project);
+      return Promise.all(records.map(async (record) => ({
+        record,
+        changed: record.project ? changedSetupFiles(record.fingerprint, await setupFingerprint(record.project)) : []
+      })));
+    },
+    async saveSetupSnapshot(ref, input) {
+      assertRef(ref);
+      if (!backend.snapshots)
+        throw new Error(`${identity.mode === "managed" ? "Managed accounts" : `${identity.provider} sandboxes`} cannot be snapshotted.`);
+      const previous = input.replace ? (await setupSnapshots.list(identity)).find((record) => record.snapshotId === input.replace) : undefined;
+      if (input.replace && !previous)
+        throw new Error(`No saved snapshot ${input.replace}.`);
+      await running(ref);
+      const project = input.project ?? null;
+      const fingerprint = project ? await setupFingerprint(project) : {};
+      const snapshotId = await backend.snapshots.create(ref.id, setupSnapshotName(input.label, project));
+      const record = {
+        ...identity,
+        snapshotId,
+        label: input.label.slice(0, 60),
+        project,
+        note: input.note?.slice(0, 500) ?? "",
+        fingerprint,
+        sandboxId: ref.id,
+        createdAt: new Date().toISOString()
+      };
+      await setupSnapshots.put(record);
+      if (backend.snapshots.effect === "stops")
+        await load(ref).catch(() => {});
+      let leftover = null;
+      if (previous && previous.snapshotId !== snapshotId) {
+        await setupSnapshots.remove(identity, previous.snapshotId);
+        await backend.snapshots.delete(previous.snapshotId).catch(() => {
+          leftover = previous.snapshotId;
+        });
+      }
+      return { record, replaced: previous?.snapshotId ?? null, leftover };
+    },
+    async deleteSetupSnapshot(snapshotId) {
+      const record = (await setupSnapshots.list(identity)).find((item) => item.snapshotId === snapshotId);
+      if (!record)
+        throw new Error(`No saved snapshot ${snapshotId}.`);
+      if (!backend.snapshots)
+        throw new Error("This account cannot delete snapshots.");
+      await backend.snapshots.delete(snapshotId);
+      await setupSnapshots.remove(identity, snapshotId);
+      return record;
+    },
+    async destroy(ref) {
+      assertRef(ref);
+      await backend.destroy(ref.id);
+      let info = await backend.get(ref.id);
+      for (const deadline = Date.now() + 30000;info.state !== "terminated" && Date.now() < deadline; ) {
+        await sleep2(2000);
+        info = await backend.get(ref.id);
+      }
+      const record = await store.update(ref, applyInfo(info)) ?? recordFrom(info, null);
+      if (info.state !== "terminated")
+        throw new Error(`The provider still reports sandbox ${ref.id} as ${info.state}. Retry destroy.`);
+      return record;
+    }
+  };
+  return api;
+}
+// ../agent-runtime/src/sandbox/boat.ts
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { BoxApi, Configuration, waitUntilReady } from "@asciidev/box-sdk";
+var profile = SANDBOX_PROVIDER_PROFILES.boat;
+var BASE_URL = "https://ascii.dev/api/box/v1";
+var NAME_PREFIX = "gitterm-sbx-";
+var WRITE_CHUNK_BYTES = 4 * 1024 * 1024;
+var failure = (error, action) => classifyFailure("Boat", error, action);
+function infoFrom(box) {
+  const match = new RegExp(`^${NAME_PREFIX}([a-f0-9]{10})-`).exec(box.name ?? "");
+  return {
+    id: box.id,
+    state: ["ready", "idle", "running"].includes(box.state) ? "running" : box.state === "archived" ? "paused" : box.state === "error" ? "terminated" : "pending",
+    labels: match ? { gitterm_account_hash: match[1], gitterm_workload: "sandbox" } : {},
+    startedAt: box.createdAt ? new Date(box.createdAt).toISOString() : null,
+    expiresAt: box.archiveAfter ? new Date(box.archiveAfter).toISOString() : null
+  };
+}
+function createBoatSandboxTransport(config) {
+  if (!config.apiKey?.trim())
+    throw new SandboxProviderError("auth", "Boat apiKey is empty.");
+  const client = new BoxApi(new Configuration({ basePath: BASE_URL, accessToken: config.apiKey }));
+  const get = async (id) => {
+    try {
+      return (await client.get({ boxId: id })).box;
+    } catch (error) {
+      throw failure(error, "read the sandbox");
+    }
+  };
+  const running = async (id) => {
+    const box = await get(id);
+    if (infoFrom(box).state !== "running")
+      throw new SandboxProviderError("not_found", `The Boat box is ${box.state}.`);
+  };
+  async function command(id, script, timeoutMs = 60000) {
+    try {
+      const result = await client.command({
+        boxId: id,
+        commandRequest: {
+          command: script,
+          timeoutSeconds: Math.min(600, Math.max(1, Math.ceil(timeoutMs / 1000)))
+        }
+      });
+      return {
+        exitCode: result.timedOut ? 124 : result.exitCode ?? 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? ""
+      };
+    } catch (error) {
+      throw failure(error, "run a command");
+    }
+  }
+  async function destroy(id) {
+    const response = await fetch(`${BASE_URL}/boxes/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${config.apiKey}`, "X-Ascii-Confirm-Delete": id }
+    }).catch((error) => {
+      throw failure(error, "delete the sandbox");
+    });
+    if (response.status === 401 || response.status === 403)
+      throw new SandboxProviderError("auth", "Boat rejected the API key while trying to delete the sandbox.");
+    if (!response.ok && response.status !== 404)
+      throw new SandboxProviderError("provider", `Boat failed to delete the sandbox (${response.status}).`);
+  }
+  return {
+    provider: "boat",
+    ...profile,
+    async create(input) {
+      validateLifetime(input.timeoutMs, profile.capabilities.maxLifetimeMs);
+      const account = input.labels.gitterm_account ?? input.labels.gitterm_workspace ?? "managed";
+      const name = `${NAME_PREFIX}${accountHash(account)}-${randomBytes5(4).toString("hex")}`;
+      let id;
+      try {
+        id = (await client.create({
+          createBoxRequest: {
+            type: input.machine?.size ?? config.size,
+            ttlSeconds: Math.ceil(input.timeoutMs / 1000),
+            noEnv: true,
+            ...input.snapshot ?? config.snapshot ? { from: input.snapshot ?? config.snapshot } : {},
+            ...input.env ? { env: input.env } : {}
+          }
+        })).box.id;
+      } catch (error) {
+        throw failure(error, "create a sandbox");
+      }
+      try {
+        await waitUntilReady(client, id);
+        await client.update({ boxId: id, updateBoxRequest: { name } });
+        return infoFrom(await get(id));
+      } catch (error) {
+        return discardFailedCreate(destroy, id, failure(error, "prepare the sandbox"));
+      }
+    },
+    async info(id) {
+      try {
+        return infoFrom((await client.get({ boxId: id })).box);
+      } catch (error) {
+        const classified = failure(error, "read the sandbox");
+        if (classified.code === "not_found")
+          return terminated(id);
+        throw classified;
+      }
+    },
+    async list(labels) {
+      const items = [];
+      let cursor;
+      try {
+        do {
+          const page = await client.boxes({ limit: 100, cursor });
+          for (const box of page.boxes) {
+            const info = infoFrom(box);
+            if (info.labels.gitterm_workload !== "sandbox" || info.state === "terminated")
+              continue;
+            const wanted = labels.gitterm_account ? accountHash(labels.gitterm_account) : undefined;
+            if (wanted && info.labels.gitterm_account_hash !== wanted)
+              continue;
+            items.push(info);
+          }
+          cursor = page.pageInfo?.nextCursor;
+        } while (cursor && items.length < 500);
+      } catch (error) {
+        throw failure(error, "list sandboxes");
+      }
+      return items;
+    },
+    destroy,
+    async pause(id) {
+      try {
+        await client.stop({ boxId: id });
+      } catch (error) {
+        throw failure(error, "stop the sandbox");
+      }
+      const deadline = Date.now() + 120000;
+      while ((await get(id)).state !== "archived") {
+        if (Date.now() > deadline)
+          throw new SandboxProviderError("timeout", "Boat did not finish pausing the sandbox.");
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    },
+    async resume(id) {
+      try {
+        await client.resume({ boxId: id, resumeRequest: { noEnv: true } });
+        await waitUntilReady(client, id);
+      } catch (error) {
+        throw failure(error, "resume the sandbox");
+      }
+    },
+    async keepAlive(id, timeoutMs) {
+      try {
+        await client.update({
+          boxId: id,
+          updateBoxRequest: { ttlSeconds: Math.ceil(timeoutMs / 1000) }
+        });
+      } catch (error) {
+        throw failure(error, "extend the sandbox lifetime");
+      }
+    },
+    async run(id, script, options = {}) {
+      await running(id);
+      const exports = Object.entries(options.env ?? {}).map(([key, value]) => {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+          throw new Error(`Invalid variable name: ${key}`);
+        return `export ${key}=${shellQuote(value)}; `;
+      }).join("");
+      const cd = options.cwd ? `cd ${shellQuote(options.cwd)} && ` : "";
+      return command(id, `${exports}${cd}sh -c ${shellQuote(script)}`, options.timeoutMs);
+    },
+    async writeFile(id, path, data) {
+      await running(id);
+      const parts = [];
+      try {
+        for (let offset = 0;offset < Math.max(1, data.byteLength); offset += WRITE_CHUNK_BYTES) {
+          const part = data.byteLength <= WRITE_CHUNK_BYTES ? path : `${path}.part${parts.length}`;
+          await client.writeFile({
+            boxId: id,
+            fileWriteRequest: {
+              path: part,
+              content: Buffer.from(data.subarray(offset, offset + WRITE_CHUNK_BYTES)).toString("base64"),
+              encoding: "base64"
+            }
+          });
+          parts.push(part);
+        }
+      } catch (error) {
+        throw failure(error, "upload a file");
+      }
+      if (parts.length > 1) {
+        const quoted = parts.map(shellQuote).join(" ");
+        const joined = await command(id, `cat ${quoted} > ${shellQuote(path)} && rm -f ${quoted}`);
+        if (joined.exitCode !== 0)
+          throw new SandboxProviderError("provider", "Could not assemble the upload in the box.");
+      }
+    },
+    async readFile(id, path) {
+      await running(id);
+      try {
+        const result = await client.readFile({ boxId: id, path, encoding: "base64" });
+        return new Uint8Array(Buffer.from(result.content, "base64"));
+      } catch (error) {
+        throw failure(error, "download a file");
+      }
+    },
+    async preview(id, port) {
+      validatePort(port);
+      await running(id);
+      const hosted = await command(id, `host ${port} >/dev/null && host url ${port}`);
+      const url = hosted.stdout.match(/https:\/\/\S+/)?.[0];
+      if (hosted.exitCode !== 0 || !url)
+        throw new SandboxProviderError("provider", `Boat did not return a URL for port ${port}.`);
+      const parsed = new URL(url);
+      const token = parsed.searchParams.get("_token");
+      parsed.searchParams.delete("_token");
+      const headers = token ? { cookie: `_port_auth=${token}` } : {};
+      return { url: parsed.toString(), headers };
+    },
+    snapshots: {
+      async create(id, name) {
+        try {
+          await client.saveNamedSnapshot({ namedSnapshotSaveRequest: { boxId: id, name } });
+          const deadline = Date.now() + 30 * 60000;
+          while (true) {
+            const { snapshot } = await client.getNamedSnapshot({ name });
+            if (snapshot.status === "ready")
+              return name;
+            if (snapshot.status === "failed")
+              throw new SandboxProviderError("provider", `Boat could not save the snapshot${snapshot.error ? `: ${snapshot.error}` : "."}`);
+            if (Date.now() > deadline)
+              throw new SandboxProviderError("timeout", "Boat did not finish saving the snapshot.");
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+          }
+        } catch (error) {
+          throw failure(error, "snapshot the sandbox");
+        }
+      },
+      async delete(snapshotId) {
+        try {
+          await client.deleteNamedSnapshot({ name: snapshotId });
+        } catch (error) {
+          const classified = failure(error, "delete the snapshot");
+          if (classified.code !== "not_found")
+            throw classified;
+        }
+      }
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/daytona.ts
+import { Daytona, Image } from "@daytonaio/sdk";
+var profile2 = SANDBOX_PROVIDER_PROFILES.daytona;
+var DEFAULT_DAYTONA_SANDBOX_IMAGE = "node:22-bookworm-slim";
+var failure2 = (error, action) => classifyFailure("Daytona", error, action);
+function infoFrom2(sandbox) {
+  const state = String(sandbox.state ?? "");
+  return {
+    id: sandbox.id,
+    state: ["started"].includes(state) ? "running" : ["stopped", "paused", "archived", "stopping", "pausing", "archiving"].includes(state) ? "paused" : ["destroyed", "destroying", "error", "build_failed"].includes(state) ? "terminated" : "pending",
+    labels: sandbox.labels ?? {},
+    startedAt: sandbox.createdAt ?? null,
+    expiresAt: sandbox.labels?.gitterm_expires_at ?? null
+  };
+}
+function createDaytonaSandboxTransport(config) {
+  if (!config.apiKey?.trim())
+    throw new SandboxProviderError("auth", "Daytona apiKey is empty.");
+  const client = new Daytona({
+    apiKey: config.apiKey,
+    ...config.target ? { target: config.target } : {}
+  });
+  const get = async (id) => {
+    try {
+      return await client.get(id);
+    } catch (error) {
+      throw failure2(error, "read the sandbox");
+    }
+  };
+  const running = async (id) => {
+    const sandbox = await get(id);
+    if (infoFrom2(sandbox).state !== "running")
+      throw new SandboxProviderError("not_found", `The Daytona sandbox is ${sandbox.state}.`);
+    return sandbox;
+  };
+  return {
+    provider: "daytona",
+    ...profile2,
+    async create(input) {
+      validateLifetime(input.timeoutMs, profile2.capabilities.maxLifetimeMs);
+      const minutes = Math.ceil(input.timeoutMs / 60000);
+      const kill = (input.onTimeout ?? "kill") === "kill";
+      const resources = input.machine?.resources ?? config.resources;
+      let sandbox;
+      try {
+        sandbox = await client.create({
+          ...input.snapshot ?? config.snapshot ? { snapshot: input.snapshot ?? config.snapshot } : {
+            image: Image.base(input.template ?? DEFAULT_DAYTONA_SANDBOX_IMAGE).entrypoint([
+              "sleep",
+              "infinity"
+            ]),
+            ...resources ? { resources } : {}
+          },
+          labels: {
+            ...input.labels,
+            ...kill ? { gitterm_expires_at: new Date(Date.now() + minutes * 60000).toISOString() } : {}
+          },
+          public: input.publicPreviews === true,
+          ...kill ? { ttlMinutes: minutes, autoStopInterval: minutes, autoDeleteInterval: 0 } : { autoStopInterval: minutes, autoDeleteInterval: -1 }
+        }, { timeout: 600 });
+      } catch (error) {
+        throw failure2(error, "create a sandbox");
+      }
+      try {
+        const check = await sandbox.process.executeCommand("true", undefined, undefined, 30);
+        if (check.exitCode !== 0)
+          throw new Error("sandbox did not run a command");
+        return infoFrom2(sandbox);
+      } catch (error) {
+        return discardFailedCreate(() => sandbox.delete(), sandbox.id, failure2(error, "prepare the sandbox"));
+      }
+    },
+    async info(id) {
+      try {
+        const sandbox = await client.get(id);
+        return infoFrom2(sandbox);
+      } catch (error) {
+        const classified = failure2(error, "read the sandbox");
+        if (classified.code === "not_found")
+          return terminated(id);
+        throw classified;
+      }
+    },
+    async list(labels) {
+      try {
+        const items = [];
+        for await (const sandbox of client.list({ labels })) {
+          items.push(infoFrom2(sandbox));
+          if (items.length >= 500)
+            break;
+        }
+        return items.filter((item) => item.state !== "terminated");
+      } catch (error) {
+        throw failure2(error, "list sandboxes");
+      }
+    },
+    async destroy(id) {
+      try {
+        await (await client.get(id)).delete(180, true);
+      } catch (error) {
+        const classified = failure2(error, "delete the sandbox");
+        if (classified.code !== "not_found")
+          throw classified;
+      }
+    },
+    async pause(id) {
+      try {
+        await (await get(id)).stop();
+      } catch (error) {
+        throw failure2(error, "stop the sandbox");
+      }
+    },
+    async resume(id) {
+      try {
+        await (await get(id)).start();
+      } catch (error) {
+        throw failure2(error, "start the sandbox");
+      }
+    },
+    async keepAlive(id) {
+      try {
+        await (await get(id)).refreshActivity();
+      } catch (error) {
+        throw failure2(error, "record sandbox activity");
+      }
+    },
+    async run(id, command, options = {}) {
+      const sandbox = await running(id);
+      try {
+        const result = await sandbox.process.executeCommand(command, options.cwd, options.env, Math.ceil((options.timeoutMs ?? 60000) / 1000));
+        return { exitCode: result.exitCode, stdout: result.result, stderr: "" };
+      } catch (error) {
+        throw failure2(error, "run a command");
+      }
+    },
+    async writeFile(id, path, data) {
+      const sandbox = await running(id);
+      try {
+        await sandbox.fs.uploadFile(Buffer.from(data), path);
+      } catch (error) {
+        throw failure2(error, "upload a file");
+      }
+    },
+    async readFile(id, path) {
+      const sandbox = await running(id);
+      try {
+        return new Uint8Array(await sandbox.fs.downloadFile(path));
+      } catch (error) {
+        throw failure2(error, "download a file");
+      }
+    },
+    async preview(id, port) {
+      validatePort(port);
+      const sandbox = await running(id);
+      try {
+        const link = await sandbox.getPreviewLink(port);
+        const headers = link.token ? { "x-daytona-preview-token": link.token, "X-Daytona-Skip-Preview-Warning": "true" } : {};
+        return { url: link.url, headers };
+      } catch (error) {
+        throw failure2(error, "get a preview link");
+      }
+    },
+    snapshots: {
+      async create(id, name) {
+        try {
+          await (await running(id)).createSnapshot(name, 1800);
+          return name;
+        } catch (error) {
+          throw failure2(error, "snapshot the sandbox");
+        }
+      },
+      async delete(snapshotId) {
+        try {
+          await client.snapshot.delete(await client.snapshot.get(snapshotId));
+        } catch (error) {
+          const classified = failure2(error, "delete the snapshot");
+          if (classified.code !== "not_found")
+            throw classified;
+        }
+      }
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/e2b.ts
+import {
+  AuthenticationError,
+  CommandExitError,
+  NotFoundError,
+  RateLimitError,
+  Sandbox,
+  TimeoutError
+} from "e2b";
+var DEFAULT_E2B_TEMPLATE = "base";
+var profile3 = SANDBOX_PROVIDER_PROFILES.e2b;
+var MAX_LIFETIME_MS = profile3.capabilities.maxLifetimeMs;
+var EXPIRES_LABEL = "gitterm_expires_at";
+var failure3 = (error, action) => {
+  if (error instanceof RateLimitError)
+    return new SandboxProviderError("rate_limited", `E2B rate-limited the request to ${action}.`);
+  if (error instanceof TimeoutError)
+    return new SandboxProviderError("timeout", `E2B timed out while trying to ${action}.`);
+  return classifyFailure("E2B", error, action, {
+    auth: (e) => e instanceof AuthenticationError,
+    notFound: (e) => e instanceof NotFoundError
+  });
+};
+function infoFrom3(info) {
+  return {
+    id: info.sandboxId,
+    state: info.state === "paused" ? "paused" : "running",
+    labels: info.metadata ?? {},
+    startedAt: info.startedAt.toISOString(),
+    expiresAt: info.metadata?.[EXPIRES_LABEL] ?? info.endAt.toISOString()
+  };
+}
+function createE2BSandboxTransport(config) {
+  const apiKey = config.apiKey?.trim();
+  if (!apiKey)
+    throw new SandboxProviderError("auth", "E2B apiKey is empty.");
+  const opts = { apiKey };
+  async function info(id) {
+    try {
+      return infoFrom3(await Sandbox.getInfo(id, opts));
+    } catch (error) {
+      const classified = failure3(error, "read the sandbox");
+      if (classified.code === "not_found")
+        return terminated(id);
+      throw classified;
+    }
+  }
+  async function connect(id) {
+    const current = await info(id);
+    if (current.state === "terminated")
+      throw new SandboxProviderError("not_found", "The sandbox no longer exists.");
+    const remaining = Date.parse(current.expiresAt ?? "") - Date.now();
+    if (!(remaining > 1000))
+      throw new SandboxProviderError("not_found", "The sandbox has reached its lifetime limit.");
+    try {
+      return await Sandbox.connect(id, { ...opts, timeoutMs: remaining });
+    } catch (error) {
+      throw failure3(error, "connect to the sandbox");
+    }
+  }
+  return {
+    provider: "e2b",
+    ...profile3,
+    async create(input) {
+      validateLifetime(input.timeoutMs, MAX_LIFETIME_MS);
+      const onTimeout = input.onTimeout ?? "kill";
+      const labels = {
+        ...input.labels,
+        ...onTimeout === "kill" ? { [EXPIRES_LABEL]: new Date(Date.now() + input.timeoutMs).toISOString() } : {}
+      };
+      let sandbox;
+      try {
+        const template = input.template ?? config.template ?? DEFAULT_E2B_TEMPLATE;
+        const source = input.snapshot ?? config.snapshot ?? `${template}${input.machine?.templateSuffix ?? ""}`;
+        sandbox = await Sandbox.create(source, {
+          ...opts,
+          timeoutMs: input.timeoutMs,
+          metadata: labels,
+          ...input.env ? { envs: input.env } : {},
+          lifecycle: { onTimeout },
+          network: { allowPublicTraffic: input.publicPreviews === true }
+        });
+      } catch (error) {
+        throw failure3(error, "create a sandbox");
+      }
+      try {
+        await sandbox.commands.run("true", { timeoutMs: 30000 });
+        return infoFrom3(await Sandbox.getInfo(sandbox.sandboxId, opts));
+      } catch (error) {
+        return discardFailedCreate((id) => Sandbox.kill(id, opts), sandbox.sandboxId, failure3(error, "prepare the sandbox"));
+      }
+    },
+    info,
+    async list(labels) {
+      try {
+        const paginator = Sandbox.list({
+          ...opts,
+          query: {
+            ...Object.keys(labels).length ? { metadata: labels } : {},
+            state: ["running", "paused"]
+          }
+        });
+        const items = [];
+        while (paginator.hasNext && items.length < 500) {
+          for (const item of await paginator.nextItems())
+            items.push(infoFrom3(item));
+        }
+        return items;
+      } catch (error) {
+        throw failure3(error, "list sandboxes");
+      }
+    },
+    async destroy(id) {
+      try {
+        await Sandbox.kill(id, opts);
+      } catch (error) {
+        const classified = failure3(error, "delete the sandbox");
+        if (classified.code !== "not_found")
+          throw classified;
+      }
+    },
+    async pause(id) {
+      try {
+        await Sandbox.pause(id, opts);
+      } catch (error) {
+        throw failure3(error, "pause the sandbox");
+      }
+    },
+    async resume(id) {
+      try {
+        await Sandbox.connect(id, opts);
+      } catch (error) {
+        throw failure3(error, "resume the sandbox");
+      }
+    },
+    async keepAlive(id, timeoutMs) {
+      try {
+        await Sandbox.setTimeout(id, timeoutMs, opts);
+      } catch (error) {
+        throw failure3(error, "extend the sandbox timeout");
+      }
+    },
+    async run(id, command, options = {}) {
+      const sandbox = await connect(id);
+      try {
+        const result = await sandbox.commands.run(command, {
+          cwd: options.cwd,
+          envs: options.env,
+          timeoutMs: options.timeoutMs ?? 60000
+        });
+        return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+      } catch (error) {
+        if (error instanceof CommandExitError)
+          return { exitCode: error.exitCode, stdout: error.stdout, stderr: error.stderr };
+        throw failure3(error, "run a command");
+      }
+    },
+    async writeFile(id, path, data) {
+      const sandbox = await connect(id);
+      try {
+        await sandbox.files.write(path, new Blob([data]));
+      } catch (error) {
+        throw failure3(error, "upload a file");
+      }
+    },
+    async readFile(id, path) {
+      const sandbox = await connect(id);
+      try {
+        return await sandbox.files.read(path, { format: "bytes" });
+      } catch (error) {
+        throw failure3(error, "download a file");
+      }
+    },
+    async preview(id, port) {
+      validatePort(port);
+      const sandbox = await connect(id);
+      const token = sandbox.trafficAccessToken;
+      const headers = token ? { "e2b-traffic-access-token": token } : {};
+      return { url: `https://${sandbox.getHost(port)}`, headers };
+    },
+    snapshots: {
+      async create(id, name) {
+        try {
+          return (await Sandbox.createSnapshot(id, { ...opts, name })).snapshotId;
+        } catch (error) {
+          throw failure3(error, "snapshot the sandbox");
+        }
+      },
+      async delete(snapshotId) {
+        try {
+          await Sandbox.deleteSnapshot(snapshotId, opts);
+        } catch (error) {
+          const classified = failure3(error, "delete the snapshot");
+          if (classified.code !== "not_found")
+            throw classified;
+        }
+      }
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/exedev.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
+var profile4 = SANDBOX_PROVIDER_PROFILES.exedev;
+var DEFAULT_EXEDEV_SANDBOX_IMAGE = "node:22-bookworm";
+var NAME_PREFIX2 = "gitterm-sbx-";
+var EXIT_MARKER = "__GITTERM_EXIT__";
+var WRITE_CHUNK_BYTES2 = 40 * 1024;
+var READ_CHUNK_BYTES = 4 * 1024 * 1024;
+function createExeDevSandboxTransport(config) {
+  if (!config.apiKey?.trim())
+    throw new SandboxProviderError("auth", "exe.dev token is empty.");
+  const accessKeys = new Map;
+  async function exec(command, action) {
+    let response;
+    try {
+      response = await fetch("https://exe.dev/exec", {
+        method: "POST",
+        headers: { authorization: `Bearer ${config.apiKey}`, "content-type": "text/plain" },
+        body: command,
+        signal: AbortSignal.timeout(45000)
+      });
+    } catch (error) {
+      throw classifyFailure("exe.dev", error, action);
+    }
+    const text = await response.text();
+    if (response.status === 401 || response.status === 403)
+      throw new SandboxProviderError("auth", `exe.dev rejected the token while trying to ${action}. Tokens need cmds new, ls, ssh, ssh-key, pause, resume, and rm.`);
+    if (response.status === 504)
+      throw new SandboxProviderError("timeout", `exe.dev timed out while trying to ${action}.`);
+    if (!response.ok)
+      throw classifyFailure("exe.dev", new Error(`${response.status} ${text.slice(0, 200)}`), action);
+    return text;
+  }
+  const parseList = (text) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {};
+    }
+  };
+  const infoFrom = (name, status) => {
+    const match = new RegExp(`^${NAME_PREFIX2}([a-f0-9]{10})-`).exec(name);
+    return {
+      id: name,
+      state: status === "running" ? "running" : status === "paused" ? "paused" : status === "creating" ? "pending" : "terminated",
+      labels: match ? { gitterm_account_hash: match[1], gitterm_workload: "sandbox" } : {},
+      startedAt: null,
+      expiresAt: null
+    };
+  };
+  async function info(id) {
+    if (!/^[a-z0-9-]+$/.test(id))
+      throw new Error("Invalid exe.dev VM name");
+    try {
+      const vm = parseList(await exec(`ls ${id} --json`, "read the sandbox")).vms?.find((item) => item.vm_name === id);
+      return vm ? infoFrom(id, vm.status) : terminated(id);
+    } catch (error) {
+      if (error instanceof SandboxProviderError && error.code === "not_found")
+        return terminated(id);
+      throw error;
+    }
+  }
+  async function ssh(id, command, timeoutMs = 25000) {
+    const text = await exec(`ssh ${id} -- bash -c ${shellQuote(`timeout ${Math.max(1, Math.floor(timeoutMs / 1000))} bash -c ${shellQuote(command)}; printf '\\n${EXIT_MARKER}%s\\n' "$?"`)}`, "run a command");
+    const match = new RegExp(`\\n?${EXIT_MARKER}(\\d+)\\n?$`).exec(text);
+    if (!match)
+      throw new SandboxProviderError("provider", "exe.dev did not report the command's exit code.");
+    return { exitCode: Number(match[1]), stdout: text.slice(0, match.index), stderr: "" };
+  }
+  async function running(id) {
+    const current = await info(id);
+    if (current.state !== "running")
+      throw new SandboxProviderError("not_found", `The exe.dev VM is ${current.state}.`);
+  }
+  return {
+    provider: "exedev",
+    ...profile4,
+    async create(input) {
+      validateLifetime(input.timeoutMs, profile4.capabilities.maxLifetimeMs);
+      const account = input.labels.gitterm_account ?? input.labels.gitterm_workspace ?? "managed";
+      const name = `${NAME_PREFIX2}${accountHash(account)}-${randomBytes6(4).toString("hex")}`;
+      const machine = input.machine ?? config;
+      const size = ["cpu", "memory", "disk"].filter((key) => machine[key]).map((key) => ` --${key}=${shellQuote(String(machine[key]))}`).join("");
+      await exec(`new --name=${name} --no-email --image=${shellQuote(input.template ?? config.image ?? DEFAULT_EXEDEV_SANDBOX_IMAGE)}${size} --json`, "create a sandbox");
+      try {
+        const deadline = Date.now() + 120000;
+        while ((await info(name)).state !== "running") {
+          if (Date.now() > deadline)
+            throw new SandboxProviderError("timeout", "Timed out waiting for the exe.dev VM.");
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        const check = await ssh(name, "true");
+        if (check.exitCode !== 0)
+          throw new Error("VM did not run a command");
+        return info(name);
+      } catch (error) {
+        return discardFailedCreate(() => exec(`rm ${name}`, "delete the sandbox"), name, error);
+      }
+    },
+    info,
+    async list(labels) {
+      const wanted = labels.gitterm_account ? accountHash(labels.gitterm_account) : undefined;
+      return (parseList(await exec("ls --json", "list sandboxes")).vms ?? []).filter((vm) => vm.vm_name.startsWith(wanted ? `${NAME_PREFIX2}${wanted}-` : NAME_PREFIX2)).map((vm) => infoFrom(vm.vm_name, vm.status)).filter((item) => item.state !== "terminated");
+    },
+    async destroy(id) {
+      if ((await info(id)).state === "terminated")
+        return;
+      await exec(`rm ${id}`, "delete the sandbox");
+    },
+    async pause(id) {
+      await exec(`pause ${id}`, "pause the sandbox");
+    },
+    async resume(id) {
+      await exec(`resume ${id}`, "resume the sandbox");
+    },
+    async run(id, command, options = {}) {
+      await running(id);
+      const exports = Object.entries(options.env ?? {}).map(([key, value]) => {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+          throw new Error(`Invalid variable name: ${key}`);
+        return `export ${key}=${shellQuote(value)}; `;
+      }).join("");
+      const cd = options.cwd ? `cd ${shellQuote(options.cwd)} && ` : "";
+      return ssh(id, `${exports}${cd}${command}`, Math.min(options.timeoutMs ?? 25000, 25000));
+    },
+    async writeFile(id, path, data) {
+      await running(id);
+      const target = shellQuote(path);
+      const begin = await ssh(id, `mkdir -p "$(dirname ${target})" && : > ${target}`);
+      if (begin.exitCode !== 0)
+        throw new SandboxProviderError("provider", "Could not create the file in the VM.");
+      for (let offset = 0;offset < data.byteLength; offset += WRITE_CHUNK_BYTES2) {
+        const chunk = Buffer.from(data.subarray(offset, offset + WRITE_CHUNK_BYTES2)).toString("base64");
+        const appended = await ssh(id, `printf %s ${chunk} | base64 -d >> ${target}`);
+        if (appended.exitCode !== 0)
+          throw new SandboxProviderError("provider", "Could not upload the file to the VM.");
+      }
+    },
+    async readFile(id, path) {
+      await running(id);
+      const size = await ssh(id, `wc -c < ${shellQuote(path)}`);
+      if (size.exitCode !== 0)
+        throw new SandboxProviderError("not_found", `No file at ${path} in the VM.`);
+      const total = Number(size.stdout.trim());
+      const chunks = [];
+      for (let block = 0;block * READ_CHUNK_BYTES < total; block++) {
+        const part = await ssh(id, `dd if=${shellQuote(path)} bs=${READ_CHUNK_BYTES} skip=${block} count=1 2>/dev/null | base64 -w0`);
+        if (part.exitCode !== 0)
+          throw new SandboxProviderError("provider", "Could not download the file from the VM.");
+        chunks.push(Buffer.from(part.stdout.trim(), "base64"));
+      }
+      return new Uint8Array(Buffer.concat(chunks));
+    },
+    async preview(id, port) {
+      validatePort(port);
+      if (port < 3000 || port > 9999)
+        throw new Error("exe.dev previews support ports 3000-9999");
+      await running(id);
+      let key = accessKeys.get(id);
+      if (!key) {
+        const output = await exec(`ssh-key generate-api-key --vm=${id} --label=gitterm-sandbox --exp=never`, "create a preview key");
+        key = output.match(/exe[01]\.[A-Za-z0-9._-]+/)?.[0];
+        if (!key)
+          throw new SandboxProviderError("provider", "exe.dev did not return a VM access key.");
+        accessKeys.set(id, key);
+      }
+      return {
+        url: `https://${id}.exe.xyz:${port}/`,
+        headers: { "X-Exedev-Authorization": `Bearer ${key}` }
+      };
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/railway.ts
+import { randomBytes as randomBytes7 } from "node:crypto";
+
+// ../agent-runtime/src/sandbox/exec-server.ts
+import { createHmac } from "node:crypto";
+var EXEC_SERVER_SOURCE = String.raw`
+const http = require("http"), cp = require("child_process"), fs = require("fs"), path = require("path"), crypto = require("crypto");
+const token = Buffer.from(process.env.GITTERM_EXEC_TOKEN || "");
+delete process.env.GITTERM_EXEC_TOKEN;
+delete process.env.GITTERM_EXEC_SERVER;
+const MAX = 32 * 1024 * 1024;
+const authorized = (req) => {
+  const given = Buffer.from(String(req.headers["x-gitterm-token"] || ""));
+  return token.length > 0 && given.length === token.length && crypto.timingSafeEqual(given, token);
+};
+const body = (req) => new Promise((resolve, reject) => {
+  const chunks = []; let size = 0;
+  req.on("data", (c) => { size += c.length; if (size > MAX) { reject(new Error("too large")); req.destroy(); } else chunks.push(c); });
+  req.on("end", () => resolve(Buffer.concat(chunks)));
+  req.on("error", reject);
+});
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, "http://sandbox");
+  if (url.pathname === "/healthz" && !req.headers["x-gitterm-port"]) return res.end("ok");
+  if (!authorized(req)) return res.writeHead(401).end();
+  const port = Number(req.headers["x-gitterm-port"]);
+  if (port) {
+    const headers = { ...req.headers };
+    delete headers["x-gitterm-token"]; delete headers["x-gitterm-port"];
+    const upstream = http.request({ host: "127.0.0.1", port, method: req.method, path: req.url, headers }, (reply) => {
+      res.writeHead(reply.statusCode || 502, reply.headers);
+      reply.pipe(res);
+    });
+    upstream.on("error", () => { if (!res.headersSent) res.writeHead(502); res.end(); });
+    return req.pipe(upstream);
+  }
+  try {
+    if (url.pathname === "/run" && req.method === "POST") {
+      const input = JSON.parse((await body(req)).toString());
+      const child = cp.spawn("sh", ["-c", input.command], {
+        cwd: input.cwd || process.env.HOME || "/",
+        env: { ...process.env, ...(input.env || {}) },
+      });
+      const out = [], err = []; let kept = 0;
+      const keep = (into) => (chunk) => { if (kept < 16 * 1024 * 1024) { into.push(chunk); kept += chunk.length; } };
+      child.stdout.on("data", keep(out)); child.stderr.on("data", keep(err));
+      const timer = setTimeout(() => child.kill("SIGKILL"), input.timeoutMs || 60000);
+      child.on("error", () => {});
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ exitCode: code === null ? 137 : code, stdout: Buffer.concat(out).toString(), stderr: Buffer.concat(err).toString() }));
+      });
+      return;
+    }
+    const file = url.searchParams.get("path");
+    if (url.pathname === "/file" && file && path.isAbsolute(file)) {
+      if (req.method === "PUT") {
+        const data = await body(req);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, data);
+        return res.end("ok");
+      }
+      if (req.method === "GET") return res.end(fs.readFileSync(file));
+    }
+    res.writeHead(404).end();
+  } catch (error) {
+    res.writeHead(error && error.code === "ENOENT" ? 404 : 500).end();
+  }
+});
+server.on("upgrade", (req, socket) => socket.destroy());
+server.listen(Number(process.env.PORT || 8080), "::");
+`;
+var EXEC_SERVER_PORT = 8080;
+var EXEC_SERVER_START_COMMAND = `sh -c 'node -e "$GITTERM_EXEC_SERVER"'`;
+function execServerToken(credential, sandboxName) {
+  return createHmac("sha256", credential).update(`gitterm-exec:${sandboxName}`).digest("hex");
+}
+function createExecServerClient(baseUrl, token, provider, routing = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const request = async (path, init) => {
+    let response;
+    try {
+      response = await fetch(`${base}${path}`, {
+        ...init,
+        headers: { ...init.headers, ...routing, "x-gitterm-token": token },
+        redirect: "error",
+        signal: AbortSignal.timeout(init.timeoutMs ?? 120000)
+      });
+    } catch {
+      throw new SandboxProviderError("provider", `Could not reach the ${provider} sandbox command server.`);
+    }
+    if (response.status === 401)
+      throw new SandboxProviderError("auth", `The ${provider} sandbox rejected the derived access token.`);
+    if (response.status === 404)
+      throw new SandboxProviderError("not_found", "File or endpoint not found in the sandbox.");
+    if (!response.ok)
+      throw new SandboxProviderError("provider", `The ${provider} sandbox command server failed (${response.status}).`);
+    return response;
+  };
+  return {
+    async ready() {
+      return fetch(`${base}/healthz`, { headers: routing, signal: AbortSignal.timeout(5000) }).then((response) => response.ok).catch(() => false);
+    },
+    async run(command, options = {}) {
+      const timeoutMs = options.timeoutMs ?? 60000;
+      const response = await request("/run", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ command, cwd: options.cwd, env: options.env, timeoutMs }),
+        timeoutMs: timeoutMs + 15000
+      });
+      return await response.json();
+    },
+    async writeFile(path, data) {
+      await request(`/file?path=${encodeURIComponent(path)}`, {
+        method: "PUT",
+        body: data
+      });
+    },
+    async readFile(path) {
+      return new Uint8Array(await (await request(`/file?path=${encodeURIComponent(path)}`, { method: "GET" })).arrayBuffer());
+    },
+    preview(port) {
+      return {
+        url: `${base}/`,
+        headers: { ...routing, "x-gitterm-token": token, "x-gitterm-port": String(port) }
+      };
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/railway.ts
+var profile5 = SANDBOX_PROVIDER_PROFILES.railway;
+var DEFAULT_RAILWAY_SANDBOX_IMAGE = "node:22-bookworm-slim";
+var NAME_PREFIX3 = "gitterm-sbx-";
+var DEPLOY_TIMEOUT_MS = 5 * 60000;
+function createRailwaySandboxTransport(config) {
+  if (!config.apiKey?.trim())
+    throw new SandboxProviderError("auth", "Railway token is empty.");
+  if (!config.projectId?.trim() || !config.environmentId?.trim())
+    throw new Error("Railway sandboxes need projectId and environmentId");
+  const apiUrl = config.apiUrl?.trim() || "https://backboard.railway.app/graphql/v2";
+  const { environmentId, projectId } = config;
+  async function gql(query, variables, action) {
+    let response;
+    try {
+      response = await fetch(apiUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+        body: JSON.stringify({ query, variables }),
+        signal: AbortSignal.timeout(60000)
+      });
+    } catch (error) {
+      throw classifyFailure("Railway", error, action);
+    }
+    if (response.status === 401 || response.status === 403)
+      throw new SandboxProviderError("auth", `Railway rejected the token while trying to ${action}.`);
+    const result = await response.json().catch(() => ({}));
+    if (!response.ok || result.errors?.length) {
+      const message = result.errors?.map((error) => error.message).join("; ") ?? `HTTP ${response.status}`;
+      throw classifyFailure("Railway", new Error(message), action);
+    }
+    return result.data;
+  }
+  async function snapshot(id) {
+    try {
+      return await gql(`query($serviceId: String!, $environmentId: String!, $projectId: String!) {
+          service(id: $serviceId) { id name createdAt deletedAt }
+          serviceInstance(environmentId: $environmentId, serviceId: $serviceId) {
+            latestDeployment { id status }
+            domains { serviceDomains { domain targetPort } }
+          }
+          variables(projectId: $projectId, environmentId: $environmentId, serviceId: $serviceId)
+        }`, { serviceId: id, environmentId, projectId }, "read the sandbox");
+    } catch (error) {
+      if (error instanceof SandboxProviderError && error.code === "not_found")
+        return null;
+      throw error;
+    }
+  }
+  const infoFrom = (id, data) => {
+    if (!data?.service || data.service.deletedAt)
+      return terminated(id);
+    const status = data.serviceInstance?.latestDeployment?.status;
+    let labels = {};
+    try {
+      labels = JSON.parse(data.variables?.GITTERM_LABELS ?? "{}");
+    } catch {}
+    return {
+      id,
+      state: status === "SUCCESS" ? "running" : !status || ["REMOVED", "SLEEPING", "REMOVING"].includes(status) ? "paused" : ["FAILED", "CRASHED", "SKIPPED"].includes(status) ? "terminated" : "pending",
+      labels,
+      startedAt: data.service.createdAt ?? null,
+      expiresAt: null
+    };
+  };
+  async function connect(id) {
+    const data = await snapshot(id);
+    const info = infoFrom(id, data);
+    if (info.state !== "running")
+      throw new SandboxProviderError("not_found", `The Railway sandbox is ${info.state}.`);
+    const domain = data?.serviceInstance?.domains?.serviceDomains?.[0]?.domain;
+    if (!domain)
+      throw new SandboxProviderError("provider", "The Railway sandbox has no domain.");
+    return createExecServerClient(`https://${domain}`, execServerToken(config.apiKey, data.service.name), "Railway");
+  }
+  async function deploy(id) {
+    await gql(`mutation($environmentId: String!, $serviceId: String!) { serviceInstanceDeploy(environmentId: $environmentId, serviceId: $serviceId, latestCommit: true) }`, { environmentId, serviceId: id }, "deploy the sandbox");
+    const deadline = Date.now() + DEPLOY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      const data = await snapshot(id);
+      const status = data?.serviceInstance?.latestDeployment?.status;
+      if (status && ["FAILED", "CRASHED"].includes(status))
+        throw new SandboxProviderError("provider", `The Railway deployment ended with ${status}.`);
+      if (status === "SUCCESS") {
+        const client = await connect(id);
+        if (await client.ready())
+          return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    throw new SandboxProviderError("timeout", "Timed out waiting for the Railway sandbox to start.");
+  }
+  async function destroy(id) {
+    try {
+      await gql(`mutation($id: String!) { serviceDelete(id: $id) }`, { id }, "delete the sandbox");
+    } catch (error) {
+      if (!(error instanceof SandboxProviderError && error.code === "not_found"))
+        throw error;
+    }
+  }
+  return {
+    provider: "railway",
+    ...profile5,
+    async create(input) {
+      validateLifetime(input.timeoutMs, profile5.capabilities.maxLifetimeMs);
+      const name = `${NAME_PREFIX3}${randomBytes7(6).toString("hex")}`;
+      const created = await gql(`mutation($input: ServiceCreateInput!) { serviceCreate(input: $input) { id } }`, {
+        input: {
+          projectId,
+          environmentId,
+          name,
+          variables: {
+            GITTERM_LABELS: JSON.stringify(input.labels),
+            GITTERM_EXEC_TOKEN: execServerToken(config.apiKey, name),
+            GITTERM_EXEC_SERVER: EXEC_SERVER_SOURCE,
+            PORT: String(EXEC_SERVER_PORT)
+          }
+        }
+      }, "create a sandbox");
+      const id = created.serviceCreate.id;
+      try {
+        await gql(`mutation($environmentId: String!, $serviceId: String!, $input: ServiceInstanceUpdateInput!) {
+            serviceInstanceUpdate(environmentId: $environmentId, serviceId: $serviceId, input: $input)
+          }`, {
+          environmentId,
+          serviceId: id,
+          input: {
+            source: { image: input.template ?? config.image ?? DEFAULT_RAILWAY_SANDBOX_IMAGE },
+            startCommand: EXEC_SERVER_START_COMMAND,
+            healthcheckPath: "/healthz"
+          }
+        }, "configure the sandbox");
+        await gql(`mutation($input: ServiceDomainCreateInput!) { serviceDomainCreate(input: $input) { id } }`, { input: { environmentId, serviceId: id, targetPort: EXEC_SERVER_PORT } }, "create the sandbox domain");
+        await deploy(id);
+        return infoFrom(id, await snapshot(id));
+      } catch (error) {
+        return discardFailedCreate(destroy, id, error);
+      }
+    },
+    async info(id) {
+      return infoFrom(id, await snapshot(id));
+    },
+    async list(labels) {
+      const data = await gql(`query($projectId: String!) { project(id: $projectId) { services { edges { node { id name } } } } }`, { projectId }, "list sandboxes");
+      const items = [];
+      for (const { node } of data.project.services.edges) {
+        if (!node.name.startsWith(NAME_PREFIX3))
+          continue;
+        const info = infoFrom(node.id, await snapshot(node.id));
+        if (info.state !== "terminated" && Object.entries(labels).every(([key, value]) => info.labels[key] === value))
+          items.push(info);
+      }
+      return items;
+    },
+    destroy,
+    async pause(id) {
+      const deployment = (await snapshot(id))?.serviceInstance?.latestDeployment;
+      if (!deployment || deployment.status === "REMOVED")
+        return;
+      await gql(`mutation($id: String!) { deploymentRemove(id: $id) }`, { id: deployment.id }, "pause the sandbox");
+    },
+    resume: deploy,
+    async run(id, command, options) {
+      return (await connect(id)).run(command, options);
+    },
+    async writeFile(id, path, data) {
+      return (await connect(id)).writeFile(path, data);
+    },
+    async readFile(id, path) {
+      return (await connect(id)).readFile(path);
+    },
+    async preview(id, port) {
+      validatePort(port);
+      if (port === EXEC_SERVER_PORT)
+        throw new Error(`Port ${EXEC_SERVER_PORT} is reserved for Gitterm in Railway sandboxes`);
+      return (await connect(id)).preview(port);
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/vercel.ts
+import { randomBytes as randomBytes8 } from "node:crypto";
+import { Sandbox as Sandbox2, Snapshot } from "@vercel/sandbox";
+var profile6 = SANDBOX_PROVIDER_PROFILES.vercel;
+var failure4 = (error, action) => classifyFailure("Vercel", error, action);
+var TAG_PRIORITY = [
+  "gitterm_account",
+  "gitterm_workload",
+  "gitterm_workspace",
+  "gitterm_user",
+  "gitterm_name",
+  "gitterm_purpose",
+  "gitterm_session"
+];
+function limitTags(labels) {
+  const rank = (key) => TAG_PRIORITY.indexOf(key) + 1 || 99;
+  const keys = Object.keys(labels).toSorted((a, b) => rank(a) - rank(b));
+  return Object.fromEntries(keys.slice(0, 5).map((key) => [key, labels[key]]));
+}
+function summaryInfo(summary) {
+  return {
+    id: summary.name,
+    state: state(summary.status, summary.persistent),
+    labels: summary.tags ?? {},
+    startedAt: new Date(summary.createdAt).toISOString(),
+    expiresAt: !summary.persistent && summary.timeout ? new Date(summary.createdAt + summary.timeout).toISOString() : null
+  };
+}
+function state(status, persistent) {
+  if (status === "running")
+    return "running";
+  if (status === "pending" || status === "snapshotting")
+    return "pending";
+  if ((status === "stopping" || status === "stopped") && persistent)
+    return "paused";
+  return "terminated";
+}
+function createVercelSandboxTransport(config) {
+  if (!config.apiKey?.trim())
+    throw new SandboxProviderError("auth", "Vercel token is empty.");
+  if (!config.teamId?.trim() || !config.projectId?.trim())
+    throw new Error("Vercel sandboxes need teamId and projectId");
+  const credentials = { token: config.apiKey, teamId: config.teamId, projectId: config.projectId };
+  const infoFrom = (sandbox) => summaryInfo({
+    name: sandbox.name,
+    status: sandbox.status,
+    persistent: sandbox.persistent,
+    tags: sandbox.tags,
+    createdAt: sandbox.createdAt.getTime(),
+    timeout: sandbox.timeout
+  });
+  const get = async (id) => {
+    try {
+      return await Sandbox2.get({ ...credentials, name: id });
+    } catch (error) {
+      throw failure4(error, "read the sandbox");
+    }
+  };
+  const running = async (id) => {
+    const sandbox = await get(id);
+    if (sandbox.status !== "running")
+      throw new SandboxProviderError("not_found", `The Vercel sandbox is ${sandbox.status}.`);
+    return sandbox;
+  };
+  return {
+    provider: "vercel",
+    ...profile6,
+    async create(input) {
+      validateLifetime(input.timeoutMs, profile6.capabilities.maxLifetimeMs);
+      const kill = (input.onTimeout ?? "kill") === "kill";
+      const name = `gitterm-sbx-${randomBytes8(6).toString("hex")}`;
+      const snapshot = input.snapshot ?? config.snapshot;
+      const vcpus = input.machine?.vcpus ? Number(input.machine.vcpus) : config.vcpus;
+      let sandbox;
+      try {
+        sandbox = await Sandbox2.create({
+          ...credentials,
+          name,
+          ...snapshot ? { source: { type: "snapshot", snapshotId: snapshot } } : { runtime: config.runtime ?? "node24" },
+          timeout: input.timeoutMs,
+          persistent: !kill,
+          tags: limitTags(input.labels),
+          ...vcpus ? { resources: { vcpus } } : {}
+        });
+      } catch (error) {
+        throw failure4(error, "create a sandbox");
+      }
+      try {
+        const check = await sandbox.runCommand("true");
+        if (check.exitCode !== 0)
+          throw new Error("sandbox did not run a command");
+        return infoFrom(sandbox);
+      } catch (error) {
+        return discardFailedCreate(() => sandbox.delete(), sandbox.name, failure4(error, "prepare the sandbox"));
+      }
+    },
+    async info(id) {
+      try {
+        return infoFrom(await Sandbox2.get({ ...credentials, name: id }));
+      } catch (error) {
+        const classified = failure4(error, "read the sandbox");
+        if (classified.code === "not_found")
+          return terminated(id);
+        throw classified;
+      }
+    },
+    async list(labels) {
+      const [first] = Object.entries(labels);
+      try {
+        const pages = await Sandbox2.list({
+          ...credentials,
+          ...first ? { tags: { [first[0]]: first[1] } } : {}
+        });
+        const items = [];
+        for await (const summary of pages) {
+          const info = summaryInfo(summary);
+          if (Object.entries(labels).every(([key, value]) => info.labels[key] === value) && info.state !== "terminated")
+            items.push(info);
+          if (items.length >= 500)
+            break;
+        }
+        return items;
+      } catch (error) {
+        throw failure4(error, "list sandboxes");
+      }
+    },
+    async destroy(id) {
+      try {
+        await (await Sandbox2.get({ ...credentials, name: id })).delete();
+      } catch (error) {
+        const classified = failure4(error, "delete the sandbox");
+        if (classified.code !== "not_found")
+          throw classified;
+      }
+    },
+    async pause(id) {
+      try {
+        await (await get(id)).stop();
+      } catch (error) {
+        throw failure4(error, "stop the sandbox");
+      }
+    },
+    async resume(id) {
+      try {
+        await Sandbox2.get({ ...credentials, name: id, resume: true });
+      } catch (error) {
+        throw failure4(error, "resume the sandbox");
+      }
+    },
+    async keepAlive(id, timeoutMs) {
+      try {
+        await (await get(id)).update({ timeout: timeoutMs });
+      } catch (error) {
+        throw failure4(error, "extend the sandbox timeout");
+      }
+    },
+    async run(id, command, options = {}) {
+      const sandbox = await running(id);
+      try {
+        const result = await sandbox.runCommand({
+          cmd: "bash",
+          args: ["-c", command],
+          cwd: options.cwd,
+          env: options.env,
+          signal: AbortSignal.timeout(options.timeoutMs ?? 60000)
+        });
+        return {
+          exitCode: result.exitCode,
+          stdout: await result.stdout(),
+          stderr: await result.stderr()
+        };
+      } catch (error) {
+        throw failure4(error, "run a command");
+      }
+    },
+    async writeFile(id, path, data) {
+      const sandbox = await running(id);
+      try {
+        await sandbox.writeFiles([{ path, content: Buffer.from(data) }]);
+      } catch (error) {
+        throw failure4(error, "upload a file");
+      }
+    },
+    async readFile(id, path) {
+      const sandbox = await running(id);
+      let data;
+      try {
+        data = await sandbox.readFileToBuffer({ path });
+      } catch (error) {
+        throw failure4(error, "download a file");
+      }
+      if (!data)
+        throw new SandboxProviderError("not_found", `No file at ${path} in the sandbox.`);
+      return new Uint8Array(data);
+    },
+    async preview(id, port) {
+      validatePort(port);
+      const sandbox = await running(id);
+      try {
+        const exposed = sandbox.routes.map((route) => route.port);
+        if (!exposed.includes(port))
+          await sandbox.update({ ports: [...exposed, port] });
+        return { url: sandbox.domain(port), headers: {} };
+      } catch (error) {
+        throw failure4(error, "expose the port");
+      }
+    },
+    snapshots: {
+      async create(id) {
+        try {
+          return (await (await running(id)).snapshot({ expiration: 0 })).snapshotId;
+        } catch (error) {
+          throw failure4(error, "snapshot the sandbox");
+        }
+      },
+      async delete(snapshotId) {
+        try {
+          await (await Snapshot.get({ ...credentials, snapshotId })).delete();
+        } catch (error) {
+          const classified = failure4(error, "delete the snapshot");
+          if (classified.code !== "not_found")
+            throw classified;
+        }
+      }
+    }
+  };
+}
+
+// ../agent-runtime/src/sandbox/index.ts
+function createSandboxTransport(config) {
+  switch (config.provider) {
+    case "e2b":
+      return createE2BSandboxTransport(config);
+    case "daytona":
+      return createDaytonaSandboxTransport(config);
+    case "vercel":
+      return createVercelSandboxTransport(config);
+    case "boat":
+      return createBoatSandboxTransport(config);
+    case "exedev":
+      return createExeDevSandboxTransport(config);
+    case "railway":
+      return createRailwaySandboxTransport(config);
+  }
+}
+
+// src/client.ts
+import {
+  createTRPCClient,
+  httpBatchLink,
+  httpSubscriptionLink,
+  splitLink,
+  TRPCClientError
+} from "@trpc/client";
+import { EventSource } from "eventsource";
+
+// src/config.ts
+import { mkdir as mkdir4, readFile as readFile5, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_GITTERM_SERVER_URL = "https://api.gitterm.dev";
+function getConfigPath(configPath) {
+  return configPath ?? join(homedir3(), ".config", "gitterm", "cli.json");
+}
+async function ensureConfigDir(path) {
+  await mkdir4(dirname(path), { recursive: true });
+}
+function parseConfig(text) {
+  const parsed = JSON.parse(text);
+  if (!parsed.token || !parsed.serverUrl)
+    return null;
+  return {
+    serverUrl: parsed.serverUrl,
+    token: parsed.token,
+    createdAt: parsed.createdAt ?? Date.now()
+  };
+}
+async function loadConfig(configPath) {
+  try {
+    const text = await readFile5(getConfigPath(configPath), "utf-8");
+    return parseConfig(text);
+  } catch {
+    return null;
+  }
+}
+function loadConfigSync(configPath) {
+  try {
+    const text = readFileSync(getConfigPath(configPath), "utf-8");
+    return parseConfig(text);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config, configPath) {
+  const path = getConfigPath(configPath);
+  await ensureConfigDir(path);
+  await writeFile4(path, JSON.stringify(config, null, 2), "utf-8");
+}
+async function deleteConfig(configPath) {
+  try {
+    await unlink(getConfigPath(configPath));
+  } catch {}
+}
+
+// src/transport.ts
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function normalizeServerUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Invalid GitTerm server URL: ${value}`);
+  }
+  if (url.username || url.password) {
+    throw new Error("GitTerm server URL must not contain credentials");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname))) {
+    throw new Error("GitTerm server URL must use HTTPS (HTTP is allowed only for loopback)");
+  }
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/, "");
+}
+function withPath(serverUrl, pathname) {
+  const url = new URL(serverUrl);
+  url.pathname = pathname;
+  return url.toString();
+}
+function basePath(serverUrl) {
+  return new URL(serverUrl).pathname.replace(/\/+$/, "");
+}
+function trpcEndpoint(serverUrl) {
+  const base = basePath(serverUrl);
+  return withPath(serverUrl, base.endsWith("/trpc") ? base : `${base}/trpc`);
+}
+function apiEndpoint(serverUrl, route) {
+  const base = basePath(serverUrl);
+  const apiBase = base.endsWith("/api") ? base : `${base}/api`;
+  return withPath(serverUrl, `${apiBase}/${route.replace(/^\/+/, "")}`);
+}
+function createNoRedirectFetch(fetchImpl = fetch) {
+  return async (input, init) => {
+    const response = await fetchImpl(input, { ...init, redirect: "manual" });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      throw new Error(location ? `GitTerm server redirects are not allowed: ${location}` : "GitTerm server redirects are not allowed");
+    }
+    return response;
+  };
+}
+
+// src/runs.ts
+function terminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function aborted(signal) {
+  if (signal?.aborted)
+    throw new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled");
+}
+async function abortable(operation, signal) {
+  if (signal.aborted)
+    operation.catch(() => {});
+  aborted(signal);
+  let onAbort;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        onAbort = () => reject(new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+function delay(ms, signal) {
+  aborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new GittermError("ABORTED", "Operation aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function deadline(options, operation) {
+  aborted(options?.signal);
+  const timeoutMs = options?.timeoutMs ?? 30 * 60000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
+    throw new GittermError("BAD_REQUEST", "timeoutMs must be finite and non-negative");
+  const controller = new AbortController;
+  const onAbort = () => controller.abort();
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await operation(controller.signal);
+  } catch (error) {
+    if (timedOut)
+      throw new GittermError("TIMEOUT", "Run observation timed out; the agent was not cancelled", {
+        cause: error
+      });
+    aborted(options?.signal);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    options?.signal?.removeEventListener("abort", onAbort);
+    controller.abort();
+  }
+}
+async function* runEvents(states) {
+  const seen = new Set;
+  let pending = new Set;
+  let status;
+  for await (const run of states) {
+    if (run.status !== status) {
+      status = run.status;
+      yield { type: "run.status", run };
+    }
+    const current = new Set(run.pendingInputs.map((request) => request.id));
+    for (const requestId of pending) {
+      if (!current.has(requestId))
+        yield { type: "input.resolved", run, requestId };
+    }
+    pending = current;
+    for (const request of run.pendingInputs) {
+      if (seen.has(request.id))
+        continue;
+      seen.add(request.id);
+      yield { type: "input.required", run, request };
+    }
+    if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+      yield { type: `run.${run.status}`, run };
+      return;
+    }
+  }
+}
+function runHelpers(operations) {
+  return {
+    events: (ref, options) => runEvents(operations.watch(ref, options)),
+    wait: (ref, options) => deadline(options, async (signal) => {
+      for await (const run of operations.watch(ref, { signal })) {
+        if (terminal(run.status) || run.status === "awaiting_input" && options?.until !== "terminal")
+          return run;
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    }),
+    result: (ref, options) => deadline(options, async (signal) => {
+      for await (const event of runEvents(operations.watch(ref, { signal }))) {
+        aborted(signal);
+        if (event.type === "run.completed")
+          return event.run;
+        if (event.type === "run.failed")
+          throw new AgentRunError(event.run, "RUN_FAILED");
+        if (event.type === "run.cancelled")
+          throw new AgentRunError(event.run, "RUN_CANCELLED");
+        if (event.type !== "input.required")
+          continue;
+        const { request } = event;
+        let reply;
+        if (request.kind === "permission") {
+          if (!options?.onPermission)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "permission",
+            response: await abortable(Promise.resolve(options.onPermission(request, { signal })), signal)
+          };
+        } else {
+          if (!options?.onQuestion)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "question",
+            ...await abortable(Promise.resolve(options.onQuestion(request, { signal })), signal)
+          };
+        }
+        aborted(signal);
+        try {
+          await abortable(operations.respond(ref, { requestId: request.id, reply }), signal);
+        } catch (error) {
+          if (!(error instanceof GittermError) || error.code !== "INPUT_NOT_PENDING")
+            throw error;
+        }
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    })
+  };
+}
+
+// src/client.ts
+function toConnection(connection) {
+  const details = connection.details;
+  return {
+    ...connection,
+    connectedAt: toIso(connection.connectedAt),
+    details: "lastCheckedAt" in details ? { ...details, lastCheckedAt: toIso(details.lastCheckedAt) } : details
+  };
+}
+function envValue(name) {
+  const value = typeof process !== "undefined" ? process.env[name] : undefined;
+  return value && value.trim() ? value : undefined;
+}
+function resolveCredentials(options) {
+  const config = !options.serverUrl || !options.token ? loadConfigSync(options.configPath) : null;
+  const serverUrl = options.serverUrl ?? envValue("GITTERM_SERVER_URL") ?? config?.serverUrl ?? DEFAULT_GITTERM_SERVER_URL;
+  const token = options.token ?? envValue("GITTERM_API_TOKEN") ?? config?.token;
+  if (!serverUrl || !token) {
+    throw new GittermError("NOT_LOGGED_IN", "Not logged in. Run: gitterm login");
+  }
+  return { serverUrl: normalizeServerUrl(serverUrl), token };
+}
+function toIso(value) {
+  if (!value)
+    return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeBaseCommit(value) {
+  if (value == null)
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  return /^[0-9a-f]{40}([0-9a-f]{24})?$/i.test(trimmed) ? trimmed.toLowerCase() : trimmed;
+}
+function workspaceIdOf(ref) {
+  return typeof ref === "string" ? ref : ref.id;
+}
+function runTargetOf(ref) {
+  return { workspaceId: ref.workspaceId, runId: ref.id };
+}
+function throwIfAborted(signal, what) {
+  if (signal?.aborted)
+    throw new GittermError("ABORTED", `Aborted while ${what}`);
+}
+function sleep3(ms, signal, what) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new GittermError("ABORTED", `Aborted while ${what}`));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function normalizeWorkspace(workspace) {
+  if (!workspace)
+    return null;
+  return {
+    id: workspace.id,
+    name: workspace.name,
+    status: workspace.status,
+    repositoryUrl: workspace.repositoryUrl,
+    repositoryBranch: workspace.repositoryBranch,
+    baseCommit: normalizeBaseCommit(workspace.baseCommit ?? workspace.repositoryBaseCommit ?? null),
+    checkoutRef: workspace.checkoutRef ?? workspace.repositoryCheckoutRef ?? null,
+    domain: workspace.domain,
+    subdomain: workspace.subdomain,
+    persistent: workspace.persistent,
+    hostingType: workspace.hostingType,
+    serverOnly: workspace.serverOnly,
+    workspaceProfile: workspace.workspaceProfile,
+    cloudProviderId: workspace.cloudProviderId,
+    agentType: workspace.image?.agentType ? {
+      id: workspace.image.agentType.id,
+      name: workspace.image.agentType.name,
+      description: workspace.image.agentType.description
+    } : null,
+    image: workspace.image ? {
+      id: workspace.image.id,
+      name: workspace.image.name,
+      imageId: workspace.image.imageId
+    } : null,
+    metadata: workspace.metadata ?? {},
+    autoTerminateAt: toIso(workspace.autoTerminateAt),
+    customImage: workspace.customImage ?? null,
+    startedAt: toIso(workspace.startedAt),
+    pausedAt: toIso(workspace.pausedAt),
+    terminatedAt: toIso(workspace.terminatedAt),
+    lastActiveAt: toIso(workspace.lastActiveAt),
+    updatedAt: toIso(workspace.updatedAt)
+  };
+}
+function normalizeRuntime(runtime) {
+  return {
+    workspaceId: runtime.workspaceId,
+    status: runtime.status,
+    url: runtime.url,
+    headers: runtime.headers,
+    password: runtime.password,
+    directory: runtime.directory,
+    repo: runtime.repo,
+    branch: runtime.branch,
+    baseCommit: normalizeBaseCommit(runtime.baseCommit),
+    checkoutRef: runtime.checkoutRef,
+    persistent: runtime.persistent,
+    recoverable: runtime.recoverable,
+    providerKey: runtime.providerKey
+  };
+}
+function mapTrpcCode(code) {
+  switch (code) {
+    case "UNAUTHORIZED":
+      return "UNAUTHORIZED";
+    case "NOT_FOUND":
+      return "NOT_FOUND";
+    case "FORBIDDEN":
+      return "FORBIDDEN";
+    case "BAD_REQUEST":
+      return "BAD_REQUEST";
+    case "CONFLICT":
+      return "CONFLICT";
+    case "TIMEOUT":
+      return "TIMEOUT";
+    default:
+      return "SERVER_ERROR";
+  }
+}
+function credentialErrorCode(message) {
+  const match = /^(MODEL_CREDENTIAL_(?:UNAVAILABLE|DUPLICATE_PROVIDER|INVALID|REQUIRED)):\s*/.exec(message);
+  return match?.[1];
+}
+function toGittermError(serverUrl, error) {
+  if (error instanceof GittermError)
+    return error;
+  if (error instanceof TRPCClientError) {
+    const data = error.data;
+    if (!data) {
+      return new GittermError("NETWORK", `Could not reach the GitTerm server at ${serverUrl}`, {
+        cause: error.cause ?? error
+      });
+    }
+    const status = { status: data.httpStatus };
+    const structuredLifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => candidate === data.workspaceLifecycleCode);
+    if (structuredLifecycleCode) {
+      return new WorkspaceLifecycleError(structuredLifecycleCode, error.message, status);
+    }
+    if (error.message.startsWith("INPUT_NOT_PENDING:"))
+      return new GittermError("INPUT_NOT_PENDING", error.message, status);
+    const credentialCode = credentialErrorCode(error.message);
+    if (credentialCode)
+      return new GittermError(credentialCode, error.message, status);
+    const lifecycleCode = WORKSPACE_LIFECYCLE_ERROR_CODES.find((candidate) => error.message.startsWith(`${candidate}:`));
+    if (lifecycleCode)
+      return new WorkspaceLifecycleError(lifecycleCode, error.message, status);
+    const code = mapTrpcCode(data.code);
+    return new GittermError(code, code === "UNAUTHORIZED" ? `${error.message}. Check your GitTerm API token, or create a new one in the dashboard.` : error.message, status);
+  }
+  return new GittermError("NETWORK", error instanceof Error ? error.message : "Network request failed", { cause: error });
+}
+async function runWithServer(serverUrl, operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw toGittermError(serverUrl, error);
+  }
+}
+function isTerminalRun(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+async function* watchRun(trpc, serverUrl, target, options) {
+  const what = `watching run ${target.runId}`;
+  throwIfAborted(options?.signal, what);
+  const queue = [];
+  let wake;
+  const push = (item) => {
+    queue.push(item);
+    wake?.();
+    wake = undefined;
+  };
+  const onAbort = () => push({ error: new GittermError("ABORTED", `Aborted while ${what}`) });
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  let last;
+  const subscription = trpc.run.lifecycle.subscribe(target, {
+    onData: (event) => {
+      last = event.run;
+      push({ run: last });
+    },
+    onError: (error) => push({ error }),
+    onComplete: () => push(last && isTerminalRun(last.status) ? { done: true } : {
+      error: new GittermError("NETWORK", `Run ${target.runId} event stream ended unexpectedly`)
+    })
+  });
+  try {
+    while (true) {
+      throwIfAborted(options?.signal, what);
+      if (queue.length === 0)
+        await new Promise((resolve) => wake = resolve);
+      const item = queue.shift();
+      if ("done" in item)
+        return;
+      if ("error" in item)
+        throw toGittermError(serverUrl, item.error);
+      yield item.run;
+      if (isTerminalRun(item.run.status))
+        return;
+    }
+  } finally {
+    options?.signal?.removeEventListener("abort", onAbort);
+    subscription.unsubscribe();
+  }
+}
+function createGittermClient(options = {}) {
+  const credentials = resolveCredentials(options);
+  const fetchImpl = createNoRedirectFetch(options.fetch);
+  const authorization = `Bearer ${credentials.token}`;
+  const trpc = createTRPCClient({
+    links: [
+      splitLink({
+        condition: (operation) => operation.type === "subscription",
+        true: httpSubscriptionLink({
+          url: trpcEndpoint(credentials.serverUrl),
+          EventSource,
+          eventSourceOptions: {
+            fetch: (url, init) => fetchImpl(url, { ...init, headers: { ...init.headers, authorization } })
+          }
+        }),
+        false: httpBatchLink({
+          url: trpcEndpoint(credentials.serverUrl),
+          fetch: fetchImpl,
+          headers: () => ({ authorization })
+        })
+      })
+    ]
+  });
+  const run = (operation) => runWithServer(credentials.serverUrl, operation);
+  const watch = (ref, watchOptions) => watchRun(trpc, credentials.serverUrl, runTargetOf(ref), watchOptions);
+  const respond = (ref, input) => run(async () => trpc.run.respond.mutate({ ...runTargetOf(ref), ...input }));
+  const normalizeCreateResult = (result) => {
+    const workspace = normalizeWorkspace(result.workspace);
+    if (!workspace)
+      throw new GittermError("SERVER_ERROR", "Workspace creation failed");
+    const runtime = result.runtime ? normalizeRuntime(result.runtime) : {
+      workspaceId: workspace.id,
+      status: workspace.status,
+      url: null,
+      directory: "/workspace",
+      repo: workspace.repositoryUrl,
+      branch: workspace.repositoryBranch,
+      baseCommit: workspace.baseCommit,
+      checkoutRef: workspace.checkoutRef,
+      persistent: workspace.persistent,
+      recoverable: workspace.status !== "terminated",
+      providerKey: null
+    };
+    return { workspace, runtime };
+  };
+  const createWorkspace = (input) => run(async () => {
+    const result = await trpc.workspace.createWorkspace.mutate(input);
+    return normalizeCreateResult(result);
+  });
+  const waitForWorkspaceSetup = async (workspaceId, waitOptions) => {
+    const timeoutMs = waitOptions?.timeoutMs ?? 10 * 60000;
+    const pollIntervalMs = waitOptions?.pollIntervalMs ?? 2000;
+    const signal = waitOptions?.signal;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      throwIfAborted(signal, "waiting for workspace setup");
+      const result = await trpc.workspace.getSetupStatus.query({ workspaceId }, { signal });
+      if (result.status === "not_requested" || result.status === "succeeded")
+        return result;
+      if (result.status === "failed") {
+        const log = result.log?.trim();
+        throw new GittermError("BAD_REQUEST", `Workspace setup failed${result.exitCode === null ? "" : ` with exit code ${result.exitCode}`}${log ? `
+${log}` : ""}`);
+      }
+      if (Date.now() >= deadline) {
+        const log = result.log?.trim();
+        throw new GittermError("TIMEOUT", `Timed out waiting for workspace ${workspaceId} setup (last status: ${result.status})${log ? `
+${log}` : ""}`);
+      }
+      await sleep3(pollIntervalMs, signal, "waiting for workspace setup");
+    }
+  };
+  return {
+    serverUrl: credentials.serverUrl,
+    auth: {
+      status: () => run(async () => {
+        const me = await trpc.agent.me.query();
+        return {
+          loggedIn: true,
+          userId: me.userId,
+          email: me.email,
+          name: me.name,
+          plan: me.plan ?? "free",
+          authMethod: me.authMethod
+        };
+      })
+    },
+    workspaces: {
+      list: (input) => run(async () => {
+        const result = await trpc.workspace.listWorkspaces.query(input);
+        return {
+          workspaces: result.workspaces.map(normalizeWorkspace).filter((workspace) => workspace !== null),
+          pagination: result.pagination
+        };
+      }),
+      get: (ref) => run(async () => {
+        const result = await trpc.workspace.getWorkspace.query({
+          workspaceId: workspaceIdOf(ref)
+        });
+        const workspace = normalizeWorkspace(result.workspace);
+        if (!workspace)
+          throw new GittermError("NOT_FOUND", "Workspace not found");
+        return workspace;
+      }),
+      getRuntimeAccess: (ref) => run(async () => {
+        const result = await trpc.workspace.getRuntimeAccess.query({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return normalizeRuntime(result);
+      }),
+      ensureRunning: (ref, waitOptions) => run(async () => {
+        throwIfAborted(waitOptions?.signal, "ensuring the workspace is running");
+        const result = await trpc.workspace.ensureRunning.mutate({
+          workspaceId: workspaceIdOf(ref),
+          timeoutMs: waitOptions?.timeoutMs,
+          pollIntervalMs: waitOptions?.pollIntervalMs
+        }, { signal: waitOptions?.signal });
+        const workspace = normalizeWorkspace(result.workspace);
+        if (!workspace)
+          throw new GittermError("SERVER_ERROR", "ensureRunning failed");
+        return {
+          workspace,
+          runtime: normalizeRuntime(result.runtime)
+        };
+      }),
+      pause: (ref) => run(async () => {
+        const result = await trpc.workspace.pauseWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return { durationMinutes: result.durationMinutes };
+      }),
+      restart: (ref) => run(async () => {
+        const result = await trpc.workspace.restartWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return { status: result.status };
+      }),
+      terminate: (ref) => run(async () => {
+        const result = await trpc.workspace.deleteWorkspace.mutate({
+          workspaceId: workspaceIdOf(ref)
+        });
+        return {
+          workspace: normalizeWorkspace(result.workspace),
+          cleanupInBackground: result.cleanupInBackground
+        };
+      }),
+      create: createWorkspace,
+      models: (ref) => run(() => trpc.workspace.getModelAccess.query({ workspaceId: workspaceIdOf(ref) })),
+      setupStatus: (ref) => run(async () => trpc.workspace.getSetupStatus.query({ workspaceId: workspaceIdOf(ref) })),
+      waitForSetup: (ref, waitOptions) => run(() => waitForWorkspaceSetup(workspaceIdOf(ref), waitOptions))
+    },
+    sandboxes: {
+      create: (input) => run(() => trpc.sandbox.create.mutate(input)),
+      list: (input) => run(() => trpc.sandbox.list.query(input)),
+      get: (sandboxId) => run(() => trpc.sandbox.get.query({ sandboxId })),
+      run: (sandboxId, command, options) => run(async () => {
+        const result = await trpc.sandbox.run.mutate({ sandboxId, command, ...options });
+        if (!result)
+          throw new GittermError("SERVER_ERROR", "Sandbox command returned no result");
+        return result;
+      }),
+      writeFile: (sandboxId, path, data) => run(async () => {
+        await trpc.sandbox.writeFile.mutate({
+          sandboxId,
+          path,
+          contentBase64: Buffer.from(data).toString("base64")
+        });
+      }),
+      readFile: (sandboxId, path) => run(async () => {
+        const result = await trpc.sandbox.readFile.mutate({ sandboxId, path });
+        return new Uint8Array(Buffer.from(result?.contentBase64 ?? "", "base64"));
+      }),
+      preview: (sandboxId, port, options) => run(async () => {
+        const result = await trpc.sandbox.preview.mutate({
+          sandboxId,
+          port,
+          public: options?.public
+        });
+        if (!result)
+          throw new GittermError("SERVER_ERROR", "Sandbox preview returned no result");
+        return result;
+      }),
+      resume: (sandboxId) => run(async () => {
+        await trpc.workspace.restartWorkspace.mutate({ workspaceId: sandboxId });
+      }),
+      terminate: (sandboxId) => run(async () => {
+        await trpc.sandbox.terminate.mutate({ sandboxId });
+      }),
+      saveSnapshot: (sandboxId, label) => run(() => trpc.sandbox.saveSnapshot.mutate({ sandboxId, label: label.slice(0, 120) })),
+      listSnapshots: () => run(() => trpc.sandbox.snapshots.query()),
+      deleteSnapshot: (snapshotId) => run(async () => {
+        await trpc.sandbox.deleteSnapshot.mutate({ snapshotId });
+      }),
+      onJobFinished: (listener) => {
+        const subscription = trpc.sandbox.jobEvents.subscribe(undefined, {
+          onData: (event) => listener(event),
+          onError: () => {}
+        });
+        return () => subscription.unsubscribe();
+      }
+    },
+    runs: {
+      create: (input) => run(async () => {
+        const { signal, workspace, ...rest } = input;
+        const request = {
+          ...rest,
+          workspaceId: workspaceIdOf(workspace),
+          context: rest.context?.type === "continue" ? { type: "continue", runId: rest.context.run.id } : rest.context
+        };
+        if (request.waitForSetup) {
+          await waitForWorkspaceSetup(request.workspaceId, {
+            timeoutMs: request.setupTimeoutMs,
+            signal
+          });
+        }
+        throwIfAborted(signal, "creating the run");
+        return trpc.run.create.mutate({ ...request, idempotencyKey: request.idempotencyKey ?? crypto.randomUUID() }, { signal });
+      }),
+      list: (ref, listOptions) => run(async () => trpc.run.list.query({
+        workspaceId: workspaceIdOf(ref),
+        ...listOptions
+      })),
+      get: (ref) => run(async () => trpc.run.get.query(runTargetOf(ref))),
+      messages: (ref) => run(async () => {
+        const messages = await trpc.run.messages.query(runTargetOf(ref));
+        return messages.map((message) => ({ ...message, parts: message.parts ?? [] }));
+      }),
+      cancel: (ref) => run(async () => trpc.run.cancel.mutate(runTargetOf(ref))),
+      respond,
+      watch,
+      ...runHelpers({ watch, respond })
+    },
+    catalog: {
+      agentTypes: (input) => run(async () => {
+        const result = await trpc.workspace.listAgentTypes.query(input);
+        return result.agentTypes;
+      }),
+      cloudProviders: (input) => run(async () => {
+        const result = await trpc.workspace.listCloudProviders.query(input);
+        return result.cloudProviders;
+      }),
+      workspaceOptions: () => run(async () => trpc.workspace.getWorkspaceCatalog.query())
+    },
+    integrations: {
+      catalog: () => run(async () => trpc.integrations.catalog.query()),
+      connections: {
+        list: (filter) => run(async () => {
+          const result = await trpc.integrations.connections.list.query(filter);
+          return result.map(toConnection);
+        }),
+        get: (id) => run(async () => toConnection(await trpc.integrations.connections.get.query({ id }))),
+        resolve: (references, options) => run(async () => {
+          const result = await trpc.integrations.connections.resolve.query({
+            references,
+            ...options?.repo ? { repo: options.repo } : {}
+          });
+          return result.map(toConnection);
+        }),
+        create: (input) => run(async () => {
+          const result = await trpc.integrations.connections.create.mutate(input);
+          return result.status !== "pending" ? { ...result, connection: toConnection(result.connection) } : result;
+        }),
+        remove: (id) => run(async () => {
+          await trpc.integrations.connections.remove.mutate({ id });
+        }),
+        waitFor: ({
+          integration,
+          since,
+          connectionId,
+          timeoutMs = 5 * 60000,
+          intervalMs = 3000
+        }) => run(async () => {
+          const sinceMs = since ? new Date(since).getTime() : 0;
+          const deadline = Date.now() + timeoutMs;
+          while (Date.now() < deadline) {
+            const result = await trpc.integrations.connections.list.query({
+              integration,
+              kind: "personal"
+            });
+            const match = result.map(toConnection).filter((c) => c.status === "connected" && (connectionId ? c.id === connectionId : new Date(c.connectedAt).getTime() >= sinceMs)).sort((a, b) => b.connectedAt.localeCompare(a.connectedAt))[0];
+            if (match)
+              return match;
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+          }
+          throw new Error(`Timed out waiting for a ${integration} connection`);
+        })
+      },
+      github: {
+        repositories: (connectionId) => run(async () => trpc.integrations.github.repositories.query({ connectionId })),
+        branches: (connectionId, owner, repo) => run(async () => trpc.integrations.github.branches.query({ connectionId, owner, repo }))
+      },
+      google: {
+        setup: () => run(async () => trpc.integrations.google.setup.query())
+      },
+      mcp: {
+        test: (id) => run(async () => {
+          const result = await trpc.integrations.mcp.test.mutate({ id });
+          return { ...result, connection: toConnection(result.connection) };
+        }),
+        update: (input) => run(async () => toConnection(await trpc.integrations.mcp.update.mutate(input)))
+      }
+    },
+    bots: {
+      acquireLease: (leaseId) => run(() => trpc.bots.acquireLease.mutate({ leaseId })),
+      releaseLease: (leaseId) => run(() => trpc.bots.releaseLease.mutate({ leaseId })),
+      self: () => run(async () => trpc.bots.self.query())
+    },
+    credentials: {
+      list: () => run(async () => {
+        const result = await trpc.modelCredentials.listMyCredentials.query();
+        return result.credentials.map((credential) => ({
+          ...credential,
+          lastUsedAt: toIso(credential.lastUsedAt),
+          oauthExpiresAt: toIso(credential.oauthExpiresAt),
+          createdAt: toIso(credential.createdAt),
+          updatedAt: toIso(credential.updatedAt)
+        }));
+      }),
+      listProviders: () => run(async () => {
+        const result = await trpc.modelCredentials.listProviders.query();
+        return result.providers.map((provider) => ({
+          id: provider.id,
+          name: provider.name,
+          logicalProviderKey: provider.logicalProviderKey,
+          displayName: provider.displayName,
+          authType: provider.authType,
+          isRecommended: provider.isRecommended
+        }));
+      })
+    }
+  };
+}
+
+// src/sandbox/config.ts
+var DIRECT_PROVIDERS = ["e2b", "daytona", "vercel", "boat", "exedev", "railway"];
+var PROVIDER_NAMES = {
+  e2b: "E2B",
+  daytona: "Daytona",
+  vercel: "Vercel",
+  boat: "Boat",
+  exedev: "exe.dev",
+  railway: "Railway",
+  aws: "AWS",
+  gitterm: "Gitterm"
+};
+function selected(settings, accountName) {
+  const name = accountName ?? settings.account;
+  const accounts = settings.accounts ?? {};
+  if (!name) {
+    const names = Object.keys(accounts);
+    throw new Error(names.length ? `No sandbox account selected. Choose one of: ${names.join(", ")}.` : "No sandbox accounts are configured. Add one to the sandbox settings.");
+  }
+  const config = accounts[validateAccountName(name)];
+  if (!config)
+    throw new Error(`Sandbox account ${JSON.stringify(name)} is not configured.`);
+  const mode = config.mode;
+  if (mode !== "direct" && mode !== "managed")
+    throw new Error(`Sandbox account ${name} has an unknown mode.`);
+  const provider = config.provider ?? (config.mode === "managed" && config.size ? "gitterm" : "e2b");
+  if (config.mode === "managed" && config.size && provider !== "gitterm")
+    throw new Error(`Sandbox account ${name}: "size" picks a Gitterm size; drop "provider" or use "machine".`);
+  if (!Object.hasOwn(SANDBOX_PROVIDER_PROFILES, provider))
+    throw new Error(`Sandbox account ${name} uses provider ${JSON.stringify(provider)}, which does not support sandboxes.`);
+  if (mode === "direct" && !DIRECT_PROVIDERS.includes(provider))
+    throw new Error(`Sandbox account ${name}: ${provider} sandboxes are available only as a managed account.`);
+  return { name, config, provider };
+}
+function directCredential(config) {
+  if (config.apiKey !== undefined)
+    return { source: "plugin option", value: config.apiKey.trim() };
+  if (config.apiKeyEnv)
+    return {
+      source: `environment variable ${config.apiKeyEnv}`,
+      value: process.env[config.apiKeyEnv]?.trim() ?? ""
+    };
+  return { source: "not configured", value: "" };
+}
+function describeLimitations(provider, mode) {
+  const capabilities = mode === "managed" ? managedCapabilities(provider) : SANDBOX_PROVIDER_PROFILES[provider].capabilities;
+  const name = PROVIDER_NAMES[provider];
+  return [
+    mode === "managed" ? "Gitterm terminates the sandbox at its lifetime, even if this machine is offline." : capabilities.expiry === "hard" ? `${name} deletes the sandbox at its lifetime, even if this machine is offline.` : capabilities.expiry === "idle" ? `${name} deletes the sandbox after it has been idle for its lifetime; an actively used sandbox can run longer.` : capabilities.expiry === "archive" ? `${name} stops and archives the sandbox at its lifetime; the archived storage remains until you destroy it.` : `${name} never deletes an abandoned sandbox. Destroy it yourself; a crash leaves it running and billing.`,
+    capabilities.previews === "either" ? mode === "managed" ? "Gitterm serves previews: private to your Gitterm login unless created with public previews." : "Previews are private unless created with public previews." : capabilities.previews === "private" ? `${name} previews are always private: they need an access header.` : capabilities.previews === "public" ? `${name} previews are always public URLs, so they need the public-sharing approval.` : `${name} sandboxes cannot expose ports.`,
+    ...capabilities.pause === "state-losing" ? [`Pausing a ${name} sandbox discards its files and processes.`] : []
+  ];
+}
+function describeMachine(config) {
+  if (config.mode === "managed") {
+    const machine = config.size ?? config.machine;
+    return machine ? `Gitterm machine profile "${machine}".` : "Your Gitterm plan's default machine profile.";
+  }
+  switch (config.provider) {
+    case "e2b":
+      if (config.snapshot)
+        return `E2B snapshot "${config.snapshot}" (sized as when it was saved).`;
+      return config.template ? `E2B template "${config.template}" (its size is fixed when the template is built).` : "E2B base template: 2 vCPU, 512 MB memory.";
+    case "daytona": {
+      if (config.snapshot)
+        return `Daytona snapshot "${config.snapshot}" (sized by the snapshot).`;
+      const { cpu = 1, memory = 1, disk = 3 } = config.resources ?? {};
+      return `${cpu} vCPU, ${memory} GiB memory, ${disk} GiB disk.`;
+    }
+    case "vercel": {
+      const vcpus = config.vcpus ?? 2;
+      return `${vcpus} vCPU, ${vcpus * 2} GB memory${config.snapshot ? `, from snapshot "${config.snapshot}"` : ""}.`;
+    }
+    case "boat":
+      return `Boat size "${config.size ?? "default"}"${config.snapshot ? `, from snapshot "${config.snapshot}"` : ""}.`;
+    case "exedev":
+      return config.cpu || config.memory || config.disk ? `${[config.cpu && `${config.cpu} vCPU`, config.memory && `${config.memory} memory`, config.disk && `${config.disk} disk`].filter(Boolean).join(", ")}.` : "exe.dev's default VM size.";
+    case "railway":
+      return "Railway's per-service limits for your Railway plan.";
+  }
+}
+function describeSandboxAccount(settings, accountName) {
+  const { name, config, provider } = selected(settings, accountName);
+  const base = {
+    name,
+    provider,
+    capabilities: config.mode === "managed" ? managedCapabilities(provider) : SANDBOX_PROVIDER_PROFILES[provider].capabilities,
+    limitations: describeLimitations(provider, config.mode),
+    pinnedSnapshot: config.mode === "direct" && "snapshot" in config ? config.snapshot ?? null : null,
+    machine: `${describeMachine(config)} Only the user can change this, in the settings of sandbox account "${name}".`
+  };
+  if (config.mode === "direct") {
+    const credential = directCredential(config);
+    return {
+      ...base,
+      mode: "direct",
+      credentialSource: credential.source,
+      credentialPresent: Boolean(credential.value),
+      chargedTo: `your ${PROVIDER_NAMES[provider]} account (no Gitterm account or credits used)`
+    };
+  }
+  return {
+    ...base,
+    mode: "managed",
+    credentialSource: config.token ? "plugin option" : "Gitterm CLI login or GITTERM_API_TOKEN",
+    credentialPresent: true,
+    chargedTo: "your Gitterm plan (usage, quotas, and limits apply)"
+  };
+}
+function createSandboxBackend(settings, accountName) {
+  const { name, config, provider } = selected(settings, accountName);
+  if (config.mode === "managed")
+    return createManagedSandboxBackend({
+      account: name,
+      provider,
+      client: createGittermClient({ serverUrl: config.serverUrl, token: config.token }),
+      machine: config.size ?? config.machine
+    });
+  const credential = directCredential(config);
+  if (!credential.value)
+    throw new Error(`Sandbox account ${name} has no ${PROVIDER_NAMES[provider]} credential (${credential.source}). In OpenCode use "apiKey": "{env:YOUR_VARIABLE}" and make sure the variable is set.`);
+  if (config.provider === "daytona" && config.snapshot && config.resources)
+    throw new Error(`Sandbox account ${name}: a Daytona snapshot carries its own size, so set "snapshot" or "resources", not both.`);
+  const { apiKey: _apiKey, apiKeyEnv: _apiKeyEnv, allowUnboundedLifetime, ...options } = config;
+  return withAuthHint(createDirectSandboxBackend({
+    account: name,
+    allowUnboundedLifetime,
+    transport: createSandboxTransport({ ...options, apiKey: credential.value })
+  }), `This is your own ${PROVIDER_NAMES[provider]} key, not Gitterm's: check sandbox account "${name}" in your settings.`);
+}
+function withAuthHint(backend, hint) {
+  return new Proxy(backend, {
+    get(target, key, receiver) {
+      const value = Reflect.get(target, key, receiver);
+      if (typeof value !== "function")
+        return value;
+      return async (...args) => {
+        try {
+          return await value.apply(target, args);
+        } catch (error) {
+          if (isSandboxProviderError(error) && error.code === "auth")
+            error.message = `${error.message} ${hint}`;
+          throw error;
+        }
+      };
+    }
+  });
+}
+// src/sandbox/proxy.ts
+import { randomBytes as randomBytes9, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+var TOKEN_PARAM = "gitterm_preview_token";
+var COOKIE = "gitterm_preview";
+var TOKEN_FORMAT = /^[0-9a-f]{48}$/;
+var HOP_BY_HOP = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+  "cookie"
+]);
+function cookies(header) {
+  const result = new Map;
+  for (const part of (header ?? "").split(";")) {
+    const index = part.indexOf("=");
+    if (index > 0)
+      result.set(part.slice(0, index).trim(), part.slice(index + 1).trim());
+  }
+  return result;
+}
+async function startPreviewProxy(access) {
+  const upstream = new URL(access.url);
+  const token = randomBytes9(24).toString("hex");
+  const hostname = `p-${randomBytes9(8).toString("hex")}.localhost`;
+  const matches = (value) => !!value && TOKEN_FORMAT.test(value) && timingSafeEqual(Buffer.from(value), Buffer.from(token));
+  const { cookie: accessCookie, ...accessHeaders } = access.headers;
+  let expectedHost = "";
+  async function handle(request, response) {
+    if (request.headers.host?.toLowerCase() !== expectedHost) {
+      response.writeHead(421).end();
+      return;
+    }
+    const local = new URL(request.url ?? "/", `http://${expectedHost}`);
+    const jar = cookies(request.headers.cookie);
+    if (matches(local.searchParams.get(TOKEN_PARAM))) {
+      local.searchParams.delete(TOKEN_PARAM);
+      response.writeHead(303, {
+        "set-cookie": `${COOKIE}=${token}; HttpOnly; SameSite=Strict; Path=/`,
+        location: `${local.pathname}${local.search}`
+      });
+      response.end();
+      return;
+    }
+    if (!matches(jar.get(COOKIE))) {
+      response.writeHead(401).end();
+      return;
+    }
+    jar.delete(COOKIE);
+    const target = new URL(upstream.href);
+    target.pathname = local.pathname;
+    target.search = local.search;
+    if (target.origin !== upstream.origin) {
+      response.writeHead(400).end();
+      return;
+    }
+    const headers = new Headers;
+    for (const [key, value] of Object.entries(request.headers)) {
+      if (value === undefined || HOP_BY_HOP.has(key.toLowerCase()))
+        continue;
+      headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+    for (const [key, value] of Object.entries(accessHeaders))
+      headers.set(key, value);
+    const forwarded = [...[...jar].map(([name, value]) => `${name}=${value}`), accessCookie].filter(Boolean);
+    if (forwarded.length)
+      headers.set("cookie", forwarded.join("; "));
+    const body = request.method === "GET" || request.method === "HEAD" ? undefined : Readable.toWeb(request);
+    const upstreamResponse = await fetch(target, {
+      method: request.method,
+      headers,
+      body,
+      redirect: "manual",
+      duplex: "half"
+    });
+    const responseHeaders = {};
+    upstreamResponse.headers.forEach((value, key) => {
+      if (!HOP_BY_HOP.has(key) && key !== "content-encoding" && key !== "content-length" && key !== "set-cookie")
+        responseHeaders[key] = value;
+    });
+    const setCookies = upstreamResponse.headers.getSetCookie();
+    if (setCookies.length)
+      responseHeaders["set-cookie"] = setCookies.map((cookie) => cookie.split(";").filter((part) => !/^\s*domain=/i.test(part)).join(";"));
+    const location = upstreamResponse.headers.get("location");
+    if (location) {
+      const resolved = new URL(location, target);
+      if (resolved.origin === upstream.origin)
+        responseHeaders.location = `${resolved.pathname}${resolved.search}${resolved.hash}`;
+    }
+    response.writeHead(upstreamResponse.status, responseHeaders);
+    if (upstreamResponse.body)
+      Readable.fromWeb(upstreamResponse.body).pipe(response);
+    else
+      response.end();
+  }
+  const server = createServer((request, response) => {
+    handle(request, response).catch(() => {
+      if (!response.headersSent)
+        response.writeHead(502);
+      response.end();
+    });
+  });
+  server.on("clientError", (_error, socket) => socket.destroy());
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address();
+  expectedHost = `${hostname}:${port}`;
+  return {
+    url: `http://${expectedHost}/?${TOKEN_PARAM}=${token}`,
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+export {
+  ArtifactConflictError,
+  DEFAULT_LOG_TAIL_BYTES,
+  DEFAULT_SANDBOX_LIMITS,
+  MAX_SOURCE_BYTES,
+  SandboxAccountError,
+  applyArtifact,
+  artifactDirectory,
+  captureSource,
+  createFileSandboxStore,
+  createFileSetupSnapshotStore,
+  createManagedSandboxBackend,
+  createSandboxBackend,
+  createSandboxClient,
+  defaultStoreDirectory,
+  describeSandboxAccount,
+  isSandboxProviderError,
+  jobRoot,
+  projectDir,
+  sanitizeOutput,
+  sensitivePath,
+  startPreviewProxy
+};