@madarco/agentbox 0.6.0 → 0.8.0

package/dist/chunk-KJNZP6I3.js

@@ -1,586 +0,0 @@
-#!/usr/bin/env node
-import {
-  ConfigError,
-  VNC_CONTAINER_PORT,
-  WEB_CONTAINER_PORT,
-  bindWorktrees,
-  buildClaudeMounts,
-  buildIdeMounts,
-  chownGitBindParents,
-  collectRepoCarryOver,
-  createSnapshot,
-  cursorServerVolumeName,
-  detectGitRepos,
-  dockerVolumeName,
-  ensureClaudeVolume,
-  ensureHomeOwnedByVscode,
-  ensureIdeVolumes,
-  ensureRelay,
-  generateRelayToken,
-  generateVncPassword,
-  gitWorktreePathFor,
-  launchCtlDaemon,
-  launchDockerdDaemon,
-  launchVncDaemon,
-  loadConfig,
-  pickFreshBranch,
-  registerBoxWithRelay,
-  rehydrateRelayRegistry,
-  repairIdeOwnership,
-  resolveClaudeVolume,
-  seedSetupSkillIntoVolume,
-  seedWorkspace,
-  seedWorkspaceFromDir,
-  snapshotPathFor,
-  vscodeServerVolumeName
-} from "./chunk-HTTKML3C.js";
-import {
-  STATE_DIR,
-  allocateProjectIndex,
-  readState,
-  recordBox
-} from "./chunk-HPZMD5DE.js";
-import {
-  CONTAINER_EXPORT_MERGED,
-  DEFAULT_BOX_IMAGE,
-  DEFAULT_ENV_PATTERNS,
-  boxRunDirFor,
-  containerExists,
-  copyHostEnvFilesToBox,
-  copyHostFilesToBox,
-  dockerInfo,
-  dockerStorageDriver,
-  ensureImage,
-  ensureVolume,
-  publishedHostPort,
-  resolveCheckpoint,
-  runBox
-} from "./chunk-HHMWQNLF.js";
-
-// ../../packages/sandbox-docker/dist/chunk-A4F6SVSK.js
-import { randomBytes } from "crypto";
-import { mkdir as mkdir2, stat } from "fs/promises";
-import { homedir } from "os";
-import { basename, join as join2, resolve } from "path";
-import { execa as execa3 } from "execa";
-import { chmod, mkdir, readFile } from "fs/promises";
-import { join } from "path";
-import { execa } from "execa";
-import { execa as execa2 } from "execa";
-var CREDENTIALS_BACKUP_FILE = join(STATE_DIR, "claude-credentials.json");
-async function hostBackupHasCredentials(path = CREDENTIALS_BACKUP_FILE) {
-  try {
-    const parsed = JSON.parse(await readFile(path, "utf8"));
-    const rt = parsed?.claudeAiOauth?.refreshToken;
-    return typeof rt === "string" && rt.length > 0;
-  } catch {
-    return false;
-  }
-}
-function parseSyncResult(stdout) {
-  const volumeHasCredentials = /\bVOLREAL=yes\b/.test(stdout);
-  if (/\bEXTRACTED=yes\b/.test(stdout)) return { direction: "extracted", volumeHasCredentials };
-  if (/\bSEEDED=yes\b/.test(stdout)) return { direction: "seeded", volumeHasCredentials };
-  return { direction: "noop", volumeHasCredentials };
-}
-var SYNC_SCRIPT = `
-EXTRACTED=no
-SEEDED=no
-VOL=/dst/.credentials.json
-HOST=/host-state/claude-credentials.json
-if [ -f "$VOL" ] && jq -e '(.claudeAiOauth.refreshToken // "") | length > 0' "$VOL" >/dev/null 2>&1; then VOL_REAL=yes; else VOL_REAL=no; fi
-if [ -f "$HOST" ] && jq -e '(.claudeAiOauth.refreshToken // "") | length > 0' "$HOST" >/dev/null 2>&1; then HOST_REAL=yes; else HOST_REAL=no; fi
-if [ "$VOL_REAL" = yes ] && [ "$ISOLATE" != yes ]; then
-  cp -a "$VOL" "$HOST" && chmod 600 "$HOST" && EXTRACTED=yes
-elif [ "$VOL_REAL" = no ] && [ "$HOST_REAL" = yes ]; then
-  cp -a "$HOST" "$VOL" && chown 1000:1000 "$VOL" && chmod 600 "$VOL" && SEEDED=yes && VOL_REAL=yes
-fi
-echo "EXTRACTED=$EXTRACTED SEEDED=$SEEDED VOLREAL=$VOL_REAL"
-`;
-async function syncClaudeCredentials(spec, opts) {
-  try {
-    await mkdir(STATE_DIR, { recursive: true });
-    const { stdout } = await execa("docker", [
-      "run",
-      "--rm",
-      "--user",
-      "0",
-      "-v",
-      `${spec.volume}:/dst`,
-      "-v",
-      `${STATE_DIR}:/host-state`,
-      "-e",
-      `ISOLATE=${opts.isolate ? "yes" : "no"}`,
-      opts.image,
-      "sh",
-      "-c",
-      SYNC_SCRIPT
-    ]);
-    const result = parseSyncResult(stdout);
-    if (result.direction === "extracted") {
-      await chmod(CREDENTIALS_BACKUP_FILE, 384).catch(() => {
-      });
-    }
-    return result;
-  } catch {
-    return { direction: "noop", volumeHasCredentials: false };
-  }
-}
-async function writeBoxEnvFile(container, env) {
-  const body = formatBoxEnvBody(env);
-  const result = await execa2(
-    "docker",
-    ["exec", "--user", "root", "-i", container, "sh", "-c", "umask 022 && cat > /etc/agentbox/box.env"],
-    { input: body, reject: false }
-  );
-  if (result.exitCode !== 0) {
-    return {
-      ok: false,
-      reason: `docker exec failed (exit ${String(result.exitCode)}): ${(result.stderr ?? "").toString().slice(0, 400)}`
-    };
-  }
-  return { ok: true };
-}
-function formatBoxEnvBody(env) {
-  const lines = [];
-  for (const [k, v] of Object.entries(env)) {
-    lines.push(`${k}=${shellSingleQuote(v)}`);
-  }
-  return lines.join("\n") + "\n";
-}
-function shellSingleQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function persistableLimits(lim) {
-  if (!lim) return void 0;
-  const out = {};
-  if (lim.memoryBytes && lim.memoryBytes > 0) out.memoryBytes = Math.floor(lim.memoryBytes);
-  if (lim.cpus && lim.cpus > 0) out.cpus = lim.cpus;
-  if (lim.pidsLimit && lim.pidsLimit > 0) out.pidsLimit = Math.floor(lim.pidsLimit);
-  if (lim.disk) out.disk = lim.disk;
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function generateBoxId() {
-  return randomBytes(4).toString("hex");
-}
-function sanitizeBasename(workspacePath) {
-  const raw = basename(resolve(workspacePath));
-  return raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-._]+|[-._]+$/g, "").slice(0, 30).replace(/[-._]+$/, "");
-}
-function defaultBoxName(workspacePath, id) {
-  const base = sanitizeBasename(workspacePath);
-  return base.length > 0 ? `${base}-${id}` : id;
-}
-async function pathExists(p) {
-  try {
-    await stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function buildIdentityMounts() {
-  const home = homedir();
-  const candidates = [
-    { src: join2(home, ".codex"), dst: "/home/vscode/.codex", readOnly: false },
-    { src: join2(home, ".gitconfig"), dst: "/home/vscode/.gitconfig", readOnly: true }
-  ];
-  const out = [];
-  for (const c of candidates) {
-    if (await pathExists(c.src)) {
-      out.push(`${c.src}:${c.dst}${c.readOnly ? ":ro" : ""}`);
-    }
-  }
-  return out;
-}
-async function createBox(opts) {
-  const log = opts.onLog ?? (() => {
-  });
-  const workspace = resolve(opts.workspacePath);
-  if (!await pathExists(workspace)) {
-    throw new Error(`workspace does not exist: ${workspace}`);
-  }
-  const cfgPath = join2(workspace, "agentbox.yaml");
-  if (await pathExists(cfgPath)) {
-    try {
-      const cfg = await loadConfig(cfgPath);
-      log(`agentbox.yaml validated (${String(cfg.services.length)} service(s))`);
-    } catch (err) {
-      if (err instanceof ConfigError) {
-        throw new Error(`agentbox.yaml validation failed:
-  ${err.message}`);
-      }
-      throw err;
-    }
-  }
-  await dockerInfo();
-  log("docker daemon reachable");
-  let checkpointImage;
-  let checkpointSource;
-  let restoredWorktrees;
-  if (opts.checkpointRef) {
-    const projectRootForCkpt = opts.projectRoot ?? workspace;
-    const head = await resolveCheckpoint(projectRootForCkpt, opts.checkpointRef);
-    if (!head) {
-      throw new Error(`checkpoint not found: ${opts.checkpointRef}`);
-    }
-    checkpointImage = head.manifest.image;
-    const chain = [head.name, ...head.manifest.parents];
-    checkpointSource = { ref: opts.checkpointRef, type: head.manifest.type, chain };
-    restoredWorktrees = head.manifest.worktrees;
-    log(
-      `starting from checkpoint ${opts.checkpointRef} (${head.manifest.type}, ${String(chain.length)} layer(s), image ${head.manifest.image})`
-    );
-  }
-  const imageRef = checkpointImage ?? opts.image ?? DEFAULT_BOX_IMAGE;
-  const ensureRef = checkpointImage ? opts.image ?? DEFAULT_BOX_IMAGE : imageRef;
-  const { built } = await ensureImage(ensureRef, {
-    onProgress: (line) => log(`[image] ${line}`)
-  });
-  log(built ? `built image ${ensureRef}` : `using cached image ${imageRef}`);
-  let relayUp = false;
-  try {
-    await ensureRelay({ onLog: log });
-    const existing = await readState();
-    await rehydrateRelayRegistry(existing.boxes);
-    relayUp = true;
-  } catch (err) {
-    log(`relay unavailable: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const id = generateBoxId();
-  const name = opts.name ?? defaultBoxName(workspace, id);
-  const containerName = `agentbox-${name}`;
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  if (await containerExists(containerName)) {
-    throw new Error(`container ${containerName} already exists; remove it first`);
-  }
-  let projectIndex;
-  if (opts.projectRoot) {
-    projectIndex = allocateProjectIndex(await readState(), opts.projectRoot);
-  }
-  const repoCarryOvers = [];
-  const gitWorktreeRecords = [];
-  if (checkpointImage && restoredWorktrees && restoredWorktrees.length > 0) {
-    gitWorktreeRecords.push(...restoredWorktrees);
-  }
-  if (!checkpointImage) {
-    const repos = await detectGitRepos(workspace);
-    if (repos.length > 0) {
-      log(
-        `detected ${String(repos.length)} git repo(s): ` + repos.map((r) => `${r.kind}${r.relPathFromWorkspace ? "@" + r.relPathFromWorkspace : ""}`).join(", ")
-      );
-    }
-    for (const r of repos) {
-      const branchBase = r.kind === "root" ? `agentbox/${name}` : `agentbox/${name}--${r.relPathFromWorkspace.replace(/[^A-Za-z0-9._-]+/g, "_")}`;
-      const branch = await pickFreshBranch(r.hostMainRepo, branchBase);
-      const containerPath = r.kind === "root" ? "/workspace" : `/workspace/${r.relPathFromWorkspace}`;
-      const gitWorktreePath = gitWorktreePathFor(branch);
-      const carry = await collectRepoCarryOver(r, branch, containerPath, gitWorktreePath);
-      repoCarryOvers.push(carry);
-      gitWorktreeRecords.push({
-        kind: r.kind,
-        hostMainRepo: r.hostMainRepo,
-        containerPath,
-        gitWorktreePath,
-        branch,
-        relPathFromWorkspace: r.relPathFromWorkspace
-      });
-    }
-  }
-  let snapshotDir = null;
-  const snapshotIsUseful = !checkpointImage && repoCarryOvers.length === 0;
-  if (opts.useSnapshot && snapshotIsUseful) {
-    snapshotDir = snapshotPathFor({ id, name, projectIndex });
-    log(`cloning workspace to ${snapshotDir} (APFS clone where available)`);
-    const snap = await createSnapshot({ source: workspace, destination: snapshotDir });
-    log(`pruned ${snap.prunedPaths.length} platform-dependent dirs from snapshot`);
-  } else if (opts.useSnapshot && !checkpointImage) {
-    log("skipping --host-snapshot: git worktree path reads content from .git, not from a workspace clone");
-  }
-  await ensureIdeVolumes(id);
-  const dockerCacheShared = opts.docker?.sharedCache === true;
-  const dockerVolume = dockerVolumeName(id, dockerCacheShared);
-  await ensureVolume(dockerVolume);
-  log(`prepared volumes ${vscodeServerVolumeName(id)}, ${cursorServerVolumeName(id)}, ${dockerVolume}`);
-  const ide = buildIdeMounts(id);
-  const claudeSpec = resolveClaudeVolume({
-    isolate: opts.claudeConfig?.isolate ?? false,
-    boxId: id
-  });
-  const claudeEnsured = await ensureClaudeVolume(claudeSpec, {
-    syncFromHost: true,
-    image: ensureRef,
-    hostWorkspace: workspace
-  });
-  if (claudeEnsured.synced) {
-    log(`synced ${claudeSpec.volume} from ~/.claude`);
-    if ((claudeEnsured.filteredHookCount ?? 0) > 0) {
-      log(
-        `filtered ${String(claudeEnsured.filteredHookCount)} host-path hook(s) (paths under ~/)`
-      );
-    }
-    if (claudeEnsured.installMethodFixed) {
-      log("set installMethod=native in synced .claude.json (matches box native install)");
-    }
-    if (claudeEnsured.aliasedProjectKey) {
-      log(`aliased project state for ${workspace} -> /workspace in synced .claude.json`);
-    }
-    if (claudeEnsured.workspaceTrusted) {
-      log("pre-trusted /workspace in synced .claude.json (skips the trust dialog)");
-    }
-  } else if (claudeEnsured.created) {
-    log(`created empty volume ${claudeSpec.volume} (no host ~/.claude to sync)`);
-  } else {
-    log(`reusing volume ${claudeSpec.volume} (no host ~/.claude to sync)`);
-  }
-  const seeded = await seedSetupSkillIntoVolume(claudeSpec.volume, ensureRef);
-  if (seeded.seeded) log(`refreshed /agentbox-setup skill into ${claudeSpec.volume}`);
-  const credSync = await syncClaudeCredentials(claudeSpec, {
-    image: ensureRef,
-    isolate: opts.claudeConfig?.isolate ?? false
-  });
-  if (credSync.direction === "extracted") {
-    log("extracted box claude credentials to host backup");
-  } else if (credSync.direction === "seeded") {
-    log(`seeded claude credentials into ${claudeSpec.volume} from host backup`);
-  }
-  const claudeMounts = buildClaudeMounts(claudeSpec, process.env);
-  const boxDir = boxRunDirFor({ id, name, projectIndex });
-  const socketDir = join2(boxDir, "run");
-  const socketPath = join2(socketDir, "ctl.sock");
-  const mergedExportDir = join2(boxDir, "workspace");
-  await mkdir2(socketDir, { recursive: true });
-  await mkdir2(mergedExportDir, { recursive: true });
-  const extraVolumes = await buildIdentityMounts();
-  extraVolumes.push(...claudeMounts.extraVolumes);
-  extraVolumes.push(...ide.extraVolumes);
-  extraVolumes.push(`${socketDir}:/run/agentbox`);
-  extraVolumes.push(`${mergedExportDir}:${CONTAINER_EXPORT_MERGED}`);
-  extraVolumes.push(`${dockerVolume}:/var/lib/docker`);
-  for (const w of gitWorktreeRecords) {
-    extraVolumes.push(`${w.hostMainRepo}/.git:${w.hostMainRepo}/.git`);
-  }
-  for (const v of extraVolumes) log(`mounting agent dir: ${v}`);
-  const relayToken = generateRelayToken();
-  if (relayUp) {
-    try {
-      await registerBoxWithRelay({
-        boxId: id,
-        token: relayToken,
-        name,
-        containerName,
-        createdAt,
-        projectIndex,
-        worktrees: gitWorktreeRecords
-      });
-      log(`registered box token with relay`);
-    } catch (err) {
-      log(`relay register failed: ${err instanceof Error ? err.message : String(err)}`);
-      relayUp = false;
-    }
-  }
-  const relayEnv = relayUp ? {
-    // host.docker.internal resolves to the host (where the relay node
-    // process is running). The matching `--add-host` is set in runBox.
-    AGENTBOX_RELAY_URL: `http://host.docker.internal:8787`,
-    AGENTBOX_RELAY_TOKEN: relayToken
-  } : {};
-  const vncEnabled = opts.vnc?.enabled !== false;
-  const vncPassword = vncEnabled ? generateVncPassword() : void 0;
-  const vncEnv = vncEnabled && vncPassword ? { AGENTBOX_VNC_PASSWORD: vncPassword } : {};
-  const vncPortMappings = vncEnabled ? [{ hostPort: 0, containerPort: VNC_CONTAINER_PORT, hostIp: "127.0.0.1" }] : [];
-  const webPortMappings = [
-    { hostPort: 0, containerPort: WEB_CONTAINER_PORT, hostIp: "127.0.0.1" }
-  ];
-  const agentboxEnv = {
-    AGENTBOX: "1",
-    AGENTBOX_BOX_NAME: name,
-    AGENTBOX_HOST_WORKSPACE: workspace,
-    ...opts.projectRoot ? { AGENTBOX_PROJECT_ROOT: opts.projectRoot } : {},
-    ...projectIndex !== void 0 ? { AGENTBOX_PROJECT_INDEX: String(projectIndex) } : {}
-  };
-  const boxEnvForFile = {
-    AGENTBOX_BOX_ID: id,
-    ...agentboxEnv
-  };
-  const appliedLimits = opts.limits;
-  let effectiveLimits = appliedLimits;
-  if (appliedLimits?.disk) {
-    const driver = await dockerStorageDriver();
-    if (!/^(devicemapper|btrfs|zfs|windowsfilter)$/.test(driver)) {
-      log(
-        `warning: --disk/box.disk is a no-op on this engine (storage-driver=${driver || "unknown"}); ignoring`
-      );
-      effectiveLimits = { ...appliedLimits, disk: null };
-    }
-  }
-  await runBox({
-    name: containerName,
-    image: imageRef,
-    extraVolumes,
-    limits: effectiveLimits,
-    portMappings: [...vncPortMappings, ...webPortMappings],
-    env: {
-      AGENTBOX_BOX_ID: id,
-      ...agentboxEnv,
-      ...claudeMounts.env,
-      ...relayEnv,
-      ...vncEnv,
-      ...opts.claudeEnv ?? {}
-    }
-  });
-  log(`container ${containerName} started`);
-  if (gitWorktreeRecords.length > 0) {
-    await chownGitBindParents({
-      container: containerName,
-      hostMainRepos: gitWorktreeRecords.map((w) => w.hostMainRepo),
-      onLog: log
-    });
-  }
-  const boxEnv = await writeBoxEnvFile(containerName, boxEnvForFile);
-  if (boxEnv.ok) log("wrote /etc/agentbox/box.env");
-  else log(`writing /etc/agentbox/box.env failed: ${boxEnv.reason}`);
-  await ensureHomeOwnedByVscode(containerName);
-  if (!checkpointImage) {
-    if (repoCarryOvers.length > 0) {
-      try {
-        await seedWorkspace({ container: containerName, repos: repoCarryOvers, onLog: log });
-        log("seeded /workspace from in-container git worktree(s)");
-      } catch (err) {
-        log(
-          `seedWorkspace failed; leaving ${containerName} running so you can inspect it`
-        );
-        throw err;
-      }
-    } else {
-      const source = snapshotDir ?? workspace;
-      await seedWorkspaceFromDir({ container: containerName, hostSource: source, onLog: log });
-    }
-  } else if (restoredWorktrees && restoredWorktrees.length > 0) {
-    await bindWorktrees(
-      containerName,
-      restoredWorktrees.map((w) => ({
-        kind: w.kind,
-        containerPath: w.containerPath,
-        gitWorktreePath: w.gitWorktreePath
-      })),
-      log
-    );
-    log("re-bound /workspace from checkpoint image");
-  } else {
-    log("using /workspace from checkpoint image (no worktrees recorded; no rebind)");
-  }
-  await repairIdeOwnership(containerName);
-  log(".vscode-server + .cursor-server ownership verified");
-  const ctl = await launchCtlDaemon(containerName, socketPath);
-  if (ctl.up) log("agentbox-ctl daemon up");
-  else log(`agentbox-ctl daemon did not become reachable: ${ctl.reason}`);
-  const dockerd = await launchDockerdDaemon(containerName);
-  if (dockerd.up) {
-    log(`dockerd up (data root=${dockerVolume})`);
-  } else {
-    log(`dockerd did not become ready: ${dockerd.reason}`);
-  }
-  if (opts.withPlaywright) {
-    log("installing @playwright/cli@latest (--with-playwright)");
-    const result = await execa3(
-      "docker",
-      [
-        "exec",
-        "--user",
-        "root",
-        containerName,
-        "bash",
-        "-lc",
-        "npm install -g @playwright/cli@latest 2>&1"
-      ],
-      { reject: false }
-    );
-    for (const line of (result.stdout ?? "").split("\n")) {
-      if (line.trim().length > 0) log(`[playwright] ${line}`);
-    }
-    if (result.exitCode !== 0) {
-      throw new Error(
-        `failed to install @playwright/cli (exit ${String(result.exitCode)}): ${(result.stderr ?? "").toString().slice(0, 400)}`
-      );
-    }
-    log("@playwright/cli installed");
-  }
-  if (opts.withEnv) {
-    log("copying host env/config files into /workspace (--with-env)");
-    const { copied } = await copyHostEnvFilesToBox({
-      container: containerName,
-      workspaceDir: workspace,
-      patterns: DEFAULT_ENV_PATTERNS,
-      onLog: log
-    });
-    log(copied > 0 ? `copied ${String(copied)} env/config file(s)` : "no env/config files found");
-  }
-  if (opts.envFilesToImport && opts.envFilesToImport.length > 0) {
-    log(`copying ${String(opts.envFilesToImport.length)} selected env/config file(s) into /workspace`);
-    const { copied } = await copyHostFilesToBox({
-      container: containerName,
-      workspaceDir: workspace,
-      files: opts.envFilesToImport,
-      onLog: log
-    });
-    if (copied !== opts.envFilesToImport.length) {
-      log(`copied ${String(copied)}/${String(opts.envFilesToImport.length)} selected env/config file(s)`);
-    }
-  }
-  let vncHostPort = null;
-  if (vncEnabled) {
-    const vnc = await launchVncDaemon(containerName);
-    if (vnc.up) log("vnc stack up (Xvnc + websockify + noVNC)");
-    else log(`vnc stack did not become reachable: ${vnc.reason}`);
-    vncHostPort = await publishedHostPort(containerName, VNC_CONTAINER_PORT);
-    if (vncHostPort) log(`vnc web on host 127.0.0.1:${String(vncHostPort)}`);
-  }
-  const webHostPort = await publishedHostPort(containerName, WEB_CONTAINER_PORT);
-  if (webHostPort) {
-    log(
-      `web port reserved on host 127.0.0.1:${String(webHostPort)} (forwards to the web service once agentbox.yaml sets a service expose:)`
-    );
-  }
-  const record = {
-    id,
-    name,
-    container: containerName,
-    image: imageRef,
-    workspacePath: workspace,
-    snapshotDir,
-    socketPath,
-    claudeConfigVolume: claudeSpec.volume,
-    vscodeServerVolume: vscodeServerVolumeName(id),
-    cursorServerVolume: cursorServerVolumeName(id),
-    relayToken: relayUp ? relayToken : void 0,
-    gitWorktrees: gitWorktreeRecords.length > 0 ? gitWorktreeRecords : void 0,
-    withPlaywright: opts.withPlaywright ? true : void 0,
-    withEnv: opts.withEnv ? true : void 0,
-    vncEnabled: vncEnabled ? true : void 0,
-    vncContainerPort: vncEnabled ? VNC_CONTAINER_PORT : void 0,
-    vncHostPort: vncHostPort ?? void 0,
-    vncPassword,
-    webContainerPort: WEB_CONTAINER_PORT,
-    webHostPort: webHostPort ?? void 0,
-    dockerVolume,
-    dockerCacheShared: dockerCacheShared || void 0,
-    projectRoot: opts.projectRoot,
-    projectIndex,
-    checkpointImage,
-    checkpointSource,
-    resourceLimits: persistableLimits(effectiveLimits),
-    createdAt
-  };
-  await recordBox(record);
-  return { record, imageBuilt: built };
-}
-
-export {
-  hostBackupHasCredentials,
-  syncClaudeCredentials,
-  sanitizeBasename,
-  defaultBoxName,
-  createBox
-};
-//# sourceMappingURL=chunk-KJNZP6I3.js.map