openpond 0.0.30-bootstrap.0

package/dist/chunks/sandbox-command-5GFJ2U3V.js

@@ -0,0 +1,1652 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  buildSandboxCreateInput,
+  buildSandboxIntegrationAttachInput,
+  buildSandboxReplayInput,
+  buildSnapshotCreateInput,
+  buildTemplateBuildCreateInput,
+  createSandboxFromPlan,
+  formatReplayLine,
+  formatSandboxLine,
+  formatSandboxTemplateLine,
+  formatSnapshotCatalogLine,
+  formatTemplateBuildLine,
+  normalizeSnapshotValidationCleanup,
+  summarizeReplayArtifact,
+  summarizeSandbox,
+  waitForSandboxCreateReady
+} from "./chunk-AUJLPKGI.js";
+import {
+  readSandboxSecretValue,
+  resolveSandboxClient,
+  summarizeSandboxSecret
+} from "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import {
+  parseBooleanOption,
+  parseIntegerOption,
+  parseJsonObjectOption,
+  parseNumberOption
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/sandbox-files-command.ts
+async function handleSandboxFilesCommand(client, subcommand, options, rest) {
+  if (subcommand === "list-files") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox list-files <sandboxId> [--path <path>]");
+    }
+    const path = typeof options.path === "string" ? options.path.trim() : void 0;
+    const maxEntries = parseNumberOption(options.maxEntries, "max-entries");
+    const recursive = options.recursive !== void 0 ? parseBooleanOption(options.recursive) : void 0;
+    const result = await client.listFiles(sandboxId, {
+      ...path ? { path } : {},
+      ...recursive !== void 0 ? { recursive } : {},
+      ...maxEntries !== void 0 ? { maxEntries } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          files: result.files
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "upload-file") {
+    const sandboxId = rest[1];
+    const path = typeof options.path === "string" ? options.path.trim() : "";
+    const contents = typeof options.contents === "string" ? options.contents : typeof options.content === "string" ? options.content : "";
+    const contentsBase64 = typeof options.contentsBase64 === "string" ? options.contentsBase64.trim() : typeof options.contentBase64 === "string" ? options.contentBase64.trim() : "";
+    if (!sandboxId || !path) {
+      throw new Error(
+        'usage: sandbox upload-file <sandboxId> --path <path> --contents "text"'
+      );
+    }
+    if (!contents && !contentsBase64) {
+      throw new Error(
+        'usage: sandbox upload-file <sandboxId> --path <path> --contents "text"'
+      );
+    }
+    const result = contentsBase64 ? await client.uploadFileBase64(sandboxId, path, contentsBase64) : await client.uploadFile(sandboxId, path, contents);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          file: result.file
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "download-file") {
+    const sandboxId = rest[1];
+    const path = typeof options.path === "string" ? options.path.trim() : "";
+    const offsetBytes = Number(options["offset-bytes"]);
+    const maxBytes = Number(options["max-bytes"]);
+    if (!sandboxId || !path) {
+      throw new Error("usage: sandbox download-file <sandboxId> --path <path>");
+    }
+    const result = await client.downloadFileResponse(sandboxId, {
+      path,
+      ...Number.isFinite(offsetBytes) ? { offsetBytes } : {},
+      ...Number.isFinite(maxBytes) ? { maxBytes } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          file: result.file,
+          contents: Buffer.from(result.file.contentsBase64, "base64").toString(
+            "utf-8"
+          )
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "search-files") {
+    const sandboxId = rest[1];
+    const query = typeof options.query === "string" ? options.query.trim() : "";
+    if (!sandboxId || !query) {
+      throw new Error(
+        "usage: sandbox search-files <sandboxId> --query <text> [--path <path>]"
+      );
+    }
+    const path = typeof options.path === "string" ? options.path.trim() : void 0;
+    const maxResults = parseNumberOption(options.maxResults, "max-results");
+    const result = await client.searchFiles(sandboxId, {
+      query,
+      ...path ? { path } : {},
+      ...maxResults !== void 0 ? { maxResults } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          matches: result.matches
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "delete-file") {
+    const sandboxId = rest[1];
+    const path = typeof options.path === "string" ? options.path.trim() : "";
+    if (!sandboxId || !path) {
+      throw new Error(
+        "usage: sandbox delete-file <sandboxId> --path <path> [--recursive]"
+      );
+    }
+    const result = await client.deleteFile(sandboxId, path, {
+      recursive: parseBooleanOption(options.recursive)
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          deleted: result.deleted
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "stat-file") {
+    const sandboxId = rest[1];
+    const path = typeof options.path === "string" ? options.path.trim() : "";
+    if (!sandboxId || !path) {
+      throw new Error("usage: sandbox stat-file <sandboxId> --path <path>");
+    }
+    const result = await client.statFile(sandboxId, path);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          file: result.file
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "mkdir") {
+    const sandboxId = rest[1];
+    const path = typeof options.path === "string" ? options.path.trim() : "";
+    if (!sandboxId || !path) {
+      throw new Error(
+        "usage: sandbox mkdir <sandboxId> --path <path> [--recursive false]"
+      );
+    }
+    const result = await client.mkdir(sandboxId, {
+      path,
+      recursive: options.recursive !== void 0 ? parseBooleanOption(options.recursive) : void 0
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          directory: result.directory
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "move-file") {
+    const sandboxId = rest[1];
+    const fromPath = typeof options.fromPath === "string" ? options.fromPath.trim() : "";
+    const toPath = typeof options.toPath === "string" ? options.toPath.trim() : "";
+    if (!sandboxId || !fromPath || !toPath) {
+      throw new Error(
+        "usage: sandbox move-file <sandboxId> --from-path <path> --to-path <path> [--overwrite]"
+      );
+    }
+    const result = await client.moveFile(sandboxId, {
+      fromPath,
+      toPath,
+      overwrite: parseBooleanOption(options.overwrite)
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          moved: result.moved,
+          file: result.file
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  return false;
+}
+
+// src/cli/sandbox-git-command.ts
+async function handleSandboxGitCommand(client, subcommand, options, rest) {
+  if (subcommand === "git-status") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox git-status <sandboxId>");
+    }
+    const result = await client.gitStatus(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          status: result.status
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-diff") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox git-diff <sandboxId> [--base-ref <ref>]");
+    }
+    const baseRef = typeof options.baseRef === "string" && options.baseRef.trim() ? options.baseRef.trim() : void 0;
+    const result = await client.gitDiff(sandboxId, {
+      ...baseRef ? { baseRef } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          diff: result.diff
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-export-patch") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox git-export-patch <sandboxId> [--base-ref <ref>]"
+      );
+    }
+    const baseRef = typeof options.baseRef === "string" && options.baseRef.trim() ? options.baseRef.trim() : void 0;
+    const result = await client.gitExportPatch(sandboxId, {
+      ...baseRef ? { baseRef } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          patch: result.patch
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-branch") {
+    const sandboxId = rest[1];
+    const branch = typeof options.branch === "string" ? options.branch.trim() : "";
+    const startPoint = typeof options.startPoint === "string" && options.startPoint.trim() ? options.startPoint.trim() : void 0;
+    if (!sandboxId || !branch) {
+      throw new Error(
+        "usage: sandbox git-branch <sandboxId> --branch <name> [--create] [--start-point <ref>]"
+      );
+    }
+    const result = await client.gitBranch(sandboxId, {
+      branch,
+      create: parseBooleanOption(options.create),
+      ...startPoint ? { startPoint } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          branch: result.branch
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-commit") {
+    const sandboxId = rest[1];
+    const message = typeof options.message === "string" ? options.message.trim() : "";
+    const all = parseBooleanOption(options.all);
+    const rawPaths = typeof options.paths === "string" ? options.paths : typeof options.path === "string" ? options.path : "";
+    const paths = rawPaths.split(",").map((path) => path.trim()).filter(Boolean);
+    if (!sandboxId || !message || !all && paths.length === 0) {
+      throw new Error(
+        'usage: sandbox git-commit <sandboxId> --message "..." [--all|--paths <csv>]'
+      );
+    }
+    const result = await client.gitCommit(sandboxId, {
+      message,
+      ...all ? { all: true } : { paths }
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          commit: result.commit
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-pull") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox git-pull <sandboxId> [--remote origin] [--branch main] [--rebase|--ff-only false]"
+      );
+    }
+    const remote = typeof options.remote === "string" && options.remote.trim() ? options.remote.trim() : void 0;
+    const branch = typeof options.branch === "string" && options.branch.trim() ? options.branch.trim() : void 0;
+    const result = await client.gitPull(sandboxId, {
+      ...remote ? { remote } : {},
+      ...branch ? { branch } : {},
+      ...options.rebase !== void 0 ? { rebase: parseBooleanOption(options.rebase) } : {},
+      ...options.ffOnly !== void 0 ? { ffOnly: parseBooleanOption(options.ffOnly) } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          pull: result.pull
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "git-push") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox git-push <sandboxId> [--remote origin] [--branch main] [--set-upstream] [--force-with-lease]"
+      );
+    }
+    const remote = typeof options.remote === "string" && options.remote.trim() ? options.remote.trim() : void 0;
+    const branch = typeof options.branch === "string" && options.branch.trim() ? options.branch.trim() : void 0;
+    const result = await client.gitPush(sandboxId, {
+      ...remote ? { remote } : {},
+      ...branch ? { branch } : {},
+      ...options.setUpstream !== void 0 ? { setUpstream: parseBooleanOption(options.setUpstream) } : {},
+      ...options.forceWithLease !== void 0 ? { forceWithLease: parseBooleanOption(options.forceWithLease) } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          push: result.push
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  return false;
+}
+
+// src/cli/sandbox-process-command.ts
+async function handleSandboxProcessCommand(client, subcommand, options, rest) {
+  if (subcommand === "process-start") {
+    const sandboxId = rest[1];
+    const command = (typeof options.command === "string" ? options.command : null) || rest.slice(2).join(" ");
+    if (!sandboxId || !command.trim()) {
+      throw new Error(
+        "usage: sandbox process-start <sandboxId> --command <command>"
+      );
+    }
+    const timeoutSeconds = parseIntegerOption(
+      options.timeoutSeconds,
+      "timeout-seconds"
+    );
+    const result = await client.startProcess(sandboxId, {
+      command: command.trim(),
+      ...timeoutSeconds !== void 0 ? { timeoutSeconds } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          process: result.process
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "process-list") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox process-list <sandboxId>");
+    }
+    const result = await client.listProcesses(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          processes: result.processes
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "process-get") {
+    const sandboxId = rest[1];
+    const processId = rest[2];
+    if (!sandboxId || !processId) {
+      throw new Error(
+        "usage: sandbox process-get <sandboxId> <processId> [--since <cursor>]"
+      );
+    }
+    const since = parseIntegerOption(options.since, "since");
+    const result = await client.getProcess(sandboxId, processId, {
+      ...since !== void 0 ? { since } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          process: result.process,
+          output: result.output,
+          cursor: result.cursor,
+          completed: result.completed
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "process-stop") {
+    const sandboxId = rest[1];
+    const processId = rest[2];
+    if (!sandboxId || !processId) {
+      throw new Error("usage: sandbox process-stop <sandboxId> <processId>");
+    }
+    const result = await client.stopProcess(sandboxId, processId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          process: result.process
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "process-stream") {
+    const sandboxId = rest[1];
+    const processId = rest[2];
+    if (!sandboxId || !processId) {
+      throw new Error(
+        "usage: sandbox process-stream <sandboxId> <processId> [--since <cursor>]"
+      );
+    }
+    const since = parseIntegerOption(options.since, "since");
+    await client.streamProcessOutput(sandboxId, processId, {
+      ...since !== void 0 ? { since } : {}
+    });
+    return true;
+  }
+  if (subcommand === "pty-start") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox pty-start <sandboxId> [--command <command>]"
+      );
+    }
+    const command = (typeof options.command === "string" ? options.command : null) || rest.slice(2).join(" ");
+    const timeoutSeconds = parseIntegerOption(
+      options.timeoutSeconds,
+      "timeout-seconds"
+    );
+    const rows = parseIntegerOption(options.rows, "rows");
+    const cols = parseIntegerOption(options.cols, "cols");
+    const result = await client.startPty(sandboxId, {
+      ...command.trim() ? { command: command.trim() } : {},
+      ...timeoutSeconds !== void 0 ? { timeoutSeconds } : {},
+      ...rows !== void 0 ? { rows } : {},
+      ...cols !== void 0 ? { cols } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          pty: result.pty
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "pty-list") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox pty-list <sandboxId>");
+    }
+    const result = await client.listPtys(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          ptys: result.ptys
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "pty-get") {
+    const sandboxId = rest[1];
+    const ptyId = rest[2];
+    if (!sandboxId || !ptyId) {
+      throw new Error(
+        "usage: sandbox pty-get <sandboxId> <ptyId> [--since <cursor>]"
+      );
+    }
+    const since = parseIntegerOption(options.since, "since");
+    const result = await client.getPty(sandboxId, ptyId, {
+      ...since !== void 0 ? { since } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          pty: result.pty,
+          output: result.output,
+          cursor: result.cursor,
+          completed: result.completed
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "pty-write") {
+    const sandboxId = rest[1];
+    const ptyId = rest[2];
+    const inputBase64 = typeof options.inputBase64 === "string" ? options.inputBase64.trim() : "";
+    const inputText = (typeof options.input === "string" ? options.input : null) || rest.slice(3).join(" ");
+    if (!sandboxId || !ptyId || !inputBase64 && !inputText) {
+      throw new Error(
+        "usage: sandbox pty-write <sandboxId> <ptyId> --input <text>"
+      );
+    }
+    const result = await client.writePtyInput(
+      sandboxId,
+      ptyId,
+      inputBase64 ? { dataBase64: inputBase64 } : inputText
+    );
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          pty: result.pty
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "pty-stop") {
+    const sandboxId = rest[1];
+    const ptyId = rest[2];
+    if (!sandboxId || !ptyId) {
+      throw new Error("usage: sandbox pty-stop <sandboxId> <ptyId>");
+    }
+    const result = await client.stopPty(sandboxId, ptyId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          pty: result.pty
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "pty-stream") {
+    const sandboxId = rest[1];
+    const ptyId = rest[2];
+    if (!sandboxId || !ptyId) {
+      throw new Error(
+        "usage: sandbox pty-stream <sandboxId> <ptyId> [--since <cursor>]"
+      );
+    }
+    const since = parseIntegerOption(options.since, "since");
+    await client.streamPtyOutput(sandboxId, ptyId, {
+      ...since !== void 0 ? { since } : {}
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/cli/sandbox-replay-command.ts
+async function handleSandboxReplayCommand(client, subcommand, options, rest) {
+  if (subcommand === "replays" || subcommand === "replay-list") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const result = await client.listReplays({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {}
+    });
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify(result, null, 2));
+      return true;
+    }
+    if (result.replays.length === 0) {
+      console.log("no sandbox replays found");
+      return true;
+    }
+    for (const replay of result.replays) {
+      console.log(formatReplayLine(replay));
+    }
+    return true;
+  }
+  if (subcommand === "replay-start" || subcommand === "start-replay") {
+    const result = await client.startReplay(buildSandboxReplayInput(options));
+    console.log(JSON.stringify(result, null, 2));
+    return true;
+  }
+  if (subcommand === "replay-get" || subcommand === "get-replay") {
+    const replayId = rest[1];
+    if (!replayId) {
+      throw new Error("usage: sandbox replay-get <replayId> [--team-id <id>]");
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const result = await client.getReplay(replayId, {
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return true;
+  }
+  if (subcommand === "replay-logs" || subcommand === "logs-replay") {
+    const replayId = rest[1];
+    if (!replayId) {
+      throw new Error("usage: sandbox replay-logs <replayId> [--team-id <id>]");
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const result = await client.getReplayLogs(replayId, {
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {}
+    });
+    for (const line of result.logs) {
+      console.log(line);
+    }
+    return true;
+  }
+  if (subcommand === "replay-artifacts" || subcommand === "artifacts-replay") {
+    const replayId = rest[1];
+    if (!replayId) {
+      throw new Error(
+        "usage: sandbox replay-artifacts <replayId> [--team-id <id>]"
+      );
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const result = await client.getReplayArtifacts(replayId, {
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          replayId: result.replayId,
+          artifacts: result.artifacts.map(summarizeReplayArtifact)
+        },
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "replay-cancel" || subcommand === "cancel-replay") {
+    const replayId = rest[1];
+    if (!replayId) {
+      throw new Error(
+        "usage: sandbox replay-cancel <replayId> [--team-id <id>]"
+      );
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const result = await client.cancelReplay(replayId, {
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return true;
+  }
+  if (subcommand === "replay-watch" || subcommand === "watch-replay") {
+    const replayId = rest[1];
+    if (!replayId) {
+      throw new Error(
+        "usage: sandbox replay-watch <replayId> [--team-id <id>]"
+      );
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const intervalMs = parseIntegerOption(options.intervalMs, "interval-ms") ?? 5e3;
+    const timeoutMs = parseIntegerOption(options.timeoutMs, "timeout-ms") ?? 15 * 60 * 1e3;
+    const startedAt = Date.now();
+    const seenLogs = /* @__PURE__ */ new Set();
+    while (Date.now() - startedAt <= timeoutMs) {
+      const result = await client.getReplay(replayId, {
+        ...teamId ? { teamId } : {},
+        ...projectId ? { projectId } : {}
+      });
+      for (const line of result.replay.logs) {
+        if (!seenLogs.has(line)) {
+          seenLogs.add(line);
+          console.log(line);
+        }
+      }
+      if (result.replay.state === "succeeded" || result.replay.state === "failed" || result.replay.state === "canceled") {
+        console.log(formatReplayLine(result.replay));
+        if (result.replay.state !== "succeeded") {
+          throw new Error(
+            `sandbox replay ${result.replay.state}: ${result.replay.error ?? "no error"}`
+          );
+        }
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`sandbox replay did not finish within ${timeoutMs}ms`);
+  }
+  return false;
+}
+
+// src/cli/sandbox-runtime-command.ts
+async function handleSandboxRuntimeCommand(client, subcommand, options, rest) {
+  if (subcommand === "runtime-list") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const agentId = typeof options.agentId === "string" ? options.agentId.trim() : "";
+    const runtimes = await client.listSandboxRuntimes({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {}
+    });
+    console.log(JSON.stringify({ runtimes }, null, 2));
+    return true;
+  }
+  if (subcommand === "runtime-get") {
+    const runtimeId = rest[1]?.trim();
+    if (!runtimeId) {
+      throw new Error("usage: sandbox runtime-get <runtimeId>");
+    }
+    const runtime = await client.getSandboxRuntime(runtimeId);
+    console.log(JSON.stringify({ runtime }, null, 2));
+    return true;
+  }
+  if (subcommand === "runtime-events") {
+    const runtimeId = rest[1]?.trim();
+    if (!runtimeId) {
+      throw new Error("usage: sandbox runtime-events <runtimeId>");
+    }
+    console.log(
+      JSON.stringify(await client.listSandboxRuntimeEvents(runtimeId), null, 2)
+    );
+    return true;
+  }
+  if (subcommand === "runtime-status") {
+    const runtimeId = rest[1]?.trim();
+    const status = typeof options.status === "string" && options.status.trim() ? options.status.trim() : "";
+    const expectedVersion = Number(options.expectedVersion);
+    const summary = typeof options.summary === "string" && options.summary.trim() ? options.summary.trim() : void 0;
+    if (!runtimeId || !status || !Number.isInteger(expectedVersion)) {
+      throw new Error(
+        "usage: sandbox runtime-status <runtimeId> --status <status> --expected-version <n>"
+      );
+    }
+    const runtime = await client.updateSandboxRuntimeStatus(runtimeId, {
+      status,
+      expectedVersion,
+      ...summary ? { summary } : {}
+    });
+    console.log(JSON.stringify({ runtime }, null, 2));
+    return true;
+  }
+  if (subcommand === "runtime-event") {
+    const runtimeId = rest[1]?.trim();
+    const type = typeof options.type === "string" && options.type.trim() ? options.type.trim() : "";
+    const summary = typeof options.summary === "string" && options.summary.trim() ? options.summary.trim() : void 0;
+    const payload = typeof options.payload === "string" && options.payload.trim() ? parseJsonObjectOption(options.payload, "payload") : void 0;
+    const lifecycleHint = typeof options.lifecycleHint === "string" && options.lifecycleHint.trim() ? parseJsonObjectOption(options.lifecycleHint, "lifecycle-hint") : void 0;
+    if (!runtimeId || !type) {
+      throw new Error(
+        "usage: sandbox runtime-event <runtimeId> --type <eventType> [--summary <text>] [--payload <json>] [--lifecycle-hint <json>]"
+      );
+    }
+    console.log(
+      JSON.stringify(
+        await client.emitSandboxRuntimeEvent(runtimeId, {
+          type,
+          ...summary ? { summary } : {},
+          ...payload ? { payload } : {},
+          ...lifecycleHint ? { lifecycleHint } : {}
+        }),
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  if (subcommand === "runtime-preserve-source" || subcommand === "runtime-preserve") {
+    const runtimeId = rest[1]?.trim();
+    const teamId = typeof options.teamId === "string" && options.teamId.trim() ? options.teamId.trim() : "";
+    const sandboxId = typeof options.sandboxId === "string" && options.sandboxId.trim() ? options.sandboxId.trim() : "";
+    const message = typeof options.message === "string" && options.message.trim() ? options.message.trim() : "";
+    if (!runtimeId) {
+      throw new Error(
+        "usage: sandbox runtime-preserve-source <runtimeId> [--team-id <id>] [--sandbox-id <id>] [--message <text>]"
+      );
+    }
+    console.log(
+      JSON.stringify(
+        await client.runtimes.preserveSource(
+          runtimeId,
+          {
+            ...sandboxId ? { sandboxId } : {},
+            ...message ? { message } : {}
+          },
+          {
+            ...teamId ? { teamId } : {}
+          }
+        ),
+        null,
+        2
+      )
+    );
+    return true;
+  }
+  return false;
+}
+
+// src/cli/sandbox-secrets-command.ts
+async function handleSandboxSecretsCommand(client, subcommand, options, rest) {
+  if (subcommand === "secrets" || subcommand === "secret-list") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const secrets = await client.listSecrets({
+      ...teamId ? { teamId } : {}
+    });
+    if (parseBooleanOption(options.json)) {
+      console.log(
+        JSON.stringify(
+          { secrets: secrets.map(summarizeSandboxSecret) },
+          null,
+          2
+        )
+      );
+      return true;
+    }
+    if (secrets.length === 0) {
+      console.log("no sandbox secrets found");
+      return true;
+    }
+    for (const secret of secrets) {
+      console.log(
+        `${secret.name}	${secret.status}	v${secret.currentVersion ?? "current"}	${secret.secretRef}`
+      );
+    }
+    return true;
+  }
+  if (subcommand === "secret-create") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const name = typeof options.name === "string" ? options.name.trim() : "";
+    const description = typeof options.description === "string" && options.description.trim() ? options.description.trim() : void 0;
+    const scope = options.scope === "project" || options.scope === "template" || options.scope === "team" ? options.scope : void 0;
+    if (!name) {
+      throw new Error(
+        "usage: sandbox secret-create --name <ENV_NAME> [--team-id <id>] [--stdin]"
+      );
+    }
+    const value = await readSandboxSecretValue(options, `Value for ${name}`);
+    const secret = await client.createSecret({
+      ...teamId ? { teamId } : {},
+      name,
+      value,
+      ...description ? { description } : {},
+      ...scope ? { scope } : {}
+    });
+    console.log(
+      JSON.stringify({ secret: summarizeSandboxSecret(secret) }, null, 2)
+    );
+    return true;
+  }
+  if (subcommand === "secret-rotate") {
+    const secretId = rest[1];
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    if (!secretId) {
+      throw new Error(
+        "usage: sandbox secret-rotate <secretId> [--team-id <id>] [--stdin]"
+      );
+    }
+    const value = await readSandboxSecretValue(options, "New secret value");
+    const secret = await client.rotateSecret(secretId, {
+      ...teamId ? { teamId } : {},
+      value
+    });
+    console.log(
+      JSON.stringify({ secret: summarizeSandboxSecret(secret) }, null, 2)
+    );
+    return true;
+  }
+  if (subcommand === "secret-attach") {
+    const secretId = rest[1];
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const envName = typeof options.envName === "string" ? options.envName.trim() : "";
+    const targetType = options.targetType === "sandbox" || options.targetType === "template" || options.targetType === "project" || options.targetType === "agent" || options.targetType === "replay" ? options.targetType : void 0;
+    const targetId = typeof options.targetId === "string" ? options.targetId.trim() : "";
+    if (!secretId || !envName || !targetType || !targetId) {
+      throw new Error(
+        "usage: sandbox secret-attach <secretId> --env-name <ENV_NAME> --target-type sandbox|project|agent|template|replay --target-id <id>"
+      );
+    }
+    const secret = await client.attachSecret(secretId, {
+      ...teamId ? { teamId } : {},
+      envName,
+      targetType,
+      targetId
+    });
+    console.log(
+      JSON.stringify({ secret: summarizeSandboxSecret(secret) }, null, 2)
+    );
+    return true;
+  }
+  if (subcommand === "secret-revoke" || subcommand === "secret-delete") {
+    const secretId = rest[1];
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    if (!secretId) {
+      throw new Error(
+        `usage: sandbox ${subcommand} <secretId> [--team-id <id>]`
+      );
+    }
+    const secret = subcommand === "secret-revoke" ? await client.revokeSecret(secretId, {
+      ...teamId ? { teamId } : {}
+    }) : await client.deleteSecret(secretId, {
+      ...teamId ? { teamId } : {}
+    });
+    console.log(
+      JSON.stringify({ secret: summarizeSandboxSecret(secret) }, null, 2)
+    );
+    return true;
+  }
+  return false;
+}
+
+// src/cli/sandbox-template-builds-command.ts
+async function handleSandboxTemplateBuildsCommand(client, subcommand, options, rest) {
+  if (subcommand === "published-snapshot-builds" || subcommand === "published-snapshot-build-list" || subcommand === "template-builds" || subcommand === "template-build-list") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    if (!teamId) {
+      throw new Error(
+        "usage: sandbox published-snapshot-builds --team-id <id>"
+      );
+    }
+    const builds = await client.listPublishedSnapshotBuilds({ teamId });
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify({ builds }, null, 2));
+      return true;
+    }
+    if (builds.length === 0) {
+      console.log("no published snapshot builds found");
+      return true;
+    }
+    for (const build of builds) {
+      console.log(formatTemplateBuildLine(build));
+    }
+    return true;
+  }
+  if (subcommand === "published-snapshot-build-create" || subcommand === "create-published-snapshot-build" || subcommand === "template-build-create" || subcommand === "create-template-build") {
+    const build = await client.createPublishedSnapshotBuild(
+      buildTemplateBuildCreateInput(options)
+    );
+    console.log(JSON.stringify({ build }, null, 2));
+    return true;
+  }
+  if (subcommand === "published-snapshot-build-get" || subcommand === "get-published-snapshot-build" || subcommand === "template-build-get" || subcommand === "get-template-build") {
+    const buildId = rest[1];
+    if (!buildId) {
+      throw new Error("usage: sandbox published-snapshot-build-get <buildId>");
+    }
+    const build = await client.getPublishedSnapshotBuild(buildId);
+    console.log(JSON.stringify({ build }, null, 2));
+    return true;
+  }
+  if (subcommand === "published-snapshot-build-logs" || subcommand === "published-snapshot-build-log" || subcommand === "template-build-logs" || subcommand === "template-build-log") {
+    const buildId = rest[1];
+    if (!buildId) {
+      throw new Error("usage: sandbox published-snapshot-build-logs <buildId>");
+    }
+    const logs = await client.getPublishedSnapshotBuildLogs(buildId);
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify(logs, null, 2));
+      return true;
+    }
+    for (const line of logs.logs) {
+      console.log(line);
+    }
+    return true;
+  }
+  if (subcommand === "published-snapshot-build-cancel" || subcommand === "cancel-published-snapshot-build" || subcommand === "template-build-cancel" || subcommand === "cancel-template-build") {
+    const buildId = rest[1];
+    if (!buildId) {
+      throw new Error(
+        "usage: sandbox published-snapshot-build-cancel <buildId>"
+      );
+    }
+    const build = await client.cancelPublishedSnapshotBuild(buildId);
+    console.log(JSON.stringify({ build }, null, 2));
+    return true;
+  }
+  if (subcommand === "published-snapshot-build-watch" || subcommand === "watch-published-snapshot-build" || subcommand === "template-build-watch" || subcommand === "watch-template-build") {
+    const buildId = rest[1];
+    if (!buildId) {
+      throw new Error("usage: sandbox published-snapshot-build-watch <buildId>");
+    }
+    const intervalMs = parseIntegerOption(options.intervalMs, "interval-ms") ?? 5e3;
+    const timeoutMs = parseIntegerOption(options.timeoutMs, "timeout-ms") ?? 15 * 60 * 1e3;
+    const startedAt = Date.now();
+    const seenLogs = /* @__PURE__ */ new Set();
+    while (Date.now() - startedAt <= timeoutMs) {
+      const [build, logs] = await Promise.all([
+        client.getPublishedSnapshotBuild(buildId),
+        client.getPublishedSnapshotBuildLogs(buildId)
+      ]);
+      for (const line of logs.logs) {
+        if (!seenLogs.has(line)) {
+          seenLogs.add(line);
+          console.log(line);
+        }
+      }
+      if (build.status === "succeeded" || build.status === "failed" || build.status === "cancelled") {
+        console.log(formatTemplateBuildLine(build));
+        if (build.status !== "succeeded") {
+          throw new Error(
+            `published snapshot build ${build.status}: ${build.error ?? "no error"}`
+          );
+        }
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(
+      `published snapshot build did not finish within ${timeoutMs}ms`
+    );
+  }
+  return false;
+}
+
+// src/cli/sandbox-command.ts
+function parseSandboxAsyncOption(options) {
+  return parseBooleanOption(options.async) || parseBooleanOption(options.respondAsync);
+}
+async function runSandboxCommand(options, rest) {
+  const subcommand = rest[0] || "list";
+  const client = await resolveSandboxClient(options);
+  if (subcommand === "list") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const agentId = typeof options.agentId === "string" ? options.agentId.trim() : "";
+    const sandboxes = await client.list({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {}
+    });
+    if (sandboxes.length === 0) {
+      console.log("no sandboxes found");
+      return;
+    }
+    for (const sandbox of sandboxes) {
+      console.log(formatSandboxLine(sandbox));
+    }
+    return;
+  }
+  if (subcommand === "mcp-config" || subcommand === "mcp-url") {
+    const config = client.mcpServerConfig();
+    console.log(
+      JSON.stringify(
+        {
+          ...config,
+          headers: {
+            "openpond-api-key": "set OPENPOND_API_KEY or use your saved openpond profile"
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (await handleSandboxRuntimeCommand(client, subcommand, options, rest)) {
+    return;
+  }
+  if (subcommand === "pricing") {
+    const pricing = await client.pricing();
+    console.log(JSON.stringify(pricing, null, 2));
+    return;
+  }
+  if (subcommand === "costs") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const agentId = typeof options.agentId === "string" ? options.agentId.trim() : "";
+    const costs = await client.costs({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {}
+    });
+    if (parseBooleanOption(options.summary)) {
+      console.log(
+        JSON.stringify(
+          {
+            costs: {
+              teamId: costs.costs.teamId,
+              ownerUserId: costs.costs.ownerUserId,
+              generatedAt: costs.costs.generatedAt,
+              summary: costs.costs.summary,
+              lineItems: costs.costs.lineItems,
+              tiers: costs.costs.pricing.tiers.map((tier) => ({
+                key: tier.key,
+                resources: tier.resources,
+                keepRunningEstimate: tier.keepRunningEstimate
+              }))
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(JSON.stringify(costs, null, 2));
+    return;
+  }
+  if (await handleSandboxSecretsCommand(client, subcommand, options, rest)) {
+    return;
+  }
+  if (subcommand === "snapshots" || subcommand === "snapshot-catalog") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const agentId = typeof options.agentId === "string" ? options.agentId.trim() : "";
+    const query = typeof options.query === "string" && options.query.trim() ? options.query.trim() : typeof options.q === "string" && options.q.trim() ? options.q.trim() : "";
+    const tag = typeof options.tag === "string" ? options.tag.trim() : "";
+    const useCase = typeof options.useCase === "string" ? options.useCase.trim() : "";
+    const replayState = typeof options.replayState === "string" ? options.replayState.trim() : "";
+    const catalog = await client.snapshotCatalog({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {},
+      ...query ? { q: query } : {},
+      ...tag ? { tag } : {},
+      ...useCase ? { useCase } : {},
+      ...replayState === "draft" || replayState === "validated" || replayState === "published" ? { replayState } : {}
+    });
+    if (catalog.snapshots.length === 0) {
+      console.log("no sandbox snapshots found");
+      return;
+    }
+    for (const snapshot of catalog.snapshots) {
+      console.log(formatSnapshotCatalogLine(snapshot));
+    }
+    return;
+  }
+  if (subcommand === "published-snapshots" || subcommand === "published-snapshot-catalog" || subcommand === "templates" || subcommand === "template-catalog") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const query = typeof options.query === "string" && options.query.trim() ? options.query.trim() : typeof options.q === "string" && options.q.trim() ? options.q.trim() : "";
+    const name = typeof options.name === "string" && options.name.trim() ? options.name.trim() : typeof options.templateName === "string" && options.templateName.trim() ? options.templateName.trim() : "";
+    const version = typeof options.version === "string" ? options.version.trim() : "";
+    const tag = typeof options.tag === "string" ? options.tag.trim() : "";
+    const useCase = typeof options.useCase === "string" ? options.useCase.trim() : "";
+    const catalog = await client.publishedSnapshots({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...query ? { q: query } : {},
+      ...name ? { name } : {},
+      ...version ? { version } : {},
+      ...tag ? { tag } : {},
+      ...useCase ? { useCase } : {}
+    });
+    if (catalog.publishedSnapshots.length === 0) {
+      console.log("no published snapshots found");
+      return;
+    }
+    for (const template of catalog.publishedSnapshots) {
+      console.log(formatSandboxTemplateLine(template));
+    }
+    return;
+  }
+  if (await handleSandboxTemplateBuildsCommand(
+    client,
+    subcommand,
+    options,
+    rest
+  ) || await handleSandboxReplayCommand(client, subcommand, options, rest)) {
+    return;
+  }
+  if (subcommand === "run-published-snapshot" || subcommand === "published-snapshot-run" || subcommand === "template-launch" || subcommand === "launch-template") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const snapshotId = typeof options.snapshotId === "string" && options.snapshotId.trim() ? options.snapshotId.trim() : typeof options.snapshot === "string" && options.snapshot.trim() ? options.snapshot.trim() : "";
+    const templateName = typeof options.templateName === "string" && options.templateName.trim() ? options.templateName.trim() : typeof options.name === "string" && options.name.trim() ? options.name.trim() : typeof rest[1] === "string" && rest[1].trim() ? rest[1].trim() : "";
+    const version = typeof options.version === "string" ? options.version.trim() : "";
+    const useCase = typeof options.useCase === "string" ? options.useCase.trim() : "";
+    if (!snapshotId && !templateName && !useCase) {
+      throw new Error(
+        "usage: sandbox run-published-snapshot [--snapshot-id <id>|--name <name>|--use-case <id>] [--version <v>]"
+      );
+    }
+    const budgetUsd = typeof options.budgetUsd === "string" && options.budgetUsd.trim() ? options.budgetUsd.trim() : typeof options.budget === "string" && options.budget.trim() ? options.budget.trim() : "";
+    const result = await client.runPublishedSnapshot({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...snapshotId ? { snapshotId } : {},
+      ...templateName ? { templateName } : {},
+      ...version ? { version } : {},
+      ...useCase ? { useCase } : {},
+      ...budgetUsd ? { budget: { maxUsd: budgetUsd } } : {},
+      metadata: {
+        source: "openpond-code-published-snapshot-run"
+      }
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "snapshot-fork" || subcommand === "fork-snapshot") {
+    const snapshotId = rest[1];
+    if (!snapshotId) {
+      throw new Error("snapshot-fork requires <snapshotId>");
+    }
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const budgetUsd = typeof options.budgetUsd === "string" && options.budgetUsd.trim() ? options.budgetUsd.trim() : typeof options.budget === "string" && options.budget.trim() ? options.budget.trim() : "";
+    const result = await client.forkSnapshot(snapshotId, {
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...budgetUsd ? { budget: { maxUsd: budgetUsd } } : {},
+      metadata: {
+        source: "openpond-code-snapshot-fork",
+        templateSnapshotId: snapshotId
+      }
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "snapshot-create" || subcommand === "create-snapshot") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox snapshot-create <sandboxId> --name <name>"
+      );
+    }
+    const result = await client.createSnapshot(
+      sandboxId,
+      buildSnapshotCreateInput(options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "snapshot-validate" || subcommand === "validate-snapshot") {
+    const sandboxId = rest[1];
+    const snapshotId = rest[2];
+    if (!sandboxId || !snapshotId) {
+      throw new Error("snapshot-validate requires <sandboxId> <snapshotId>");
+    }
+    const cleanup = normalizeSnapshotValidationCleanup(options.cleanup);
+    const result = await client.validateSnapshot(sandboxId, snapshotId, {
+      ...cleanup ? { cleanup } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "snapshot-publish" || subcommand === "publish-snapshot") {
+    const sandboxId = rest[1];
+    const snapshotId = rest[2];
+    if (!sandboxId || !snapshotId) {
+      throw new Error("snapshot-publish requires <sandboxId> <snapshotId>");
+    }
+    const result = await client.publishSnapshot(sandboxId, snapshotId);
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "integration-connections") {
+    const teamId = typeof options.teamId === "string" ? options.teamId.trim() : "";
+    const projectId = typeof options.projectId === "string" ? options.projectId.trim() : "";
+    const agentId = typeof options.agentId === "string" ? options.agentId.trim() : "";
+    const status = options.status === "active" || options.status === "revoked" || options.status === "error" || options.status === "all" ? options.status : void 0;
+    const result = await client.integrationConnections({
+      ...teamId ? { teamId } : {},
+      ...projectId ? { projectId } : {},
+      ...agentId ? { agentId } : {},
+      ...status ? { status } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "create") {
+    const result = await createSandboxFromPlan(
+      client,
+      buildSandboxCreateInput(options)
+    );
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          ...result.runtime ? { runtime: result.runtime } : {}
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "exec") {
+    const sandboxId = rest[1];
+    const command = (typeof options.command === "string" ? options.command : null) || rest.slice(2).join(" ");
+    if (!sandboxId || !command.trim()) {
+      throw new Error("usage: sandbox exec <sandboxId> --command <command>");
+    }
+    const timeoutSeconds = parseIntegerOption(
+      options.timeoutSeconds,
+      "timeout-seconds"
+    );
+    const result = await client.exec(sandboxId, {
+      command: command.trim(),
+      ...timeoutSeconds !== void 0 ? { timeoutSeconds } : {}
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          command: result.command
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "port" || subcommand === "preview") {
+    const sandboxId = rest[1];
+    const port = parseIntegerOption(options.port, "port");
+    if (!sandboxId || port === void 0) {
+      throw new Error("usage: sandbox port <sandboxId> --port <port>");
+    }
+    const label = typeof options.label === "string" ? options.label : void 0;
+    const rawAccess = typeof options.access === "string" ? options.access.trim() : "";
+    if (rawAccess && rawAccess !== "private" && rawAccess !== "public") {
+      throw new Error("sandbox port --access must be private or public");
+    }
+    const access = rawAccess === "public" ? "public" : "private";
+    const customDomain = typeof options.domain === "string" ? options.domain.trim() : "";
+    const authToken = typeof options.authToken === "string" ? options.authToken : "";
+    const authHeader = typeof options.authHeader === "string" ? options.authHeader.trim() : "";
+    const authHeaderValue = typeof options.authHeaderValue === "string" ? options.authHeaderValue : "";
+    if (authToken && (authHeader || authHeaderValue)) {
+      throw new Error(
+        "sandbox port auth options must use either --auth-token or --auth-header with --auth-header-value"
+      );
+    }
+    if (authHeader && !authHeaderValue || !authHeader && authHeaderValue) {
+      throw new Error(
+        "sandbox port custom header auth requires both --auth-header and --auth-header-value"
+      );
+    }
+    const result = await client.openPort(sandboxId, {
+      port,
+      ...label ? { label } : {},
+      access,
+      ...options["auto-start"] || options.autoStart ? { autoStart: true } : {},
+      ...customDomain ? { customDomain } : {},
+      ...authToken ? { authPolicy: { mode: "bearer", token: authToken } } : {},
+      ...authHeader && authHeaderValue ? {
+        authPolicy: {
+          mode: "header",
+          headerName: authHeader,
+          headerValue: authHeaderValue
+        }
+      } : {}
+    });
+    console.log(JSON.stringify(result.preview, null, 2));
+    return;
+  }
+  if (subcommand === "stop") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox stop <sandboxId> [--fail-on-unpreserved-changes] [--async]"
+      );
+    }
+    const result = await client.stop(sandboxId, {
+      failOnUnpreservedChanges: parseBooleanOption(
+        options.failOnUnpreservedChanges
+      ),
+      async: parseSandboxAsyncOption(options)
+    });
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          receipt: result.receipt
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "start") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox start <sandboxId>");
+    }
+    const result = await client.start(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: await waitForSandboxCreateReady(client, result.sandbox),
+          receipt: result.receipt
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "delete") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox delete <sandboxId> [--fail-on-unpreserved-changes] [--async]"
+      );
+    }
+    const sandbox = await client.delete(sandboxId, {
+      failOnUnpreservedChanges: parseBooleanOption(
+        options.failOnUnpreservedChanges
+      ),
+      async: parseSandboxAsyncOption(options)
+    });
+    console.log(
+      JSON.stringify({ sandbox: summarizeSandbox(sandbox) }, null, 2)
+    );
+    return;
+  }
+  if (subcommand === "receipts") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox receipts <sandboxId>");
+    }
+    const receipts = await client.receipts(sandboxId);
+    console.log(JSON.stringify({ receipts }, null, 2));
+    return;
+  }
+  if (subcommand === "logs") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox logs <sandboxId>");
+    }
+    const logs = await client.logs(sandboxId);
+    for (const line of logs) {
+      console.log(line);
+    }
+    return;
+  }
+  if (await handleSandboxProcessCommand(client, subcommand, options, rest) || await handleSandboxFilesCommand(client, subcommand, options, rest) || await handleSandboxGitCommand(client, subcommand, options, rest)) {
+    return;
+  }
+  if (subcommand === "billing") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox billing <sandboxId>");
+    }
+    const result = await client.billing(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          billing: result.billing
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "integration-leases") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error("usage: sandbox integration-leases <sandboxId>");
+    }
+    const result = await client.integrationLeases(sandboxId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          integrationLeases: result.integrationLeases
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "integration-attach") {
+    const sandboxId = rest[1];
+    if (!sandboxId) {
+      throw new Error(
+        "usage: sandbox integration-attach <sandboxId> --integration-connection <id> --integration-capabilities <csv>"
+      );
+    }
+    const result = await client.attachIntegrationConnection(
+      sandboxId,
+      buildSandboxIntegrationAttachInput(options)
+    );
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          integrationLeases: result.integrationLeases
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "integration-remove") {
+    const sandboxId = rest[1];
+    const leaseId = typeof options.leaseId === "string" ? options.leaseId.trim() : "";
+    if (!sandboxId || !leaseId) {
+      throw new Error(
+        "usage: sandbox integration-remove <sandboxId> --lease-id <id>"
+      );
+    }
+    const result = await client.removeIntegrationLease(sandboxId, leaseId);
+    console.log(
+      JSON.stringify(
+        {
+          sandbox: summarizeSandbox(result.sandbox),
+          integrationLeases: result.integrationLeases
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "smoke") {
+    const repo = typeof options.repo === "string" ? options.repo.trim() : void 0;
+    const budgetUsd = typeof options.budgetUsd === "string" ? options.budgetUsd.trim() : typeof options.budget === "string" ? options.budget.trim() : void 0;
+    const keep = parseBooleanOption(options.keep);
+    const preview = options.preview !== void 0 ? parseBooleanOption(options.preview) : !parseBooleanOption(options.noPreview);
+    const snapshot = parseBooleanOption(options.snapshot);
+    const fork = parseBooleanOption(options.fork);
+    const smokeOptions = {
+      ...repo ? { repo } : {},
+      ...budgetUsd ? { budgetUsd } : {},
+      keep,
+      preview,
+      snapshot,
+      fork
+    };
+    if (typeof options.expectedMppMode === "string" && options.expectedMppMode.trim()) {
+      smokeOptions.expectedMppMode = options.expectedMppMode.trim();
+    }
+    const cpu = parseNumberOption(options.cpu, "cpu");
+    const memoryGb = parseNumberOption(options.memoryGb, "memory-gb");
+    const diskGb = parseNumberOption(options.diskGb, "disk-gb");
+    if (cpu !== void 0) smokeOptions.cpu = cpu;
+    if (memoryGb !== void 0) smokeOptions.memoryGb = memoryGb;
+    if (diskGb !== void 0) smokeOptions.diskGb = diskGb;
+    const summary = await client.smoke(smokeOptions);
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  throw new Error(
+    "usage: sandbox <list|mcp-config|runtime-list|runtime-get|runtime-events|runtime-status|runtime-event|runtime-preserve-source|pricing|costs|secrets|secret-create|secret-rotate|secret-attach|secret-revoke|secret-delete|snapshots|published-snapshots|run-published-snapshot|snapshot-fork|snapshot-validate|snapshot-publish|create|exec|port|preview|stop|start|delete|receipts|logs|billing|process-start|process-list|process-get|process-stop|process-stream|pty-start|pty-list|pty-get|pty-write|pty-stop|pty-stream|upload-file|download-file|list-files|search-files|delete-file|stat-file|mkdir|move-file|git-status|git-diff|git-export-patch|git-branch|git-commit|git-pull|git-push|smoke> [args]"
+  );
+}
+export {
+  runSandboxCommand
+};