@madarco/agentbox 0.7.0 → 0.9.0

package/dist/{chunk-NW5NYTQM.js → chunk-BXQMIEHC.js}

@@ -1,50 +1,64 @@
 #!/usr/bin/env node
 import {
   CLAUDE_FORWARDED_ENV_KEYS,
+  CODEX_CREDENTIALS_BACKUP_FILE,
   CODEX_FORWARDED_ENV_KEYS,
+  CREDENTIALS_BACKUP_FILE,
+  OPENCODE_CREDENTIALS_BACKUP_FILE,
   OPENCODE_FORWARDED_ENV_KEYS,
-  allocateProjectIndex,
   buildHostEnvFindArgs,
-  detectGitRepos,
+  buildTmuxConfigShellSnippet,
   ensureRelay,
   forgetBoxFromRelay,
   generateRelayToken,
   generateVncPassword,
   hashProjectPath,
+  isRealAgentCredential,
   portlessAlias,
   portlessGetUrl,
   portlessUnalias,
   projectDirSegment,
-  readState,
-  recordBox,
   registerBoxWithRelay,
-  removeBoxRecord,
   sanitizeMnemonic,
   stageClaudeCredentialsForUpload,
   stageClaudeStaticForUpload,
   stageCodexCredentialsForUpload,
   stageCodexStaticForUpload,
   stageOpencodeCredentialsForUpload,
+  stageOpencodeStateForUpload,
   stageOpencodeStaticForUpload
-} from "./chunk-NAVL4R34.js";
+} from "./chunk-NCJP5MTN.js";
+import {
+  allocateProjectIndex,
+  detectGitRepos,
+  readState,
+  recordBox,
+  removeBoxRecord
+} from "./chunk-KL36BRN4.js";
 
 // ../../packages/sandbox-cloud/dist/index.js
 import { randomBytes } from "crypto";
 import { basename as basename2 } from "path";
