@fitlab-ai/agent-infra 0.9.5 → 0.9.7

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

@@ -2,9 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { execFileSync, spawn } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { parseArgs } from 'node:util';
-import { fileURLToPath } from 'node:url';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { listAgentClientAdapters } from '../../agent-clients/registry.js';
@@ -17,10 +16,10 @@ import { commandForEngine, execEngine, run, runEngine, runOk, runOkEngine, runSa
 import { parseSandboxWorkspaceIdentity, resolveSandboxTarget, sameSandboxWorkspaceIdentity } from '../workspace-identity.js';
 import { createSandboxCapabilityPlan, runSandboxHooks, runBoundedSandboxHookCommand } from '../agent-client-reconciler.js';
 import { resolveTools, tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.js';
-import { assertFreshSandboxReady, hydrateTmpfsSeedEntries, prepareTmpfsMounts } from '../recovery.js';
+import { assertFreshSandboxReady, hydrateTmpfsSeedEntries, prepareTmpfsMounts, startSandboxControlBroker } from '../recovery.js';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from '../mounts.js';
-import { assertSandboxTaskSource, materializeSandboxControl, materializeSandboxWorkspaceView } from '../workspace-view.js';
+import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTarget, } from '../workspace-view.js';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
 import { validateSelinuxDisableEnv } from '../engines/selinux.js';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
@@ -65,11 +64,6 @@ const MANAGED_GITHUB_GIT_CONFIG = [
     '[url "https://github.com/"]',
     '\tinsteadOf = git@github.com:'
 ];
-function internalCliPath() {
-    const directory = path.dirname(fileURLToPath(import.meta.url));
-    const extension = path.extname(fileURLToPath(import.meta.url));
-    return path.resolve(directory, '..', '..', '..', 'bin', `internal-cli${extension}`);
-}
 function resolveToolDirs(config, tools, branch) {
     return tools.map((tool) => {
         const candidates = toolConfigDirCandidates(tool, config.project, branch);
@@ -895,8 +889,12 @@ export async function create(args) {
                                 const requestedDescription = target.workspace.mode === 'task-bound'
                                     ? `task-bound:${target.workspace.taskId}`
                                     : target.workspace.mode;
+                                const recoveryTarget = target.workspace.mode === 'task-bound'
+                                    ? target.workspace.taskId
+                                    : branch;
                                 throw new Error(`SANDBOX_WORKSPACE_IDENTITY_CONFLICT: container '${name}' is ${existingDescription}, `
-                                    + `but this request is ${requestedDescription}. Run 'ai sandbox rm ${branch}' and retry.`);
+                                    + `but this request is ${requestedDescription}. `
+                                    + `Run 'ai sandbox start --recreate ${recoveryTarget}' on the host, then retry.`);
                             }
                         }
                         message('Removing old container instance...');
@@ -962,6 +960,7 @@ export async function create(args) {
                             container,
                             identity: target.workspace
                         });
+                        prepareSandboxWorkspaceMountTarget(worktree);
                         const control = materializeSandboxControl({
                             base: effectiveConfig.controlBase,
                             repoRoot: effectiveConfig.repoRoot,
@@ -969,7 +968,8 @@ export async function create(args) {
                             project: effectiveConfig.project,
                             container,
                             branch,
-                            identity: target.workspace
+                            identity: target.workspace,
+                            engine
                         });
                         hostShellConfig = prepareHostShellConfig({
                             home: effectiveConfig.home,
@@ -982,6 +982,7 @@ export async function create(args) {
                             shellConfigHostDir: hostShellConfig.hostDir,
                             workspaceViewRoot: workspaceView.root,
                             controlDir: control.channelDir,
+                            controlStatusDir: control.statusDir,
                             ...(target.workspace.mode === 'task-bound'
                                 ? {
                                     taskSource: assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId),
@@ -1028,55 +1029,105 @@ export async function create(args) {
                             : [];
                         const hostTz = detectHostTimezone();
                         const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
-                        runEngineTaskCommand(engine, 'docker', [
-                            'run',
-                            '-d',
-                            '--name',
-                            container,
-                            '--hostname',
-                            `${effectiveConfig.project}-sandbox`,
-                            '--label',
-                            sandboxLabel(effectiveConfig),
-                            '--label',
-                            `${sandboxBranchLabel(effectiveConfig)}=${branch}`,
-                            '--label',
-                            `${sandboxWorkspaceModeLabel(effectiveConfig)}=${target.workspace.mode}`,
-                            ...(target.workspace.mode === 'task-bound'
-                                ? [
-                                    '--label',
-                                    `${sandboxTaskIdLabel(effectiveConfig)}=${target.workspace.taskId}`,
-                                    '-e',
-                                    `AGENT_INFRA_TASK_ID=${target.workspace.taskId}`
-                                ]
-                                : []),
-                            '-e',
-                            `AGENT_INFRA_CONTROL_TOKEN=${control.token}`,
-                            '-e',
-                            'AGENT_INFRA_CONTROL_DIR=/run/agent-infra/control',
-                            '--label',
-                            `${sandboxRuntimeCapabilityLabel(effectiveConfig)}=${capabilityPlan.runtimeSignature}`,
-                            ...coreVolumes,
-                            ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
-                            '-v',
-                            volumeArg(engine, path.join(effectiveConfig.repoRoot, '.git'), `${toEnginePath(engine, effectiveConfig.repoRoot)}/.git`),
-                            ...dotfilesMount,
-                            ...toolVolumes,
-                            ...tmpfsArgs,
-                            ...tmpfsSeedPlan.flatMap(({ volumeArgs }) => volumeArgs),
-                            ...liveMountVolumes,
-                            ...envFile.dockerArgs,
-                            ...tzFlags,
-                            '-w',
-                            '/workspace',
-                            effectiveConfig.imageName
-                        ]);
-                        const broker = spawn(process.execPath, [internalCliPath(), 'sandbox-control', 'serve', '--manifest', control.manifestPath], { cwd: effectiveConfig.repoRoot, detached: true, stdio: 'ignore' });
-                        broker.once('error', () => {
-                            // Fresh readiness verification below remains the source of truth;
-                            // consume detached spawn errors so they cannot crash the command.
-                        });
-                        broker.unref();
-                        createdTmpfsSeedPlan = tmpfsSeedPlan;
+                        let createdContainerRef = null;
+                        try {
+                            const dockerRunId = runEngineTaskCommand(engine, 'docker', [
+                                'run',
+                                '-d',
+                                '--init',
+                                '--name',
+                                container,
+                                '--hostname',
+                                `${effectiveConfig.project}-sandbox`,
+                                '--label',
+                                sandboxLabel(effectiveConfig),
+                                '--label',
+                                `${sandboxBranchLabel(effectiveConfig)}=${branch}`,
+                                '--label',
+                                `${sandboxWorkspaceModeLabel(effectiveConfig)}=${target.workspace.mode}`,
+                                ...(target.workspace.mode === 'task-bound'
+                                    ? [
+                                        '--label',
+                                        `${sandboxTaskIdLabel(effectiveConfig)}=${target.workspace.taskId}`,
+                                        '-e',
+                                        `AGENT_INFRA_TASK_ID=${target.workspace.taskId}`
+                                    ]
+                                    : []),
+                                '-e',
+                                `AGENT_INFRA_CONTROL_TOKEN=${control.token}`,
+                                '-e',
+                                `AGENT_INFRA_CONTROL_GENERATION=${control.generation}`,
+                                '-e',
+                                'AGENT_INFRA_CONTROL_DIR=/run/agent-infra/control',
+                                '-e',
+                                'AGENT_INFRA_CONTROL_STATUS_DIR=/run/agent-infra/control-status',
+                                '--label',
+                                `${sandboxRuntimeCapabilityLabel(effectiveConfig)}=${capabilityPlan.runtimeSignature}`,
+                                ...coreVolumes,
+                                ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
+                                '-v',
+                                volumeArg(engine, path.join(effectiveConfig.repoRoot, '.git'), `${toEnginePath(engine, effectiveConfig.repoRoot)}/.git`),
+                                ...dotfilesMount,
+                                ...toolVolumes,
+                                ...tmpfsArgs,
+                                ...tmpfsSeedPlan.flatMap(({ volumeArgs }) => volumeArgs),
+                                ...liveMountVolumes,
+                                ...envFile.dockerArgs,
+                                ...tzFlags,
+                                '-w',
+                                '/workspace',
+                                effectiveConfig.imageName
+                            ]);
+                            createdContainerRef = dockerRunId.trim();
+                            const containerId = runEngineTaskCommand(engine, 'docker', [
+                                'inspect', '--format', '{{.Id}}', dockerRunId.trim()
+                            ]).trim();
+                            if (!containerId)
+                                throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
+                            const rawContainerLabels = runEngineTaskCommand(engine, 'docker', [
+                                'inspect', '--format', '{{json .Config.Labels}}', containerId
+                            ]).trim();
+                            let inspectedLabels;
+                            try {
+                                inspectedLabels = JSON.parse(rawContainerLabels);
+                            }
+                            catch {
+                                throw new Error('SANDBOX_CONTROL_CONTAINER_LABELS_INVALID');
+                            }
+                            if (!inspectedLabels || typeof inspectedLabels !== 'object' || Array.isArray(inspectedLabels)) {
+                                throw new Error('SANDBOX_CONTROL_CONTAINER_LABELS_INVALID');
+                            }
+                            const expectedLabels = {
+                                [sandboxLabel(effectiveConfig)]: '',
+                                [sandboxBranchLabel(effectiveConfig)]: branch,
+                                [sandboxWorkspaceModeLabel(effectiveConfig)]: target.workspace.mode,
+                                [sandboxRuntimeCapabilityLabel(effectiveConfig)]: capabilityPlan.runtimeSignature,
+                                ...(target.workspace.mode === 'task-bound'
+                                    ? { [sandboxTaskIdLabel(effectiveConfig)]: target.workspace.taskId }
+                                    : {})
+                            };
+                            const labels = inspectedLabels;
+                            for (const [key, expected] of Object.entries(expectedLabels)) {
+                                if (labels[key] !== expected)
+                                    throw new Error('SANDBOX_CONTROL_CONTAINER_IDENTITY_MISMATCH');
+                            }
+                            finalizeSandboxControlManifest(control, {
+                                engine,
+                                id: containerId,
+                                labels: expectedLabels
+                            });
+                            await startSandboxControlBroker(effectiveConfig.repoRoot, control.manifestPath);
+                            createdTmpfsSeedPlan = tmpfsSeedPlan;
+                        }
+                        catch (error) {
+                            if (createdContainerRef) {
+                                runSafeEngine(engine, 'docker', ['stop', createdContainerRef]);
+                                runSafeEngine(engine, 'docker', ['rm', createdContainerRef]);
+                            }
+                            removeDirRecursive(control.root);
+                            removeDirRecursive(workspaceView.root);
+                            throw error;
+                        }
                     }
                     finally {
                         envFile.cleanup();

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

@@ -5,12 +5,13 @@ 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 { detectEngine, ENGINES } 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 { createSandboxCapabilityPlan } from '../agent-client-reconciler.js';
+import { createCleanPermit, formatWorktreeSnapshot, inspectWorktrees } from '../worktree-safety.js';
 const USAGE = `Usage: ai sandbox prune [--dry-run]`;
 function listChildDirs(base) {
     if (!fs.existsSync(base)) {
@@ -83,12 +84,15 @@ export function collectOrphanGroups(config, tools, activeBranches) {
     }
     return groups;
 }
-export function removeOrphanGroups(config, groups) {
+export function removeOrphanGroups(config, groups, permits, allowRegisteredPathFallback = false) {
     let removedWorktrees = false;
     for (const group of groups) {
         for (const dir of group.dirs) {
             if (group.kind === 'worktree') {
-                removeWorktreeDir(config.repoRoot, group.base, dir);
+                const permit = permits.get(path.resolve(dir));
+                if (!permit)
+                    throw new Error(`Missing worktree removal permit: ${dir}`);
+                removeWorktreeDir(config.repoRoot, group.base, dir, permit, { allowRegisteredPathFallback });
                 removedWorktrees = true;
             }
             else {
@@ -115,7 +119,7 @@ function writeGroups(groups) {
         }
     }
 }
-export async function prune(args) {
+export async function prune(args, dependencies = {}) {
     const { values } = parseArgs({
         args,
         strict: true,
@@ -128,9 +132,9 @@ export async function prune(args) {
         process.stdout.write(`${USAGE}\n`);
         return;
     }
-    const config = loadConfig();
-    const tools = [...createSandboxCapabilityPlan(config).cleanupInventory];
-    const engine = detectEngine(config);
+    const config = dependencies.config ?? loadConfig();
+    const tools = dependencies.tools ?? [...createSandboxCapabilityPlan(config).cleanupInventory];
+    const engine = dependencies.engine ?? detectEngine(config);
     const psArgs = [
         'ps',
         '-a',
@@ -139,15 +143,27 @@ export async function prune(args) {
         '--format',
         '{{.Labels}}'
     ];
-    let labelsOutput;
-    try {
-        labelsOutput = runEngine(engine, 'docker', psArgs);
-    }
-    catch {
-        throw new Error('Unable to determine active sandbox branches: docker ps failed');
+    let labelsOutput = dependencies.labelsOutput;
+    if (labelsOutput === undefined) {
+        try {
+            labelsOutput = runEngine(engine, 'docker', psArgs);
+        }
+        catch {
+            throw new Error('Unable to determine active sandbox branches: docker ps failed');
+        }
     }
+    const confirm = dependencies.confirm ?? p.confirm;
+    const isCancel = dependencies.isCancel ?? p.isCancel;
     const groups = collectOrphanGroups(config, tools, activeBranchesFromLabels(config, labelsOutput));
     const count = orphanCount(groups);
+    const worktrees = groups.filter((group) => group.kind === 'worktree').flatMap((group) => group.dirs);
+    const inspections = inspectWorktrees(worktrees);
+    const blockers = inspections.filter((inspection) => inspection.status !== 'clean');
+    const permits = new Map();
+    for (const inspection of inspections) {
+        if (inspection.status === 'clean')
+            permits.set(inspection.snapshot.worktree, createCleanPermit(inspection.snapshot));
+    }
     p.intro(pc.cyan(`Pruning orphaned sandbox state for ${config.project}`));
     if (count === 0) {
         p.log.success('No orphaned sandbox state dirs found');
@@ -155,19 +171,27 @@ export async function prune(args) {
         return;
     }
     writeGroups(groups);
+    for (const blocker of blockers) {
+        p.log.error(blocker.status === 'failed'
+            ? `${JSON.stringify(blocker.worktree)}: ${blocker.message}`
+            : formatWorktreeSnapshot(blocker.snapshot));
+    }
     if (values['dry-run']) {
         p.outro(pc.green('Dry run complete'));
         return;
     }
-    const shouldRemove = await p.confirm({
+    if (blockers.length > 0) {
+        throw new Error('Refusing to prune because worktree preflight found blocker(s); no orphan state was deleted');
+    }
+    const shouldRemove = await confirm({
         message: `Remove ${count} orphaned sandbox state dirs?`,
         initialValue: true
     });
-    if (p.isCancel(shouldRemove) || !shouldRemove) {
+    if (isCancel(shouldRemove) || !shouldRemove) {
         p.outro('Cancelled');
         return;
     }
-    const removedWorktrees = removeOrphanGroups(config, groups);
+    const removedWorktrees = removeOrphanGroups(config, groups, permits, engine === ENGINES.WSL2);
     if (removedWorktrees) {
         runSafe('git', ['-C', config.repoRoot, 'worktree', 'prune']);
     }