@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/lib/release/workflow.ts

@@ -1,32 +1,81 @@
-type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'complete';
-type ReleaseFacts = { localTag: boolean; localTagAncestor?: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
+import crypto from 'node:crypto';
+
+type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'post-prepared' | 'complete';
+type PostReleaseFacts = {
+  commit: string | null;
+  isHead: boolean;
+  published: boolean;
+  branch: string;
+  upstream: string | null;
+  remoteHead: string | null;
+  newVersion: string | null;
+  changedPaths: string[];
+  demoInputSha256: string | null;
+  worktree: string[];
+  staged: string[];
+};
+type ReleaseFacts = {
+  localTag: boolean;
+  localTagAncestor?: boolean;
+  localTagConflict?: boolean;
+  remoteBranch: boolean;
+  remoteTag: boolean;
+  githubRelease: boolean | null;
+  npm: boolean | null;
+  homebrew: boolean | null;
+  smoke: 'success' | 'pending' | 'failed' | null;
+  post: PostReleaseFacts;
+};
+type PostConfirmation = {
+  version: string;
+  commit: string;
+  branch: string;
+  upstream: string | null;
+  remoteHead: string | null;
+  newVersion: string | null;
+  changedPaths: string[];
+  demoInputSha256: string | null;
+  worktree: string[];
+  staged: string[];
+  sha256: string;
+};
+
+function byteSort(values: readonly string[]): string[] {
+  return [...values].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
+}
 
 function deriveReleasePhase(facts: ReleaseFacts): ReleasePhase {
   if (!facts.localTag && !facts.localTagAncestor) return 'unprepared';
+  if (facts.post.commit) return facts.post.published ? 'complete' : 'post-prepared';
   if (!facts.remoteBranch && !facts.remoteTag) return 'prepared';
   if (!facts.remoteBranch || !facts.remoteTag) return 'partially-published';
   if (facts.githubRelease !== true || facts.npm !== true || facts.homebrew !== true) return 'published';
-  if (facts.smoke !== 'success' || !facts.postCommit) return 'post-pending';
-  return 'complete';
+  return 'post-pending';
 }
 
-function releaseSnapshot(version: string, facts: ReleaseFacts) {
-  return { version, tag: `v${version.replace(/^v/, '')}`, phase: deriveReleasePhase(facts), facts };
+function createPostConfirmation(version: string, post: PostReleaseFacts): PostConfirmation | null {
+  if (!post.commit || !post.isHead || post.worktree.length || post.staged.length) return null;
+  const canonical = {
+    version,
+    commit: post.commit,
+    branch: post.branch,
+    upstream: post.upstream,
+    remoteHead: post.remoteHead,
+    newVersion: post.newVersion,
+    changedPaths: byteSort(post.changedPaths),
+    demoInputSha256: post.demoInputSha256,
+    worktree: byteSort(post.worktree),
+    staged: byteSort(post.staged)
+  };
+  const sha256 = `sha256:${crypto.createHash('sha256').update(JSON.stringify(canonical), 'utf8').digest('hex')}`;
+  return { ...canonical, sha256 };
 }
 
-async function runReleaseAction(input: { version: string; action: 'inspect' | 'prepare' | 'publish' | 'post'; inspect: () => Promise<ReleaseFacts>; prepare?: () => Promise<void>; publish?: () => Promise<void>; post?: () => Promise<void> }) {
-  const before = releaseSnapshot(input.version, await input.inspect());
-  if (input.action === 'inspect') return { status: 'no-op' as const, changed: false, before, snapshot: before, error: null };
-  if (before.facts.localTagConflict) return { status: 'failed' as const, changed: false, before, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag ${before.tag} is not reachable from HEAD` } };
-  const allowed = input.action === 'prepare' ? before.phase === 'unprepared'
-    : input.action === 'publish' ? before.facts.localTag && ['prepared', 'partially-published'].includes(before.phase)
-      : ['published', 'post-pending'].includes(before.phase);
-  if (!allowed) return { status: before.phase === 'complete' ? 'no-op' as const : 'failed' as const, changed: false, before, snapshot: before, error: before.phase === 'complete' ? null : { code: 'RELEASE_PHASE_INVALID', message: `Cannot ${input.action} from ${before.phase}` } };
-  await input[input.action]?.();
-  const snapshot = releaseSnapshot(input.version, await input.inspect());
-  const progressed = snapshot.phase !== before.phase;
-  return { status: progressed ? 'applied' as const : 'blocked' as const, changed: progressed, before, snapshot, error: progressed ? null : { code: 'RELEASE_PROGRESS_PENDING', message: `${input.action} has not reached the next observable phase` } };
+function releaseSnapshot(version: string, facts: ReleaseFacts) {
+  const snapshot = { version, tag: `v${version.replace(/^v/, '')}`, phase: deriveReleasePhase(facts), facts };
+  const postConfirmation = createPostConfirmation(version, facts.post);
+  return postConfirmation ? { ...snapshot, postConfirmation } : snapshot;
 }
 
-export { deriveReleasePhase, releaseSnapshot, runReleaseAction };
-export type { ReleaseFacts, ReleasePhase };
+export { createPostConfirmation, deriveReleasePhase, releaseSnapshot };
+export type { PostConfirmation, PostReleaseFacts, ReleaseFacts, ReleasePhase };

package/lib/sandbox/commands/create.ts

@@ -2,10 +2,9 @@ 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 type { ExecFileSyncOptions, StdioOptions } 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.ts';
@@ -67,14 +66,17 @@ import type { SandboxTool, TmpfsSeedEntry } from '../tools.ts';
 import {
   assertFreshSandboxReady,
   hydrateTmpfsSeedEntries,
-  prepareTmpfsMounts
+  prepareTmpfsMounts,
+  startSandboxControlBroker
 } from '../recovery.ts';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.ts';
 import { sandboxCoreBindMounts } from '../mounts.ts';
 import {
   assertSandboxTaskSource,
+  finalizeSandboxControlManifest,
   materializeSandboxControl,
-  materializeSandboxWorkspaceView
+  materializeSandboxWorkspaceView,
+  prepareSandboxWorkspaceMountTarget,
 } from '../workspace-view.ts';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.ts';
 import { validateSelinuxDisableEnv } from '../engines/selinux.ts';
@@ -157,12 +159,6 @@ type HostShellConfig = {
   mounts: Array<{ hostPath: string; containerPath: string }>;
 };
 
-function internalCliPath(): string {
-  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: Pick<SandboxCreateConfig, 'project'>, tools: SandboxTool[], branch: string): ResolvedTool[] {
   return tools.map((tool) => {
     const candidates = toolConfigDirCandidates(tool, config.project, branch);
@@ -1254,9 +1250,13 @@ export async function create(args: string[]): Promise<void> {
                 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.`
                 );
               }
             }
@@ -1342,6 +1342,7 @@ export async function create(args: string[]): Promise<void> {
               container,
               identity: target.workspace
             });