-import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { chmod, mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { mkdir as mkdir2, readFile, readdir, rm, writeFile as writeFile2 } from "fs/promises";
 import { homedir } from "os";
 import { basename, join } from "path";
-import { mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
 import { execa } from "execa";
-import { readFile as readFile2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
-import { parse as parseYaml } from "yaml";
 import { execa as execa2 } from "execa";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { parse as parseYaml } from "yaml";
+import { execa as execa3 } from "execa";
 import { existsSync, mkdirSync, renameSync, statSync } from "fs";
-import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
+import { mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
 import {
   basename as hostBasename,
   dirname as hostDirname,
@@ -52,10 +66,10 @@ import {
   resolve as hostResolve
 } from "path";
 import { posix } from "path";
-import { execa as execa3 } from "execa";
-import { mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join4 } from "path";
+import { execa as execa4 } from "execa";
+import { mkdtemp as mkdtemp4, rm as rm5, stat } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join5 } from "path";
 var CREDENTIALS_VOLUME = "agentbox-credentials";
 var AGENT_SPECS = [
   {
@@ -185,6 +199,33 @@ async function seedCredentialsOne(backend, handle, spec, opts) {
     await staged.cleanup();
   }
 }
+var OPENCODE_STATE_DIR = "/home/vscode/.local/state/opencode";
+async function seedOpencodeModelState(backend, handle, opts = {}) {
+  const log = opts.onLog ?? (() => {
+  });
+  const staged = await stageOpencodeStateForUpload();
+  if (staged.tarballPath === null) {
+    log("opencode: no host model selection to seed");
+    return;
+  }
+  try {
+    const remoteTar = "/tmp/agentbox-opencode-state.tar.gz";
+    await backend.uploadFile(handle, staged.tarballPath, remoteTar);
+    const res = await backend.exec(
+      handle,
+      `set -e; mkdir -p ${OPENCODE_STATE_DIR}; tar -xzf ${remoteTar} -C ${OPENCODE_STATE_DIR}; chown -R vscode:vscode ${OPENCODE_STATE_DIR} 2>/dev/null || true; rm -f ${remoteTar}`
+    );
+    if (res.exitCode !== 0) {
+      log(
+        `opencode: model-state seed failed (exit ${String(res.exitCode)}); box falls back to OpenCode's default model. stderr: ${res.stderr.slice(-200)}`
+      );
+      return;
+    }
+    log("opencode: model selection seeded \u2713");
+  } finally {
+    await staged.cleanup();
+  }
+}
 function agentSpecsForCloud() {
   return AGENT_SPECS.map((s) => ({
     kind: s.kind,
@@ -193,6 +234,39 @@ function agentSpecsForCloud() {
     credentialsSubpath: s.credentialsSubpath
   }));
 }
+var EXTRACT_SPECS = [
+  { kind: "claude", boxPath: "/home/vscode/.claude/.credentials.json", hostBackup: CREDENTIALS_BACKUP_FILE },
+  { kind: "codex", boxPath: "/home/vscode/.codex/auth.json", hostBackup: CODEX_CREDENTIALS_BACKUP_FILE },
+  {
+    kind: "opencode",
+    boxPath: "/home/vscode/.local/share/opencode/auth.json",
+    hostBackup: OPENCODE_CREDENTIALS_BACKUP_FILE
+  }
+];
+async function extractCloudAgentCredentials(backend, handle, opts = {}) {
+  const log = opts.onLog ?? (() => {
+  });
+  const extracted = [];
+  for (const spec of EXTRACT_SPECS) {
+    const hostBackup = opts.backups?.[spec.kind] ?? spec.hostBackup;
+    try {
+      const r = await backend.exec(handle, `cat ${spec.boxPath} 2>/dev/null`, { noRetry: true });
+      const text = r.stdout;
+      if (r.exitCode !== 0 || !text || !isRealAgentCredential(spec.kind, text)) continue;
+      await mkdir(dirname(hostBackup), { recursive: true });
+      await writeFile(hostBackup, text, { mode: 384 });
+      await chmod(hostBackup, 384).catch(() => {
+      });
+      extracted.push(spec.kind);
+      log(`extracted ${spec.kind} login from box to ${hostBackup}`);
+    } catch (err) {
+      log(
+        `WARN: ${spec.kind} credential extract failed (${err instanceof Error ? err.message : String(err)}) \u2014 skipping`
+      );
+    }
+  }
+  return extracted;
+}
 var CLOUD_CHECKPOINTS_ROOT = join(homedir(), ".agentbox", "cloud-checkpoints");
 var CLOUD_SNAPSHOT_NAME_PREFIX = "agentbox-ckpt-";
 function cloudSnapshotName(projectRoot, name) {
@@ -240,7 +314,7 @@ async function resolveCloudCheckpoint(projectRoot, backend, ref) {
 }
 async function writeCloudCheckpointManifest(projectRoot, backend, name, fields) {
   const dir = checkpointDir(backend, projectRoot, name);
-  await mkdir(dir, { recursive: true });
+  await mkdir2(dir, { recursive: true });
   const manifest = {
     schema: 1,
     name,
@@ -250,7 +324,7 @@ async function writeCloudCheckpointManifest(projectRoot, backend, name, fields)
     sourceBoxName: fields.sourceBoxName,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  await writeFile2(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
   return { name, dir, manifest };
 }
 async function removeCloudCheckpointDir(projectRoot, backend, name) {
@@ -289,7 +363,7 @@ async function uploadEnvFiles(args) {
       log(`env-file tar pack failed: ${String(packed.stderr).slice(0, 300)}`);
       return { copied: 0 };
     }
-    await writeFile2(join2(stage, ".marker"), "").catch(() => {
+    await writeFile3(join2(stage, ".marker"), "").catch(() => {
     });
     await args.backend.uploadFile(args.handle, localTar, REMOTE_TAR_PATH);
     const extract = await args.backend.exec(
@@ -307,10 +381,106 @@ async function uploadEnvFiles(args) {
   }
   return { copied: list.length };
 }
+var BOX_HOME = "/home/vscode";
+async function uploadCarryPaths(args) {
+  const log = args.onLog ?? (() => {
+  });
+  if (args.entries.length === 0) {
+    return { copied: 0, errors: [], applied: [] };
+  }
+  const stage = await mkdtemp2(join3(tmpdir2(), "agentbox-carry-"));
+  const errors = [];
+  const applied = [];
+  let copied = 0;
+  try {
+    for (const [i, entry] of args.entries.entries()) {
+      const where = `carry[${String(i)}] "${entry.rawSrc}"`;
+      if (entry.kind === "missing") {
+        log(`${where}: skipped (missing on host, optional)`);
+        continue;
+      }
+      try {
+        await uploadOneEntry({
+          backend: args.backend,
+          handle: args.handle,
+          entry,
+          stageDir: stage,
+          index: i
+        });
+        copied += 1;
+        applied.push({ src: entry.absSrc, dest: entry.absDest, bytes: entry.bytes ?? 0 });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`${where}: ${msg}`);
+        log(`${where}: failed: ${msg}`);
+      }
+    }
+  } finally {
+    await rm3(stage, { recursive: true, force: true });
+  }
+  return { copied, errors, applied };
+}
+async function uploadOneEntry(args) {
+  const { entry } = args;
+  if (entry.kind === "missing") return;
+  const boxDest = entry.absDest.startsWith("~/") ? `${BOX_HOME}/${entry.absDest.slice(2)}` : entry.absDest;
+  const isDir = entry.kind === "dir";
+  const parentDir = isDir ? boxDest : dirnameUnix(boxDest);
+  const localTar = join3(args.stageDir, `carry-${String(args.index)}.tar`);
+  const tarArgs = isDir ? ["-C", entry.absSrc, "-cf", localTar, "."] : ["-C", dirnameUnix(entry.absSrc), "-cf", localTar, basenameUnix(entry.absSrc)];
+  const packed = await execa2("tar", tarArgs, { reject: false });
+  if (packed.exitCode !== 0) {
+    throw new Error(`tar pack failed: ${String(packed.stderr).slice(0, 300)}`);
+  }
+  const remoteTar = `/tmp/agentbox-carry-${String(args.index)}.tar`;
+  await args.backend.uploadFile(args.handle, localTar, remoteTar);
+  const mode = entry.mode !== void 0 ? entry.mode.toString(8).padStart(4, "0") : "";
+  const uid = entry.user ?? 1e3;
+  const fileBase = !isDir ? basenameUnix(entry.absSrc) : "";
+  const destBase = !isDir ? basenameUnix(boxDest) : "";
+  const renameNeeded = !isDir && fileBase !== destBase;
+  const parts = [
+    `mkdir -p ${shellQuote(parentDir)}`,
+    isDir ? `tar -xf ${remoteTar} -C ${shellQuote(boxDest)} --no-same-permissions --no-same-owner -m` : `tar -xf ${remoteTar} -C ${shellQuote(parentDir)} --no-same-permissions --no-same-owner -m`
+  ];
+  if (renameNeeded) {
+    parts.push(
+      `mv ${shellQuote(`${parentDir}/${fileBase}`)} ${shellQuote(boxDest)}`
+    );
+  }
+  if (mode) parts.push(`chmod -R ${mode} ${shellQuote(boxDest)}`);
+  parts.push(`chown -R ${String(uid)}:${String(uid)} ${shellQuote(boxDest)}`);
+  if (boxDest.startsWith(BOX_HOME + "/") && parentDir !== BOX_HOME) {
+    parts.push(
+      `parent=$(dirname ${shellQuote(boxDest)}); while [ "$parent" != "${BOX_HOME}" ] && [ "$parent" != "/" ]; do chown ${String(uid)}:${String(uid)} "$parent"; parent=$(dirname "$parent"); done`
+    );
+  }
+  parts.push(`rm -f ${remoteTar}`);
+  const cmd = parts.join(" && ");
+  const execOpts = args.backend.name === "vercel" ? { user: "root" } : void 0;
+  const res = await args.backend.exec(args.handle, cmd, execOpts);
+  if (res.exitCode !== 0) {
+    throw new Error(
+      `in-box extract failed (exit ${String(res.exitCode)}): ${(res.stderr || res.stdout).slice(-300)}`
+    );
+  }
+}
+function dirnameUnix(p) {
+  const i = p.lastIndexOf("/");
+  if (i <= 0) return "/";
+  return p.slice(0, i);
+}
+function basenameUnix(p) {
+  const i = p.lastIndexOf("/");
+  return i < 0 ? p : p.slice(i + 1);
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
 async function readExposedServicePorts(workspacePath) {
   let text;
   try {
-    text = await readFile2(join3(workspacePath, "agentbox.yaml"), "utf8");
+    text = await readFile2(join4(workspacePath, "agentbox.yaml"), "utf8");
   } catch {
     return [];
   }
@@ -366,10 +536,10 @@ async function uploadToCloudBox(backend, handle, hostSrc, boxDst) {
     finalName = posix.basename(boxDst);
   }
   const finalPath = boxParent === "/" ? `/${finalName}` : `${boxParent}/${finalName}`;
-  const stage = await mkdtemp2(hostJoin(tmpdir2(), "agentbox-cp-up-"));
+  const stage = await mkdtemp3(hostJoin(tmpdir3(), "agentbox-cp-up-"));
   const localTar = hostJoin(stage, "payload.tar.gz");
   try {
-    await execa2("tar", ["-C", srcParent, "-czf", localTar, srcBasename], {
+    await execa3("tar", ["-C", srcParent, "-czf", localTar, srcBasename], {
       env: { ...process.env, COPYFILE_DISABLE: "1" }
     });
     await backend.uploadFile(handle, localTar, REMOTE_UP_TAR);
@@ -395,14 +565,14 @@ async function uploadToCloudBox(backend, handle, hostSrc, boxDst) {
       throw new Error(`cloud upload extract failed: ${r.stderr || r.stdout}`);
     }
   } finally {
-    await rm3(stage, { recursive: true, force: true });
+    await rm4(stage, { recursive: true, force: true });
   }
   return { finalPath };
 }
 async function pullCloudDirContents(backend, handle, boxSrcDir, hostDstDir) {
   const dstAbs = hostResolve(hostDstDir);
   mkdirSync(dstAbs, { recursive: true });
-  const stage = await mkdtemp2(hostJoin(tmpdir2(), "agentbox-pull-"));
+  const stage = await mkdtemp3(hostJoin(tmpdir3(), "agentbox-pull-"));
   const localTar = hostJoin(stage, "payload.tar.gz");
   try {
     const packScript = [
@@ -415,11 +585,11 @@ async function pullCloudDirContents(backend, handle, boxSrcDir, hostDstDir) {
       throw new Error(`cloud workspace pack failed: ${r.stderr || r.stdout}`);
     }
     await backend.downloadFile(handle, REMOTE_DOWN_TAR, localTar);
-    await execa2("tar", ["-xzf", localTar, "-C", dstAbs]);
+    await execa3("tar", ["-xzf", localTar, "-C", dstAbs]);
     await backend.exec(handle, `rm -f ${quoteShellArg(REMOTE_DOWN_TAR)}`).catch(() => {
     });
   } finally {
-    await rm3(stage, { recursive: true, force: true });
+    await rm4(stage, { recursive: true, force: true });
   }
   return { finalPath: dstAbs };
 }
@@ -439,7 +609,7 @@ async function downloadFromCloudBox(backend, handle, boxSrc, hostDst) {
   }
   mkdirSync(hostParent, { recursive: true });
   const finalPath = hostJoin(hostParent, finalName);
-  const stage = await mkdtemp2(hostJoin(tmpdir2(), "agentbox-cp-down-"));
+  const stage = await mkdtemp3(hostJoin(tmpdir3(), "agentbox-cp-down-"));
   const localTar = hostJoin(stage, "payload.tar.gz");
   try {
     const packScript = [
@@ -452,14 +622,14 @@ async function downloadFromCloudBox(backend, handle, boxSrc, hostDst) {
       throw new Error(`cloud download pack failed: ${r.stderr || r.stdout}`);
     }
     await backend.downloadFile(handle, REMOTE_DOWN_TAR, localTar);
-    await execa2("tar", ["-xzf", localTar, "-C", hostParent]);
+    await execa3("tar", ["-xzf", localTar, "-C", hostParent]);
     if (finalName !== srcBasename) {
       renameSync(hostJoin(hostParent, srcBasename), finalPath);
     }
     await backend.exec(handle, `rm -f ${quoteShellArg(REMOTE_DOWN_TAR)}`).catch(() => {
     });
   } finally {
-    await rm3(stage, { recursive: true, force: true });
+    await rm4(stage, { recursive: true, force: true });
   }
   return { finalPath };
 }
@@ -547,24 +717,30 @@ async function seedCloudWorkspace(args) {
   const nested = repos.filter((r) => r.kind === "nested");
   if (root) {
     log(
-      nested.length > 0 ? `seeding /workspace from git bundle (+${String(nested.length)} nested repo${nested.length === 1 ? "" : "s"})` : "seeding /workspace from git bundle"
+      nested.length > 0 ? `seeding /workspace from shallow git clone (+${String(nested.length)} nested repo${nested.length === 1 ? "" : "s"})` : "seeding /workspace from shallow git clone"
     );
-    await seedFromGitBundle({
+    await seedFromGitClone({
       backend: args.backend,
       handle: args.handle,
       hostRepo: root.hostMainRepo,
       branch: args.branch,
-      workspaceDir
+      workspaceDir,
+      bundleDepth: args.bundleDepth,
+      fromBranch: args.fromBranch,
+      useBranch: args.useBranch,
+      onLog: log
     });
     for (const r of nested) {
       const sub = `${workspaceDir}/${r.relPathFromWorkspace}`;
-      log(`seeding nested repo ${r.relPathFromWorkspace} from git bundle`);
-      await seedFromGitBundle({
+      log(`seeding nested repo ${r.relPathFromWorkspace} from shallow git clone`);
+      await seedFromGitClone({
         backend: args.backend,
         handle: args.handle,
         hostRepo: r.hostMainRepo,
         branch: args.branch,
-        workspaceDir: sub
+        workspaceDir: sub,
+        bundleDepth: args.bundleDepth,
+        onLog: log
       });
     }
     return { fromGit: true, branch: args.branch };
@@ -580,41 +756,53 @@ async function seedCloudWorkspace(args) {
 }
 var STASH_CARRYOVER_REF = "refs/agentbox-carryover/stash";
 var REMOTE_UNTRACKED_TAR = "/tmp/agentbox-carryover-untracked.tar.gz";
-async function seedFromGitBundle(args) {
-  const stage = await mkdtemp3(join4(tmpdir3(), "agentbox-bundle-"));
-  const bundlePath = join4(stage, "workspace.bundle");
-  const untrackedTarPath = join4(stage, "untracked.tar.gz");
-  const stashSha = await safeStashCreate(args.hostRepo);
-  const untrackedSize = await maybeBuildUntrackedTar(args.hostRepo, untrackedTarPath);
+var DEFAULT_BUNDLE_DEPTH = 200;
+var LARGE_BUNDLE_DEPTH = 100;
+var LARGE_BUNDLE_THRESHOLD_BYTES = 20 * 1024 * 1024;
+async function seedFromGitClone(args) {
+  const log = args.onLog ?? (() => {
+  });
+  const stage = await mkdtemp4(join5(tmpdir4(), "agentbox-clone-"));
+  const cloneDir = join5(stage, "clone");
+  const tarPath = join5(stage, "workspace.tar.gz");
+  const untrackedTarPath = join5(stage, "untracked.tar.gz");
+  const stashSha = args.useBranch ? null : await safeStashCreate(args.hostRepo);
+  const untrackedSize = args.useBranch ? 0 : await maybeBuildUntrackedTar(args.hostRepo, untrackedTarPath);
   let stashRefCreated = false;
   try {
     if (stashSha) {
-      const ref = await execa3(
+      const ref = await execa4(
         "git",
         ["-C", args.hostRepo, "update-ref", STASH_CARRYOVER_REF, stashSha],
         { reject: false }
       );
       stashRefCreated = ref.exitCode === 0;
     }
-    const depthRaw = process.env["AGENTBOX_BUNDLE_DEPTH"];
-    const depth = depthRaw ? Number.parseInt(depthRaw, 10) : NaN;
-    const bundleArgs = ["-C", args.hostRepo, "bundle", "create", bundlePath];
-    if (Number.isFinite(depth) && depth > 0) {
-      bundleArgs.push(`--depth=${String(depth)}`, "HEAD");
-    } else {
-      bundleArgs.push("--all");
-    }
-    if (stashRefCreated) bundleArgs.push(STASH_CARRYOVER_REF);
-    await execa3("git", bundleArgs);
-    if (stashRefCreated) {
-      await execa3("git", ["-C", args.hostRepo, "update-ref", "-d", STASH_CARRYOVER_REF], {
-        reject: false
-      });
-      stashRefCreated = false;
+    const configured = args.bundleDepth;
+    const adaptive = configured === void 0;
+    const initialDepth = adaptive ? DEFAULT_BUNDLE_DEPTH : configured === 0 ? null : configured;
+    log(
+      adaptive ? `clone: depth=${String(DEFAULT_BUNDLE_DEPTH)} (default, adaptive)` : initialDepth === null ? "clone: depth=full (configured)" : `clone: depth=${String(initialDepth)} (configured)`
+    );
+    const cloneBranch = args.useBranch ?? args.fromBranch;
+    await runShallowClone(args.hostRepo, cloneDir, initialDepth, stashRefCreated, cloneBranch);
+    await tarCloneDir(cloneDir, tarPath);
+    if (adaptive && initialDepth !== null) {
+      const size = await safeFileSize(tarPath);
+      if (size > LARGE_BUNDLE_THRESHOLD_BYTES) {
+        const mb = (size / (1024 * 1024)).toFixed(1);
+        log(
+          `clone tar exceeded ${String(LARGE_BUNDLE_THRESHOLD_BYTES / (1024 * 1024))} MB at depth ${String(DEFAULT_BUNDLE_DEPTH)} (${mb} MB), rebuilding at depth ${String(LARGE_BUNDLE_DEPTH)}`
+        );
+        await rm5(cloneDir, { recursive: true, force: true });
+        await rm5(tarPath, { force: true });
+        await runShallowClone(args.hostRepo, cloneDir, LARGE_BUNDLE_DEPTH, stashRefCreated, cloneBranch);
+        await tarCloneDir(cloneDir, tarPath);
+      }
     }
     const remoteUrl = await readOriginUrl(args.hostRepo);
-    const remoteBundle = "/tmp/agentbox-workspace.bundle";
-    await args.backend.uploadFile(args.handle, bundlePath, remoteBundle);
+    const remoteTar = "/tmp/agentbox-workspace.tar.gz";
+    await args.backend.uploadFile(args.handle, tarPath, remoteTar);
     if (untrackedSize > 0) {
       await args.backend.uploadFile(args.handle, untrackedTarPath, REMOTE_UNTRACKED_TAR);
     }
@@ -633,50 +821,80 @@ async function seedFromGitBundle(args) {
       // Move out of any cwd we might inherit from Daytona's executeCommand
       // before we delete /workspace. The agentbox image bakes WORKDIR
       // /workspace; if the shell's cwd is /workspace when we `rm -rf` it,
-      // the next process inherits a stale cwd FD and git-clone's child
-      // (index-pack) fails with "Unable to read current working directory".
+      // the next process inherits a stale cwd FD and tar's children fail
+      // with "Unable to read current working directory".
       `cd /tmp`,
       SUDO,
-      // rm -rf only the directory we're about to clone into — for nested
+      // rm -rf only the directory we're about to extract into — for nested
       // repos this is just `/workspace/<rel>`, so the root clone (already
       // at `/workspace`) is preserved.
       `$SUDO rm -rf ${quoteShellArgv([args.workspaceDir])}`,
       `$SUDO mkdir -p ${quoteShellArgv([args.workspaceDir])}`,
       `$SUDO chown "$(id -un):$(id -gn)" ${quoteShellArgv([args.workspaceDir])}`,
-      `git clone ${quoteShellArgv([remoteBundle, args.workspaceDir])}`,
+      `tar -C ${quoteShellArgv([args.workspaceDir])} -xzf ${quoteShellArgv([remoteTar])}`,
       setOrigin,
-      `git -C ${quoteShellArgv([args.workspaceDir])} fetch ${quoteShellArgv([remoteBundle])} --tags '+refs/heads/*:refs/remotes/bundle/*' || true`,
-      `git -C ${quoteShellArgv([args.workspaceDir])} checkout -B ${quoteShellArgv([args.branch])}`,
+      // reuse: the clone already landed on `<branch>` (pinned via `--branch`);
+      // a plain checkout materializes the working tree without resetting the
+      // ref. fork: `-B` (re)points `<branch>` at the clone HEAD.
+      args.useBranch ? `git -C ${quoteShellArgv([args.workspaceDir])} checkout ${quoteShellArgv([args.branch])}` : `git -C ${quoteShellArgv([args.workspaceDir])} checkout -B ${quoteShellArgv([args.branch])}`,
       ...carryOverSteps,
-      `rm -f ${quoteShellArgv([remoteBundle])}`
+      `rm -f ${quoteShellArgv([remoteTar])}`
     ].join("\n");
     const r = await args.backend.exec(args.handle, bashScript(script));
     if (r.exitCode !== 0) {
-      throw new Error(`workspace seed (bundle) failed: ${r.stderr || r.stdout}`);
+      throw new Error(`workspace seed (clone) failed: ${r.stderr || r.stdout}`);
     }
   } finally {
     if (stashRefCreated) {
-      await execa3("git", ["-C", args.hostRepo, "update-ref", "-d", STASH_CARRYOVER_REF], {
+      await execa4("git", ["-C", args.hostRepo, "update-ref", "-d", STASH_CARRYOVER_REF], {
         reject: false
       });
     }
-    await rm4(stage, { recursive: true, force: true });
+    await rm5(stage, { recursive: true, force: true });
+  }
+}
+async function runShallowClone(hostRepo, cloneDir, depth, includeStashRef, fromBranch) {
+  const cloneArgs = ["clone", "--no-checkout", "--quiet"];
+  if (depth !== null) cloneArgs.push(`--depth=${String(depth)}`);
+  if (fromBranch) cloneArgs.push("--branch", fromBranch);
+  cloneArgs.push(`file://${hostRepo}`, cloneDir);
+  await execa4("git", cloneArgs);
+  if (includeStashRef) {
+    const fetchArgs = ["-C", cloneDir, "fetch", "--quiet"];
+    if (depth !== null) fetchArgs.push(`--depth=${String(depth)}`);
+    fetchArgs.push(
+      `file://${hostRepo}`,
+      `+${STASH_CARRYOVER_REF}:refs/remotes/origin/agentbox-carryover/stash`
+    );
+    await execa4("git", fetchArgs, { reject: false });
+  }
+}
+async function tarCloneDir(cloneDir, outPath) {
+  await execa4("tar", ["-C", cloneDir, "-czf", outPath, "."], {
+    env: { ...process.env, COPYFILE_DISABLE: "1" }
+  });
+}
+async function safeFileSize(path) {
+  try {
+    return (await stat(path)).size;
+  } catch {
+    return 0;
   }
 }
 async function safeStashCreate(hostRepo) {
-  const r = await execa3("git", ["-C", hostRepo, "stash", "create"], { reject: false });
+  const r = await execa4("git", ["-C", hostRepo, "stash", "create"], { reject: false });
   if (r.exitCode !== 0) return null;
   const sha = r.stdout.trim();
   return sha.length > 0 ? sha : null;
 }
 async function maybeBuildUntrackedTar(hostRepo, outPath) {
-  const list = await execa3(
+  const list = await execa4(
     "git",
     ["-C", hostRepo, "ls-files", "--others", "--exclude-standard", "-z"],
     { reject: false }
   );
   if (list.exitCode !== 0 || list.stdout.length === 0) return 0;
-  const tar = await execa3(
+  const tar = await execa4(
     "tar",
     ["-C", hostRepo, "--null", "-T", "-", "-czf", outPath],
     {
@@ -687,24 +905,24 @@ async function maybeBuildUntrackedTar(hostRepo, outPath) {
   );
   if (tar.exitCode !== 0) return 0;
   try {
-    const { stat } = await import("fs/promises");
-    const s = await stat(outPath);
+    const { stat: stat2 } = await import("fs/promises");
+    const s = await stat2(outPath);
     return s.size;
   } catch {
     return 0;
   }
 }
 async function readOriginUrl(hostRepo) {
-  const r = await execa3("git", ["-C", hostRepo, "remote", "get-url", "origin"], { reject: false });
+  const r = await execa4("git", ["-C", hostRepo, "remote", "get-url", "origin"], { reject: false });
   if (r.exitCode !== 0) return null;
   const out = (r.stdout ?? "").trim();
   return out.length > 0 ? out : null;
 }
 async function seedFromTar(args) {
-  const stage = await mkdtemp3(join4(tmpdir3(), "agentbox-tar-"));
-  const tarPath = join4(stage, "workspace.tar.gz");
+  const stage = await mkdtemp4(join5(tmpdir4(), "agentbox-tar-"));
+  const tarPath = join5(stage, "workspace.tar.gz");
   try {
-    await execa3("tar", ["-C", args.hostDir, "-czf", tarPath, "."]);
+    await execa4("tar", ["-C", args.hostDir, "-czf", tarPath, "."]);
     const remoteTar = "/tmp/agentbox-workspace.tar.gz";
     await args.backend.uploadFile(args.handle, tarPath, remoteTar);
     const SUDO = `if command -v sudo >/dev/null 2>&1; then SUDO='sudo -n'; else SUDO=''; fi`;
@@ -728,7 +946,7 @@ async function seedFromTar(args) {
       throw new Error(`workspace seed (tar) failed: ${r.stderr || r.stdout}`);
     }
   } finally {
-    await rm4(stage, { recursive: true, force: true });
+    await rm5(stage, { recursive: true, force: true });
   }
 }
 var CLOUD_WORKSPACE_DIR = "/workspace";
@@ -759,18 +977,28 @@ function parseLoopbackPort(url) {
     return void 0;
   }
 }
-async function bootstrapPortlessForCloudBox(backend, handle, args) {
-  const localPort = parseLoopbackPort(args.webPreviewUrl);
+async function registerHostPortlessAlias(args) {
+  const localPort = parseLoopbackPort(args.previewUrl);
   if (localPort === void 0) return void 0;
-  const ok = await portlessAlias(args.boxName, localPort);
+  const ok = await portlessAlias(args.alias, localPort);
   if (!ok) {
     args.onLog(
-      `portless: alias not registered (portless CLI missing or not running) \u2014 host URL stays http://127.0.0.1:${String(localPort)}`
+      `portless: ${args.label} alias not registered (portless CLI missing or not running) \u2014 host URL stays http://127.0.0.1:${String(localPort)}`
     );
     return void 0;
   }
-  const url = await portlessGetUrl(args.boxName);
+  const url = await portlessGetUrl(args.alias);
   args.onLog(`portless alias ${url} -> 127.0.0.1:${String(localPort)}`);
+  return url;
+}
+async function bootstrapPortlessForCloudBox(backend, handle, args) {
+  const url = await registerHostPortlessAlias({
+    alias: args.boxName,
+    previewUrl: args.webPreviewUrl,
+    label: "web",
+    onLog: args.onLog
+  });
+  if (!url) return void 0;
   if (backend.startInBoxPortless) {
     const mode = parsePortlessUrl(url) ?? { proxyPort: DEFAULT_PORTLESS_PROXY_PORT, tls: false };
     try {
@@ -806,7 +1034,9 @@ function createCloudProvider(backend, opts = {}) {
     return {
       id,
       name,
-      branch: `agentbox/${name}`
+      // --use-branch reuses the named branch directly; otherwise fork a fresh
+      // per-box branch. The CLI validated `useBranch` exists host-side.
+      branch: req.useBranch ?? `agentbox/${name}`
     };
   }
   async function probe(box) {
@@ -825,7 +1055,13 @@ function createCloudProvider(backend, opts = {}) {
       });
       const { id, name, branch } = mintBox(req);
       const image = opts.provisionImage ? await opts.provisionImage(req) : req.image ?? FALLBACK_IMAGE;
-      const resources = opts.defaultResources ?? { cpu: 2, memory: 4, disk: 8 };
+      const baseResources = opts.defaultResources ?? { cpu: 2, memory: 4, disk: 8 };
+      const vcpuOverride = req.providerOptions?.["vcpus"];
+      const resources = typeof vcpuOverride === "number" && vcpuOverride > 0 ? { ...baseResources, cpu: vcpuOverride } : baseResources;
+      const timeoutOverride = req.providerOptions?.["timeoutMs"];
+      const timeoutMs = typeof timeoutOverride === "number" && timeoutOverride > 0 ? timeoutOverride : void 0;
+      const networkPolicyOpt = req.providerOptions?.["networkPolicy"];
+      const networkPolicy = typeof networkPolicyOpt === "string" && networkPolicyOpt.trim() !== "" ? networkPolicyOpt.trim() : void 0;
       const relayToken = generateRelayToken();
       const bridgeToken = generateRelayToken();
       try {
@@ -848,6 +1084,7 @@ function createCloudProvider(backend, opts = {}) {
         }
       }
       const agentVolumes = await ensureAgentVolumesForCloud(backend, { onLog: log });
+      const exposeServicePorts = await readExposedServicePorts(req.workspacePath);
       log(
         snapshotName ? `provisioning ${providerName} sandbox from snapshot` : `provisioning ${providerName} sandbox`
       );
@@ -856,12 +1093,17 @@ function createCloudProvider(backend, opts = {}) {
         image,
         snapshot: snapshotName,
         resources,
+        timeoutMs,
+        exposePorts: exposeServicePorts,
+        networkPolicy,
         env: {
           AGENTBOX_BOX_ID: id,
           AGENTBOX_BOX_NAME: name,
           AGENTBOX_BOX_KIND: "cloud",
-          // In-sandbox relay is on the box's loopback at the default port.
-          AGENTBOX_RELAY_URL: `http://127.0.0.1:${String(8787)}`,
+          // In-sandbox relay is on the box's loopback at the in-box port.
+          // 8788 is distinct from the host relay's 8787 so a nested agentbox
+          // run inside the box can claim :8787 without colliding.
+          AGENTBOX_RELAY_URL: `http://127.0.0.1:${String(8788)}`,
           AGENTBOX_RELAY_TOKEN: relayToken,
           AGENTBOX_BRIDGE_TOKEN: bridgeToken,
           ...agentVolumes.env
@@ -879,6 +1121,9 @@ function createCloudProvider(backend, opts = {}) {
             workspacePath: req.workspacePath,
             branch,
             workspaceDir: CLOUD_WORKSPACE_DIR,
+            bundleDepth: req.bundleDepth,
+            fromBranch: req.fromBranch,
+            useBranch: req.useBranch,
             onLog: log
           });
         }
@@ -889,6 +1134,7 @@ function createCloudProvider(backend, opts = {}) {
             onLog: log
           });
         }
+        await seedOpencodeModelState(backend, handle, { onLog: log });
         if (req.envFilesToImport && req.envFilesToImport.length > 0) {
           const { copied } = await uploadEnvFiles({
             backend,
@@ -900,22 +1146,39 @@ function createCloudProvider(backend, opts = {}) {
           });
           if (copied > 0) log(`copied ${String(copied)} env/config file(s) into /workspace`);
         }
+        let carrySummary;
+        if (req.carry && req.carry.length > 0) {
+          log(`carry: copying ${String(req.carry.length)} host path(s) into the box`);
+          const result = await uploadCarryPaths({
+            backend,
+            handle,
+            entries: req.carry,
+            onLog: log
+          });
+          log(`carry: copied ${String(result.copied)}/${String(req.carry.length)} entry/entries`);
+          for (const err of result.errors) log(`carry: ${err}`);
+          if (result.applied.length > 0) {
+            carrySummary = { count: result.applied.length, entries: result.applied };
+          }
+        }
         log("launching agentbox-ctl daemon");
         await launchCloudCtlDaemon({
           backend,
           handle,
           boxId: id,
           boxName: name,
-          relayUrl: `http://127.0.0.1:${String(8787)}`,
+          relayUrl: `http://127.0.0.1:${String(8788)}`,
           relayToken,
           bridgeToken
         });
-        log("launching in-box dockerd");
-        try {
-          const dockerd = await launchCloudDockerdDaemon({ backend, handle, timeoutMs: 6e4 });
-          if (!dockerd.up) log(`dockerd did not become ready (continuing): ${dockerd.reason ?? "unknown"}`);
-        } catch (err) {
-          log(`dockerd daemon launch failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+        if (opts.launchDockerd !== false) {
+          log("launching in-box dockerd");
+          try {
+            const dockerd = await launchCloudDockerdDaemon({ backend, handle, timeoutMs: 6e4 });
+            if (!dockerd.up) log(`dockerd did not become ready (continuing): ${dockerd.reason ?? "unknown"}`);
+          } catch (err) {
+            log(`dockerd daemon launch failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+          }
         }
         const vncEnabled = req.vnc?.enabled !== false;
         const vncPassword = vncEnabled ? generateVncPassword() : void 0;
@@ -950,7 +1213,30 @@ function createCloudProvider(backend, opts = {}) {
             portlessUrlResolved = r.url;
           }
         }
-        const servicePorts = await readExposedServicePorts(req.workspacePath);
+        let vncPreview;
+        if (portlessOpt && vncEnabled) {
+          try {
+            vncPreview = await backend.previewUrl(handle, CLOUD_VNC_PORT);
+          } catch {
+            vncPreview = void 0;
+          }
+        }
+        let portlessVncAliasName;
+        let portlessVncUrlResolved;
+        if (portlessOpt && vncPreview) {
+          const vncAlias = `vnc-${name}`;
+          const url = await registerHostPortlessAlias({
+            alias: vncAlias,
+            previewUrl: vncPreview.url,
+            label: "vnc",
+            onLog: log
+          });
+          if (url) {
+            portlessVncAliasName = vncAlias;
+            portlessVncUrlResolved = url;
+          }
+        }
+        const servicePorts = exposeServicePorts;
         const servicePreviews = {};
         for (const port of servicePorts) {
           if (port === CLOUD_WEB_PROXY_PORT) continue;
@@ -962,16 +1248,19 @@ function createCloudProvider(backend, opts = {}) {
         }
         let relayPreview;
         try {
-          relayPreview = await backend.previewUrl(handle, 8787);
+          relayPreview = await backend.previewUrl(handle, 8788);
         } catch {
           relayPreview = void 0;
         }
+        const state = await readState();
+        const projectIndex = req.projectRoot ? allocateProjectIndex(state, req.projectRoot) : void 0;
         if (relayPreview) {
           try {
             await registerBoxWithRelay({
               boxId: id,
               token: relayToken,
               name,
+              projectIndex,
               kind: "cloud",
               backend: backend.name,
               previewUrl: relayPreview.url,
@@ -985,8 +1274,6 @@ function createCloudProvider(backend, opts = {}) {
             );
           }
         }
-        const state = await readState();
-        const projectIndex = req.projectRoot ? allocateProjectIndex(state, req.projectRoot) : void 0;
         const record = {
           id,
           name,
@@ -1005,8 +1292,11 @@ function createCloudProvider(backend, opts = {}) {
           relayToken,
           withPlaywright: req.withPlaywright,
           withEnv: req.withEnv,
+          carry: carrySummary,
           portlessAlias: portlessAliasName,
           portlessUrl: portlessUrlResolved,
+          portlessVncAlias: portlessVncAliasName,
+          portlessVncUrl: portlessVncUrlResolved,
           vncEnabled,
           vncPassword,
           vncContainerPort: vncEnabled ? CLOUD_VNC_PORT : void 0,
@@ -1069,7 +1359,7 @@ function createCloudProvider(backend, opts = {}) {
       }
       let relayPreview;
       try {
-        relayPreview = await backend.previewUrl(h, 8787);
+        relayPreview = await backend.previewUrl(h, 8788);
       } catch {
         relayPreview = box.cloud?.relayPreviewUrl ? { url: box.cloud.relayPreviewUrl, token: box.cloud.relayPreviewToken } : void 0;
       }
@@ -1093,10 +1383,31 @@ function createCloudProvider(backend, opts = {}) {
           portlessUrlResolved = r.url;
         }
       }
+      let portlessVncAliasName = box.portlessVncAlias;
+      let portlessVncUrlResolved = box.portlessVncUrl;
+      if (box.portlessVncAlias && box.vncEnabled) {
+        try {
+          const vncPreview = await backend.previewUrl(h, CLOUD_VNC_PORT);
+          const url = await registerHostPortlessAlias({
+            alias: box.portlessVncAlias,
+            previewUrl: vncPreview.url,
+            label: "vnc",
+            onLog: () => {
+            }
+          });
+          if (url) {
+            portlessVncAliasName = box.portlessVncAlias;
+            portlessVncUrlResolved = url;
+          }
+        } catch {
+        }
+      }
       const next = {
         ...box,
         portlessAlias: portlessAliasName,
         portlessUrl: portlessUrlResolved,
+        portlessVncAlias: portlessVncAliasName,
+        portlessVncUrl: portlessVncUrlResolved,
         cloud: {
           ...box.cloud ?? { backend: providerName, sandboxId: h.sandboxId },
           webPort,
@@ -1111,15 +1422,17 @@ function createCloudProvider(backend, opts = {}) {
         handle: h,
         boxId: box.id,
         boxName: box.name,
-        relayUrl: `http://127.0.0.1:${String(8787)}`,
+        relayUrl: `http://127.0.0.1:${String(8788)}`,
         relayToken: box.relayToken ?? "",
         bridgeToken: box.cloud?.bridgeToken
       });
-      try {
-        const dockerd = await launchCloudDockerdDaemon({ backend, handle: h, timeoutMs: 6e4 });
-        if (!dockerd.up) {
+      if (opts.launchDockerd !== false) {
+        try {
+          const dockerd = await launchCloudDockerdDaemon({ backend, handle: h, timeoutMs: 6e4 });
+          if (!dockerd.up) {
+          }
+        } catch {
         }
-      } catch {
       }
       if (box.vncEnabled && box.vncPassword) {
         try {
@@ -1168,6 +1481,12 @@ function createCloudProvider(backend, opts = {}) {
         } catch {
         }
       }
+      if (box.portlessVncAlias) {
+        try {
+          await portlessUnalias(box.portlessVncAlias);
+        } catch {
+        }
+      }
       try {
         await forgetBoxFromRelay(box.id);
       } catch {
@@ -1232,7 +1551,7 @@ function createCloudProvider(backend, opts = {}) {
       const handle = handleFor(box);
       const baseArgv = await backend.attachArgv(handle);
       const inner = renderInnerCommand(kind, opts2);
-      const argv = [...baseArgv.slice(1), "-t", inner];
+      const argv = opts2?.detached ? [...baseArgv.slice(1), inner] : [...baseArgv.slice(1), "-t", inner];
       const fullArgv = [baseArgv[0], ...argv];
       const cleanup = backend.revokeAttachToken ? async () => {
         await backend.revokeAttachToken(handle, baseArgv);
@@ -1251,6 +1570,14 @@ function createCloudProvider(backend, opts = {}) {
     async resolveUrl(box, opts2) {
       const h = handleFor(box);
       const kind = opts2?.kind ?? "web";
+      if (!opts2?.loopback) {
+        if (kind === "web" && box.portlessAlias) {
+          return box.portlessUrl ?? `https://${box.portlessAlias}.localhost`;
+        }
+        if (kind === "vnc" && box.portlessVncAlias) {
+          return box.portlessVncUrl ?? `https://${box.portlessVncAlias}.localhost`;
+        }
+      }
       const port = kind === "vnc" ? CLOUD_VNC_PORT : box.cloud?.webPort ?? CLOUD_WEB_PROXY_PORT;
       if (backend.signedPreviewUrl) {
         const ttl = opts2?.ttl ?? DEFAULT_SIGNED_URL_TTL_SECONDS;
@@ -1266,7 +1593,16 @@ function createCloudProvider(backend, opts = {}) {
     // capability stub whose methods throw — the CLI's `agentbox checkpoint
     // create` then surfaces a clean "not supported" error rather than a
     // silent no-op.
-    checkpoint: makeCloudCheckpoint(backend)
+    checkpoint: makeCloudCheckpoint(backend),
+    // Extract the box's agent login(s) back to the host (~/.agentbox) so the
+    // next box inherits the login. Lives on the base cloud provider (not inside
+    // `checkpoint.create`) so it works even for providers that override the
+    // whole `checkpoint` capability (vercel). The CLI calls this on
+    // `checkpoint create --set-default`, while the box is guaranteed running.
+    async extractAgentCredentials(box) {
+      if (!box.cloud?.sandboxId) return [];
+      return extractCloudAgentCredentials(backend, { sandboxId: box.cloud.sandboxId });
+    }
     // stats is provider-optional; cloud backends without a metrics API just
     // omit it. Backends that have one can decorate the returned provider.
   };
@@ -1322,7 +1658,17 @@ function renderInnerCommand(kind, opts) {
   if (opts?.noTmux) {
     return fallback;
   }
-  return `command -v tmux >/dev/null || { echo "tmux not installed in sandbox"; exit 127; }; exec tmux new-session -A -c ${shellSingle(CLOUD_WORKSPACE_DIR)} -s ${shellSingle(sessionName)} ${shellSingle(fallback)}`;
+  const sessionQ = shellSingle(sessionName);
+  const cwdQ = shellSingle(CLOUD_WORKSPACE_DIR);
+  const fallbackQ = shellSingle(fallback);
+  const configSnippet = buildTmuxConfigShellSnippet(sessionName);
+  const lines = [
+    `command -v tmux >/dev/null || { echo "tmux not installed in sandbox"; exit 127; }`,
+    `tmux has-session -t ${sessionQ} 2>/dev/null || tmux new-session -d -c ${cwdQ} -s ${sessionQ} ${fallbackQ}`,
+    configSnippet
+  ];
+  if (opts?.detached) return lines.join("; ");
+  return [...lines, `exec tmux attach -t ${sessionQ}`].join("; ");
 }
 function defaultSessionName(kind) {
   switch (kind) {
@@ -1361,6 +1707,9 @@ export {
   agentSpecsForCloud,
   listCloudCheckpoints,
   resolveCloudCheckpoint,
-  createCloudProvider
+  writeCloudCheckpointManifest,
+  removeCloudCheckpointDir,
+  createCloudProvider,
+  renderInnerCommand
 };
-//# sourceMappingURL=chunk-NW5NYTQM.js.map
+//# sourceMappingURL=chunk-BXQMIEHC.js.map