@fitlab-ai/agent-infra 0.8.2 → 0.8.4

package/dist/lib/sandbox/clipboard/win32.js

@@ -0,0 +1,144 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const PROBE_TIMEOUT_MS = 2_000;
+const READ_IMAGE_TIMEOUT_MS = 5_000;
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const POWERSHELL_ARGS = ['-NoProfile', '-NonInteractive', '-STA', '-Command'];
+export function createWin32ClipboardAdapter({ execFn = execFileSync, mkdtempFn = fs.mkdtempSync, readFileFn = fs.readFileSync, rmFn = fs.rmSync, existsFn = fs.existsSync } = {}) {
+    return {
+        available() {
+            try {
+                execFn('powershell.exe', [...POWERSHELL_ARGS, clipboardProbeScript()], {
+                    encoding: 'utf8',
+                    timeout: PROBE_TIMEOUT_MS
+                });
+                return { ok: true };
+            }
+            catch {
+                return {
+                    ok: false,
+                    reason: 'Windows PowerShell Get-Clipboard is unavailable; install or enable powershell.exe to use image paste'
+                };
+            }
+        },
+        readImagePng() {
+            const tmpDir = mkdtempFn(path.join(os.tmpdir(), 'agent-infra-clipboard-'));
+            const outputPath = path.join(tmpDir, 'clipboard.png');
+            try {
+                execFn('powershell.exe', [...POWERSHELL_ARGS, pngWriteScript(outputPath)], {
+                    encoding: 'utf8',
+                    timeout: READ_IMAGE_TIMEOUT_MS
+                });
+                const png = Buffer.from(readFileFn(outputPath));
+                return isPng(png) ? png : null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                rmFn(tmpDir, { recursive: true, force: true });
+            }
+        },
+        readImageFromPath(imagePath) {
+            const tmpDir = mkdtempFn(path.join(os.tmpdir(), 'agent-infra-clipboard-'));
+            const outputPath = path.join(tmpDir, 'clipboard.png');
+            try {
+                execFn('powershell.exe', [...POWERSHELL_ARGS, pngFromPathScript(imagePath, outputPath)], {
+                    encoding: 'utf8',
+                    timeout: READ_IMAGE_TIMEOUT_MS
+                });
+                const png = Buffer.from(readFileFn(outputPath));
+                return isPng(png) ? png : null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                rmFn(tmpDir, { recursive: true, force: true });
+            }
+        },
+        readImageFromText(text) {
+            const trimmed = text.trim();
+            if (!isWindowsImagePath(trimmed)) {
+                return null;
+            }
+            if (!existsFn(trimmed)) {
+                return null;
+            }
+            return this.readImageFromPath(trimmed);
+        }
+    };
+}
+function clipboardProbeScript() {
+    return 'if ($null -eq (Get-Command Get-Clipboard -ErrorAction SilentlyContinue)) { exit 1 }';
+}
+// Embed a filesystem path in a PowerShell single-quoted string literal.
+// Single-quoted strings in PowerShell are verbatim (no variable expansion,
+// no escape sequences). The only special character is a single quote itself,
+// which is escaped by doubling it.
+function psLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function pngWriteScript(outputPath) {
+    const psOutputPath = psLiteral(outputPath);
+    return [
+        '$ErrorActionPreference = "Stop"',
+        `$outputPath = ${psOutputPath}`,
+        '$image = $null',
+        'try {',
+        '  Add-Type -AssemblyName System.Drawing',
+        '  $image = Get-Clipboard -Format Image -ErrorAction SilentlyContinue',
+        '  if ($null -ne $image) {',
+        '    $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+        '    return',
+        '  }',
+        '  $files = Get-Clipboard -Format FileDropList -ErrorAction SilentlyContinue',
+        '  if ($null -ne $files) {',
+        '    $allowed = @(".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif", ".ico")',
+        '    foreach ($file in $files) {',
+        '      if (-not (Test-Path -LiteralPath $file -PathType Leaf)) { continue }',
+        '      $ext = [System.IO.Path]::GetExtension($file)',
+        '      if ($allowed -notcontains $ext) { continue }',
+        '      try {',
+        '        $image = [System.Drawing.Image]::FromFile($file)',
+        '        $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+        '        return',
+        '      } catch {}',
+        '    }',
+        '  }',
+        '  throw "clipboard has no image"',
+        '} finally {',
+        '  if ($null -ne $image -and $image -is [System.IDisposable]) { $image.Dispose() }',
+        '}'
+    ].join('\n');
+}
+function pngFromPathScript(imagePath, outputPath) {
+    const psImagePath = psLiteral(imagePath);
+    const psOutputPath = psLiteral(outputPath);
+    return [
+        '$ErrorActionPreference = "Stop"',
+        `$imagePath = ${psImagePath}`,
+        `$outputPath = ${psOutputPath}`,
+        '$image = $null',
+        'try {',
+        '  Add-Type -AssemblyName System.Drawing',
+        '  if (-not (Test-Path -LiteralPath $imagePath -PathType Leaf)) { throw "file not found: $imagePath" }',
+        '  $image = [System.Drawing.Image]::FromFile($imagePath)',
+        '  $image.Save($outputPath, [System.Drawing.Imaging.ImageFormat]::Png)',
+        '} finally {',
+        '  if ($null -ne $image -and $image -is [System.IDisposable]) { $image.Dispose() }',
+        '}'
+    ].join('\n');
+}
+const IMAGE_EXTENSIONS_RE = /\.(png|jpg|jpeg|gif|bmp|webp|tiff?|ico)$/i;
+function isWindowsImagePath(text) {
+    // Must be a Windows absolute path: drive letter + colon + backslash/slash
+    // followed by a path ending with a known image extension.
+    return /^[A-Za-z]:[\\/].+$/.test(text) && IMAGE_EXTENSIONS_RE.test(text);
+}
+function isPng(buffer) {
+    return buffer.length >= PNG_MAGIC.length && PNG_MAGIC.every((byte, index) => buffer[index] === byte);
+}
+//# sourceMappingURL=win32.js.map