+            prepareSandboxWorkspaceMountTarget(worktree);
             const control = materializeSandboxControl({
               base: effectiveConfig.controlBase,
               repoRoot: effectiveConfig.repoRoot,
@@ -1349,7 +1350,8 @@ export async function create(args: string[]): Promise<void> {
               project: effectiveConfig.project,
               container,
               branch,
-              identity: target.workspace
+              identity: target.workspace,
+              engine
             });
             hostShellConfig = prepareHostShellConfig({
               home: effectiveConfig.home,
@@ -1362,6 +1364,7 @@ export async function create(args: string[]): Promise<void> {
               shellConfigHostDir: hostShellConfig.hostDir,
               workspaceViewRoot: workspaceView.root,
               controlDir: control.channelDir,
+              controlStatusDir: control.statusDir,
               ...(target.workspace.mode === 'task-bound'
                 ? {
                   taskSource: assertSandboxTaskSource(
@@ -1421,9 +1424,12 @@ export async function create(args: string[]): Promise<void> {
             const hostTz = detectHostTimezone();
             const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
 
-            runEngineTaskCommand(engine, 'docker', [
+            let createdContainerRef: string | null = null;
+            try {
+              const dockerRunId = runEngineTaskCommand(engine, 'docker', [
               'run',
               '-d',
+              '--init',
               '--name',
               container,
               '--hostname',
@@ -1445,7 +1451,11 @@ export async function create(args: string[]): Promise<void> {
               '-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,
@@ -1466,18 +1476,53 @@ export async function create(args: string[]): Promise<void> {
               '-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;
+              ]);
+              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: unknown;
+              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: Record<string, string> = {
+                [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 as Record<string, unknown>;
+              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/lib/sandbox/commands/prune.ts

@@ -6,16 +6,27 @@ import pc from 'picocolors';
 import { loadConfig } from '../config.ts';
 import type { SandboxConfig } from '../config.ts';
 import { safeNameCandidates, sandboxBranchLabel, sandboxLabel } from '../constants.ts';
-import { detectEngine } from '../engine.ts';
+import { detectEngine, ENGINES } from '../engine.ts';
 import { hostJoin } from '../engines/wsl2-paths.ts';
 import { removeManagedDir, removeWorktreeDir } from '../managed-fs.ts';
 import { parseLabels } from './ls.ts';
 import { runEngine, runSafe } from '../shell.ts';
 import { createSandboxCapabilityPlan } from '../agent-client-reconciler.ts';
 import type { SandboxTool } from '../tools.ts';
+import { createCleanPermit, formatWorktreeSnapshot, inspectWorktrees } from '../worktree-safety.ts';
+import type { WorktreeRemovalPermit } from '../worktree-safety.ts';
 
 const USAGE = `Usage: ai sandbox prune [--dry-run]`;
 
+type PruneDependencies = {
+  config?: SandboxConfig;
+  tools?: SandboxTool[];
+  engine?: string;
+  labelsOutput?: string;
+  confirm?: typeof p.confirm;
+  isCancel?: typeof p.isCancel;
+};
+
 type OrphanKind = 'shell' | 'worktree' | 'share' | 'tool';
 
 export type OrphanGroup = {
@@ -107,12 +118,19 @@ export function collectOrphanGroups(
   return groups;
 }
 
-export function removeOrphanGroups(config: SandboxConfig, groups: OrphanGroup[]): boolean {
+export function removeOrphanGroups(
+  config: SandboxConfig,
+  groups: OrphanGroup[],
+  permits: ReadonlyMap<string, WorktreeRemovalPermit>,
+  allowRegisteredPathFallback = false
+): boolean {
   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 {
         removeManagedDir(group.base, dir);
@@ -142,7 +160,7 @@ function writeGroups(groups: OrphanGroup[]): void {
   }
 }
 
-export async function prune(args: string[]): Promise<void> {
+export async function prune(args: string[], dependencies: PruneDependencies = {}): Promise<void> {
   const { values } = parseArgs({
     args,
     strict: true,
@@ -157,9 +175,9 @@ export async function prune(args: string[]): Promise<void> {
     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',
@@ -168,14 +186,25 @@ export async function prune(args: string[]): Promise<void> {
     '--format',
     '{{.Labels}}'
   ];
-  let labelsOutput: string;
-  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<string, WorktreeRemovalPermit>();
+  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}`));
 
@@ -186,23 +215,32 @@ export async function prune(args: string[]): Promise<void> {
   }
 
   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']);
   }