package/dist/lib/sandbox/commands/create.js

@@ -7,21 +7,21 @@ import { parseArgs } from 'node:util';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import * as toml from 'smol-toml';
-import { loadConfig } from "../config.js";
-import { assertValidBranchName, containerName, containerNameCandidates, parsePositiveIntegerOption, sandboxBranchLabel, sandboxImageConfigLabel, sandboxLabel, shareBranchDir, shareCommonDir, shellConfigDir, worktreeDirCandidates } from "../constants.js";
-import { prepareDockerfile } from "../dockerfile.js";
-import { detectEngine, ensureDocker } from "../engine.js";
-import { commandForEngine, execEngine, run, runEngine, runOk, runOkEngine, runSafe, runSafeEngine, runVerboseEngine } from "../shell.js";
-import { resolveTaskBranch } from "../task-resolver.js";
-import { imageSignatureFields, resolveTools, toolConfigDirCandidates, toolNpmPackagesArg, toolShellInstallScriptBase64 } from "../tools.js";
-import { hostJoin, toEnginePath, volumeArg } from "../engines/wsl2-paths.js";
-import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from "../clipboard/paths.js";
-import { validateSelinuxDisableEnv } from "../engines/selinux.js";
-import { resolveBuildUid } from "../engines/native.js";
-import { dotfilesCacheDir, materializeDotfiles } from "../dotfiles.js";
-import { ensureSandboxDiscoveryReadmes } from "../readme-scaffold.js";
-import { prepareClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from "../credentials.js";
-import { detectHostTimezone } from "../host-timezone.js";
+import { loadConfig } from '../config.js';
+import { assertValidBranchName, containerName, containerNameCandidates, parsePositiveIntegerOption, sandboxBranchLabel, sandboxImageConfigLabel, sandboxImageRefreshLabel, sandboxLabel, shareBranchDir, shareCommonDir, shellConfigDir, worktreeDirCandidates } from '../constants.js';
+import { prepareDockerfile } from '../dockerfile.js';
+import { detectEngine, ensureDocker } from '../engine.js';
+import { commandForEngine, execEngine, run, runEngine, runOk, runOkEngine, runSafe, runSafeEngine, runVerboseEngine } from '../shell.js';
+import { resolveTaskBranch } from '../task-resolver.js';
+import { resolveTools, toolConfigDirCandidates } from '../tools.js';
+import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
+import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
+import { validateSelinuxDisableEnv } from '../engines/selinux.js';
+import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
+import { ensureSandboxDiscoveryReadmes } from '../readme-scaffold.js';
+import { prepareClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from '../credentials.js';
+import { detectHostTimezone } from '../host-timezone.js';
+import { buildImageSignature, buildSandboxImageArgs, isRefreshDisabled, isRefreshDue, parseImageLabels, parseRefreshTimestamp } from '../image-build.js';
 const OPENCODE_YOLO_PERMISSION = '{"*":"allow","read":"allow","bash":"allow","edit":"allow","webfetch":"allow","external_directory":"allow","doom_loop":"allow"}';
 const SANDBOX_ALIAS_BLOCK_BEGIN = '# >>> agent-infra managed aliases >>>';
 const SANDBOX_ALIAS_BLOCK_END = '# <<< agent-infra managed aliases <<<';
@@ -47,22 +47,13 @@ alias gy='gemini --yolo; tput ed'
 `;
 const CONTAINER_HOME = '/home/devuser';
 const CONTAINER_SHELL_CONFIG_MOUNT = `${CONTAINER_HOME}/.host-shell-config`;
-const USAGE = `Usage: ai sandbox create <branch> [base] [--cpu <n>] [--memory <n>]
+const USAGE = `Usage: ai sandbox create <branch> [base] [--cpu <n>] [--memory <n>] [--no-refresh]
 
 Host aliases:
   ${'~'}/.agent-infra/aliases/sandbox.sh is auto-created on first run and exposed
   as ${CONTAINER_HOME}/.bash_aliases inside the sandbox container (the host
   shell-config directory is bind-mounted at ${CONTAINER_SHELL_CONFIG_MOUNT} and
   symlinked into $HOME).`;
-function buildSignature(preparedDockerfile, tools) {
-    return createHash('sha256')
-        .update(JSON.stringify({
-        dockerfile: preparedDockerfile.signature,
-        tools: imageSignatureFields(tools)
-    }))
-        .digest('hex')
-        .slice(0, 12);
-}
 function resolveToolDirs(config, tools, branch) {
     return tools.map((tool) => {
         const candidates = toolConfigDirCandidates(tool, config.project, branch);
@@ -218,12 +209,14 @@ export function writeSanitizedGitconfig({ home, hostConfigDir, stripGpg, repoRoo
 // Keep in sync with the symlink block in lib/sandbox/runtimes/ai-tools.dockerfile.
 const SHELL_CONFIG_SYMLINKS = ['.gitconfig', '.gitignore_global', '.stCommitMsg', '.bash_aliases'];
 export function ensureShellConfigSymlinks(engine, container, execFn = execEngine) {
-    // Idempotent symlink setup. Runs against a started container so it also
-    // covers custom Dockerfiles that don't bake the symlinks into the image.
-    const script = SHELL_CONFIG_SYMLINKS
-        .map((file) => `ln -sf .host-shell-config/${file} ${CONTAINER_HOME}/${file}`)
-        .join(' && ');
-    execFn(engine, 'docker', ['exec', container, 'bash', '-lc', script], { stdio: 'ignore' });
+    // Idempotent symlink setup. Avoid a shell command here because Windows .cmd
+    // engine shims would interpret metacharacters in a `bash -lc` script before
+    // forwarding it to Docker.
+    for (const file of SHELL_CONFIG_SYMLINKS) {
+        execFn(engine, 'docker', [
+            'exec', container, 'ln', '-sf', `.host-shell-config/${file}`, `${CONTAINER_HOME}/${file}`
+        ], { stdio: 'ignore' });
+    }
 }
 export function prepareHostShellConfig({ home, project, branch, repoRoot }) {
     const hostDir = hostShellConfigDir(home, project, branch);
@@ -433,9 +426,12 @@ function formatEnvFileEntry(key, value) {
     return `${key}=${value}`;
 }
 export function buildContainerEnvFile(resolvedTools, engine, runSafeEngineFn = runSafeEngine, options = {}) {
-    const { mkdtempFn = fs.mkdtempSync, writeFileFn = fs.writeFileSync, chmodFn = fs.chmodSync, rmFn = fs.rmSync, tmpDir = os.tmpdir() } = options;
+    const { mkdtempFn = fs.mkdtempSync, writeFileFn = fs.writeFileSync, chmodFn = fs.chmodSync, rmFn = fs.rmSync, tmpDir = os.tmpdir(), runSafeFn = runSafe } = options;
     const entries = resolvedTools.flatMap(({ tool }) => Object.entries(tool.envVars ?? {}));
-    const ghToken = runSafeEngineFn(engine, 'gh', ['auth', 'token']);
+    let ghToken = runSafeEngineFn(engine, 'gh', ['auth', 'token']);
+    if (!ghToken && engine === 'wsl2') {
+        ghToken = runSafeFn('gh', ['auth', 'token']);
+    }
     if (ghToken) {
         entries.push(['GH_TOKEN', ghToken]);
     }
@@ -908,34 +904,25 @@ export function buildTmpfsRunArgs(containerMount, tmpfs) {
     const size = tmpfs.size ?? '512m';
     return ['--tmpfs', `${containerMount}:rw,size=${size}`];
 }
-export function buildImage(config, tools, dockerfilePath, imageSignature, { engine, runFn = runEngine, runSafeFn = runSafeEngine, runVerboseFn = runVerboseEngine, env = process.env } = {}) {
+export function buildImage(config, tools, dockerfilePath, imageSignature, { engine, runFn = runEngine, runSafeFn = runSafeEngine, runVerboseFn = runVerboseEngine, env = process.env, refresh = false, lastRefresh } = {}) {
     const selectedEngine = engine ?? detectEngine({ engine: config.engine });
-    const { uid: hostUid, gid: hostGid } = resolveBuildUid({
+    runVerboseFn(selectedEngine, 'docker', buildSandboxImageArgs(config, tools, dockerfilePath, imageSignature, {
         engine: selectedEngine,
         runFn,
         runSafeFn,
-        env
-    });
-    runVerboseFn(selectedEngine, 'docker', [
-        'build',
-        '-t',
-        config.imageName,
-        '--build-arg',
-        `HOST_UID=${hostUid}`,
-        '--build-arg',
-        `HOST_GID=${hostGid}`,
-        '--build-arg',
-        `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
-        '--build-arg',
-        `AI_TOOLS_SHELL_INSTALL_B64=${toolShellInstallScriptBase64(tools)}`,
-        '--label',
-        sandboxLabel(config),
-        '--label',
-        `${sandboxImageConfigLabel(config)}=${imageSignature}`,
-        '-f',
-        toEnginePath(selectedEngine, dockerfilePath),
-        toEnginePath(selectedEngine, config.repoRoot)
-    ], { cwd: config.repoRoot });
+        env,
+        refresh,
+        lastRefresh
+    }), { cwd: config.repoRoot });
+}
+function readImageLabels(config, engine) {
+    return parseImageLabels(runSafeEngine(engine, 'docker', [
+        'image',
+        'inspect',
+        '--format',
+        '{{ json .Config.Labels }}',
+        config.imageName
+    ]));
 }
 export async function create(args) {
     const { values, positionals } = parseArgs({
@@ -945,6 +932,7 @@ export async function create(args) {
         options: {
             cpu: { type: 'string' },
             memory: { type: 'string' },
+            'no-refresh': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' }
         }
     });
@@ -986,7 +974,7 @@ export async function create(args) {
     const shareBranch = shareBranchDir(effectiveConfig, branch);
     const preparedDockerfile = prepareDockerfile(effectiveConfig);
     const baseBranch = base ?? runSafe('git', ['-C', effectiveConfig.repoRoot, 'branch', '--show-current']);
-    const expectedImageSignature = buildSignature(preparedDockerfile, tools);
+    const expectedImageSignature = buildImageSignature(preparedDockerfile, tools);
     const engine = detectEngine(effectiveConfig);
     p.intro(pc.cyan('AI Sandbox'));
     p.log.info(`Project: ${pc.bold(effectiveConfig.project)} | Branch: ${pc.bold(branch)} | Base: ${pc.bold(baseBranch || 'HEAD')}`);
@@ -1002,20 +990,41 @@ export async function create(args) {
         });
         p.log.success('Docker is ready');
         const imageExists = runOkEngine(engine, 'docker', ['image', 'inspect', effectiveConfig.imageName]);
-        const currentImageSignature = imageExists
-            ? runSafeEngine(engine, 'docker', [
-                'image',
-                'inspect',
-                '--format',
-                `{{ index .Config.Labels "${sandboxImageConfigLabel(effectiveConfig)}" }}`,
-                effectiveConfig.imageName
-            ])
-            : '';
-        const needsImageBuild = !imageExists || currentImageSignature !== expectedImageSignature;
+        const imageLabels = imageExists ? readImageLabels(effectiveConfig, engine) : {};
+        const currentImageSignature = imageLabels[sandboxImageConfigLabel(effectiveConfig)] ?? '';
+        const currentLastRefresh = parseRefreshTimestamp(imageLabels[sandboxImageRefreshLabel(effectiveConfig)] ?? '');
+        const signatureStale = !imageExists || currentImageSignature !== expectedImageSignature;
+        const now = Date.now();
+        const refreshDue = imageExists
+            && !signatureStale
+            && !isRefreshDisabled(process.env, values['no-refresh'] ?? false)
+            && isRefreshDue(currentLastRefresh, now, effectiveConfig.refreshIntervalDays);
+        const needsImageBuild = signatureStale || refreshDue;
         if (needsImageBuild) {
-            p.log.step(imageExists ? 'Rebuilding stale image...' : 'Building image for first use...');
-            buildImage(effectiveConfig, tools, preparedDockerfile.path, expectedImageSignature, { engine });
-            p.log.success(imageExists ? 'Image rebuilt' : 'Image built');
+            const buildRefresh = !imageExists || refreshDue;
+            const buildLastRefresh = buildRefresh ? now : currentLastRefresh || 0;
+            p.log.step(refreshDue
+                ? 'Refreshing stale image...'
+                : imageExists
+                    ? 'Rebuilding stale image...'
+                    : 'Building image for first use...');
+            try {
+                buildImage(effectiveConfig, tools, preparedDockerfile.path, expectedImageSignature, { engine, refresh: buildRefresh, lastRefresh: buildLastRefresh });
+                p.log.success(refreshDue
+                    ? 'Image refreshed'
+                    : imageExists
+                        ? 'Image rebuilt'
+                        : 'Image built');
+            }
+            catch (error) {
+                if (refreshDue && !signatureStale && imageExists) {
+                    p.log.warn('Scheduled sandbox image refresh failed; continuing with the existing image. ' +
+                        commandErrorMessage(error));
+                }
+                else {
+                    throw error;
+                }
+            }
         }
         else {
             p.log.step(`Using existing image ${effectiveConfig.imageName}`);
@@ -1141,6 +1150,7 @@ export async function create(args) {
                         : null;
                     const envFile = buildContainerEnvFile(effectiveResolvedTools, engine);
                     let hostShellConfig;
+                    let tmpfsSeedPlan = [];
                     try {
                         const claudeCodeEntry = effectiveResolvedTools.find(({ tool }) => tool.id === 'claude-code');
                         if (claudeCodeEntry) {
@@ -1177,21 +1187,23 @@ export async function create(args) {
                             '-v',
                             volumeArg(engine, hostPath, containerPath, ':ro')
                         ]);
-                        // A tmpfs containerMount starts empty, so the config seeded into the
-                        // host dir before launch would be invisible in-container. Bind only
-                        // the explicitly declared seed entries (config.toml, model-catalogs)
-                        // back over the tmpfs as nested mounts — the same proven mechanism as
-                        // hostLiveMounts/auth.json, established at `docker run` time (no
-                        // post-start `docker cp`, which can land under a freshly-mounted
-                        // tmpfs instead of inside it). The allowlist is deliberate: any
-                        // runtime files left in the host dir (e.g. a stale logs_2.sqlite or
-                        // sessions/ from a previous bind-mount era) must NOT be re-mounted,
-                        // or the high-churn writes would land on the host SSD again.
-                        const tmpfsSeedVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => (tool.tmpfs?.seed ?? []).flatMap((entry) => {
+                        // Mount each declared seed read-only at an isolated staging path.
+                        // After docker run mounts the empty tmpfs, the container's default
+                        // user copies these entries into it so the runtime targets are normal,
+                        // writable files rather than nested mount points. The allowlist keeps
+                        // stale runtime files (logs_2.sqlite, sessions, etc.) on the host from
+                        // being exposed or written through.
+                        tmpfsSeedPlan = effectiveResolvedTools.flatMap(({ tool, dir }) => (tool.tmpfs?.seed ?? []).flatMap((entry, index) => {
                             const hostPath = path.join(dir, entry);
-                            return fs.existsSync(hostPath)
-                                ? ['-v', volumeArg(engine, hostPath, path.posix.join(tool.containerMount, entry))]
-                                : [];
+                            if (!fs.existsSync(hostPath)) {
+                                return [];
+                            }
+                            const stagingPath = path.posix.join('/run/agent-infra/tmpfs-seeds', tool.id, String(index));
+                            return [{
+                                    stagingPath,
+                                    targetPath: path.posix.join(tool.containerMount, entry),
+                                    volumeArgs: ['-v', volumeArg(engine, hostPath, stagingPath, ':ro')]
+                                }];
                         }));
                         const liveMountVolumes = effectiveResolvedTools.flatMap(({ tool }) => (tool.hostLiveMounts ?? [])
                             .filter(({ hostPath }) => fs.existsSync(hostPath))
@@ -1231,12 +1243,10 @@ export async function create(args) {
                             ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
                             '-v',
                             volumeArg(engine, path.join(effectiveConfig.repoRoot, '.git'), `${toEnginePath(engine, effectiveConfig.repoRoot)}/.git`),
-                            '-v',
-                            volumeArg(engine, hostJoin(effectiveConfig.home, '.ssh'), '/home/devuser/.ssh', ':ro'),
                             ...dotfilesMount,
                             ...toolVolumes,
                             ...tmpfsArgs,
-                            ...tmpfsSeedVolumes,
+                            ...tmpfsSeedPlan.flatMap(({ volumeArgs }) => volumeArgs),
                             ...liveMountVolumes,
                             ...shellConfigVolumes,
                             ...envFile.dockerArgs,
@@ -1249,6 +1259,14 @@ export async function create(args) {
                     finally {
                         envFile.cleanup();
                     }
+                    for (const { stagingPath, targetPath } of tmpfsSeedPlan) {
+                        runEngineTaskCommand(engine, 'docker', [
+                            'exec', container, 'mkdir', '-p', path.posix.dirname(targetPath)
+                        ]);
+                        runEngineTaskCommand(engine, 'docker', [
+                            'exec', container, 'cp', '-R', '--', stagingPath, targetPath
+                        ]);
+                    }
                     // Belt-and-suspenders: re-create the four shell-config symlinks at
                     // runtime so users with a custom `sandbox.dockerfile` (which won't
                     // include the ai-tools.dockerfile symlink fragment) still get

package/dist/lib/sandbox/commands/enter.js

@@ -1,12 +1,12 @@
-import { loadConfig } from "../config.js";
-import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from "../constants.js";
-import { detectEngine } from "../engine.js";
-import { formatCredentialWarnings, formatRemaining, hasClaudeProviderAuth, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from "../credentials.js";
-import { runInteractiveEngine } from "../shell.js";
-import { dotfilesCacheDir, materializeDotfiles } from "../dotfiles.js";
-import { runInteractiveWithClipboardBridge } from "../clipboard/bridge.js";
-import { detectHostTimezone } from "../host-timezone.js";
-import { fetchSandboxRows, resolveBranchArg, selectSandboxContainer, startSandboxContainer } from "./list-running.js";
+import { loadConfig } from '../config.js';
+import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from '../constants.js';
+import { detectEngine } from '../engine.js';
+import { formatCredentialWarnings, formatRemaining, hasClaudeProviderAuth, reconcileClaudeCredentials, redactCommandError, validateClaudeCredentialsEnvOverride } from '../credentials.js';
+import { runInteractiveEngine } from '../shell.js';
+import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
+import { runInteractiveWithClipboardBridge } from '../clipboard/bridge.js';
+import { detectHostTimezone } from '../host-timezone.js';
+import { fetchSandboxRows, resolveBranchArg, selectSandboxContainer, startSandboxContainer } from './list-running.js';
 const USAGE = `Usage: ai sandbox exec <branch | TASK-id | N | '#N'> [cmd...]
 
 N (bare) and '#N' both reference the same active task short id from

package/dist/lib/sandbox/commands/list-running.js

@@ -1,8 +1,8 @@
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { runSafeEngine, runVerboseEngine } from "../shell.js";
-import { resolveTaskBranch } from "../task-resolver.js";
+import { runSafeEngine, runVerboseEngine } from '../shell.js';
+import { resolveTaskBranch } from '../task-resolver.js';
 export function containerListFormat() {
     return '{{.Names}}\t{{.Status}}\t{{.Labels}}';
 }

package/dist/lib/sandbox/commands/ls.js

@@ -1,12 +1,12 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { loadConfig } from "../config.js";
-import { sandboxBranchLabel, sandboxLabel } from "../constants.js";
-import { detectEngine } from "../engine.js";
-import { formatTable } from "../../table.js";
-import { lookupShortIdByBranch } from "../../task/short-id.js";
-import { fetchSandboxRows } from "./list-running.js";
-export { containerListFormat, parseLabels } from "./list-running.js";
+import { loadConfig } from '../config.js';
+import { sandboxBranchLabel, sandboxLabel } from '../constants.js';
+import { detectEngine } from '../engine.js';
+import { formatTable } from '../../table.js';
+import { lookupShortIdByBranch } from '../../task/short-id.js';
+import { fetchSandboxRows } from './list-running.js';
+export { containerListFormat, parseLabels } from './list-running.js';
 const USAGE = `Usage: ai sandbox ls
 
 Lists all containers for the current project. The '#' column is a

package/dist/lib/sandbox/commands/prune.js

@@ -3,14 +3,14 @@ import path from 'node:path';
 import { parseArgs } from 'node:util';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { loadConfig } from "../config.js";
-import { safeNameCandidates, sandboxBranchLabel, sandboxLabel } from "../constants.js";
-import { detectEngine } from "../engine.js";
-import { hostJoin } from "../engines/wsl2-paths.js";
-import { removeManagedDir, removeWorktreeDir } from "../managed-fs.js";
-import { parseLabels } from "./ls.js";
-import { runEngine, runSafe } from "../shell.js";
-import { resolveTools } from "../tools.js";
+import { loadConfig } from '../config.js';
+import { safeNameCandidates, sandboxBranchLabel, sandboxLabel } from '../constants.js';
+import { detectEngine } from '../engine.js';
+import { hostJoin } from '../engines/wsl2-paths.js';
+import { removeManagedDir, removeWorktreeDir } from '../managed-fs.js';
+import { parseLabels } from './ls.js';
+import { runEngine, runSafe } from '../shell.js';
+import { resolveTools } from '../tools.js';
 const USAGE = `Usage: ai sandbox prune [--dry-run]`;
 function listChildDirs(base) {
     if (!fs.existsSync(base)) {