@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/lib/process-data/index.ts

@@ -10,6 +10,7 @@ import { readAppliedOverlays, repairSnapshot } from './repair.ts';
 import { collectGitHubBoundary, resolveGitHubRepository } from './sources.ts';
 import { canonicalJsonBytes, createObjectStore, findSnapshot, publishSnapshotV2, verifySnapshot } from './store.ts';
 import { createGitHubClient } from '../platform/github-client.ts';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from '../internal/cli-route-inventory.ts';
 
 import type { NormalizedRecord } from './types.ts';
 
@@ -22,6 +23,7 @@ Commands:
   repair <snapshot-id> [--root <dir>] [--apply]
   export <snapshot-id> [--root <dir>] [--repairs none|applied] [--as-of <ISO>] [--output <file|->]
 `;
+const DATA_OPERATIONS = PUBLIC_CLI_ROUTE_SELECTORS.data;
 
 type ParsedArgs = { positionals: string[]; options: Map<string, string | true> };
 
@@ -256,6 +258,11 @@ async function cmdData(args: string[]): Promise<number> {
     return command ? 0 : 1;
   }
   try {
+    if (!DATA_OPERATIONS.includes(command as typeof DATA_OPERATIONS[number])) {
+      process.stderr.write(`Unknown data command: ${command}\n`);
+      process.stdout.write(USAGE);
+      return 1;
+    }
     switch (command) {
       case 'capture': return capture(rest);
       case 'verify': return verify(rest);

package/lib/release/workflow.ts

@@ -10,7 +10,7 @@ type PostReleaseFacts = {
   remoteHead: string | null;
   newVersion: string | null;
   changedPaths: string[];
-  demoInputSha256: string | null;
+  demoTranscriptSha256: string | null;
   worktree: string[];
   staged: string[];
 };
@@ -34,7 +34,7 @@ type PostConfirmation = {
   remoteHead: string | null;
   newVersion: string | null;
   changedPaths: string[];
-  demoInputSha256: string | null;
+  demoTranscriptSha256: string | null;
   worktree: string[];
   staged: string[];
   sha256: string;
@@ -63,7 +63,7 @@ function createPostConfirmation(version: string, post: PostReleaseFacts): PostCo
     remoteHead: post.remoteHead,
     newVersion: post.newVersion,
     changedPaths: byteSort(post.changedPaths),
-    demoInputSha256: post.demoInputSha256,
+    demoTranscriptSha256: post.demoTranscriptSha256,
     worktree: byteSort(post.worktree),
     staged: byteSort(post.staged)
   };

package/lib/run/index.ts

@@ -7,6 +7,7 @@ import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts'
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
 import { getSkillRunSpec } from './skills.ts';
 import { runHostCommand, type RunProcessResult } from './host.ts';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from '../internal/cli-route-inventory.ts';
 
 export type ParsedRunArgs = {
   skill: string;
@@ -107,6 +108,10 @@ export function parseRunArgs(args: string[]): ParsedRunArgs {
   if (!skill) throw new Error("option '--skill' is required");
   const spec = getSkillRunSpec(skill);
   if (!spec) throw new Error(`Unknown skill '${skill}'`);
+  const routeSelector = spec.kind === 'create' ? 'create-task' : recreate ? 'recreate' : 'task-skill';
+  if (!PUBLIC_CLI_ROUTE_SELECTORS.run.includes(routeSelector as typeof PUBLIC_CLI_ROUTE_SELECTORS.run[number])) {
+    throw new Error(`Unsupported run route '${routeSelector}'`);
+  }
   if (spec.kind === 'create') {
     if (taskRef !== null) throw new Error("create-task does not accept '--task'");
     if (recreate) throw new Error('--recreate is only valid for sandbox task runs');

package/lib/sandbox/commands/control-status.ts

@@ -0,0 +1,26 @@
+import type { SandboxConfig } from '../config.ts';
+import { readSandboxControlStatus } from '../control/state.ts';
+import type { SandboxControlStatus } from '../control/protocol.ts';
+import { sandboxControlPaths } from '../workspace-view.ts';
+import type { SandboxRow } from './list-running.ts';
+
+export function readSandboxControlStatusForRow(
+  config: SandboxConfig,
+  row: Pick<SandboxRow, 'name' | 'workspaceMode' | 'taskId'>
+): SandboxControlStatus | null {
+  if (!row.workspaceMode || row.workspaceMode === 'legacy-invalid') return null;
+  const identity = row.workspaceMode === 'task-bound' && row.taskId
+    ? { mode: 'task-bound' as const, taskId: row.taskId }
+    : { mode: 'branch-only' as const };
+  const control = sandboxControlPaths({
+    base: config.controlBase,
+    project: config.project,
+    container: row.name,
+    identity
+  });
+  try {
+    return readSandboxControlStatus(control.statusDir);
+  } catch {
+    return null;
+  }
+}

package/lib/sandbox/commands/create.ts

@@ -92,6 +92,12 @@ import {
 } from '../workspace-view.ts';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.ts';
 import { validateSelinuxDisableEnv } from '../engines/selinux.ts';
+import {
+  captureSandboxAuthority,
+  commandForSandboxAuthority,
+  verifySandboxAuthority,
+  type SandboxAuthorityEvidenceV1
+} from '../engines/authority.ts';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.ts';
 import { ensureSandboxDiscoveryReadmes } from '../readme-scaffold.ts';
 import { removeDirRecursive } from '../../remove-dir.ts';
@@ -923,6 +929,24 @@ function runEngineTaskCommand(engine: string, cmd: string, args: string[], opts:
   return runTaskCommand(command.cmd, command.args, opts);
 }
 
+function runSandboxAuthorityTaskCommand(
+  authority: SandboxAuthorityEvidenceV1,
+  cmd: string,
+  args: string[],
+  opts: { cwd?: string } = {}
+): string {
+  const command = commandForSandboxAuthority(authority, cmd, args);
+  return runTaskCommand(command.cmd, command.args, opts);
+}
+
+function runSandboxAuthoritySafeCommand(
+  authority: SandboxAuthorityEvidenceV1,
+  args: string[]
+): string {
+  const command = commandForSandboxAuthority(authority, 'docker', args);
+  return runSafe(command.cmd, command.args);
+}
+
 // `docker run` args for mounting a tool's containerMount as an in-container
 // tmpfs. containerMount is an in-container path, so it is NOT engine-converted.
 export function buildTmpfsRunArgs(containerMount: string, tmpfs: { size?: string }): string[] {
@@ -1308,7 +1332,6 @@ export async function create(args: string[]): Promise<void> {
                 : 'SANDBOX_CONTROL_CONTAINER_STILL_EXISTS');
             }
           }
-
           const aliasesFile = ensureSandboxAliasesFile(
             effectiveConfig.home,
             capabilityPlan.aliases
@@ -1384,6 +1407,9 @@ export async function create(args: string[]): Promise<void> {
               container,
               identity: target.workspace
             });
+            const taskSource = target.workspace.mode === 'task-bound'
+              ? assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId)
+              : null;
             prepareSandboxWorkspaceMountTargets(worktree);
             if (previousCutoverSnapshot) {
               assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
@@ -1406,7 +1432,7 @@ export async function create(args: string[]): Promise<void> {
               branch,
               identity: target.workspace,
               engine,
-              replacementLease
+              replacementLease,
             });
             hostShellConfig = prepareHostShellConfig({
               home: effectiveConfig.home,
@@ -1423,10 +1449,7 @@ export async function create(args: string[]): Promise<void> {
               ...(target.workspace.mode === 'task-bound' ? { runtimeDir: control.runtimeDir } : {}),
               ...(target.workspace.mode === 'task-bound'
                 ? {
-                  taskSources: [assertSandboxTaskSource(
-                    effectiveConfig.repoRoot,
-                    target.workspace.taskId
-                  )],
+                  taskSources: [taskSource!],
                   taskId: target.workspace.taskId
                 }
                 : {})
@@ -1481,8 +1504,11 @@ export async function create(args: string[]): Promise<void> {
             const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
 
             let createdContainerRef: string | null = null;
+            let creationAuthority: SandboxAuthorityEvidenceV1 | null = null;
             try {
-              const dockerRunId = runEngineTaskCommand(engine, 'docker', [
+              creationAuthority = captureSandboxAuthority(engine);
+              commandForSandboxAuthority(creationAuthority, 'docker');
+              const dockerRunId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
               'run',
               '-d',
               '--init',
@@ -1512,6 +1538,8 @@ export async function create(args: string[]): Promise<void> {
               'AGENT_INFRA_CONTROL_DIR=/run/agent-infra/control',
               '-e',
               'AGENT_INFRA_CONTROL_STATUS_DIR=/run/agent-infra/control-status',
+              '-e',
+              `AGENT_INFRA_CONTROL_ROOT_ID=${control.controlRootId}`,
               ...(target.workspace.mode === 'task-bound'
                 ? ['-e', 'AGENT_INFRA_RUNTIME_DIR=/run/agent-infra/runtime']
                 : []),
@@ -1537,11 +1565,11 @@ export async function create(args: string[]): Promise<void> {
               effectiveConfig.imageName
               ]);
               createdContainerRef = dockerRunId.trim();
-              const containerId = runEngineTaskCommand(engine, 'docker', [
+              const containerId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
                 'inspect', '--format', '{{.Id}}', dockerRunId.trim()
               ]).trim();
               if (!containerId) throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
-              const rawContainerLabels = runEngineTaskCommand(engine, 'docker', [
+              const rawContainerLabels = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
                 'inspect', '--format', '{{json .Config.Labels}}', containerId
               ]).trim();
               let inspectedLabels: unknown;
@@ -1566,10 +1594,18 @@ export async function create(args: string[]): Promise<void> {
               for (const [key, expected] of Object.entries(expectedLabels)) {
                 if (labels[key] !== expected) throw new Error('SANDBOX_CONTROL_CONTAINER_IDENTITY_MISMATCH');
               }
+              const authorityEvidence = captureSandboxAuthority(engine, {
+                route: creationAuthority,
+                lockDomain: creationAuthority.lockDomain
+              });
+              if (verifySandboxAuthority(creationAuthority, authorityEvidence).state !== 'verified') {
+                throw new Error('SANDBOX_AUTHORITY_DRIFT_DURING_CREATE');
+              }
               finalizeSandboxControlManifest(control, {
                 engine,
                 id: containerId,
-                labels: expectedLabels
+                labels: expectedLabels,
+                authorityEvidence
               });
               replacementLease.clearQuiescing();
               await startSandboxControlBroker(effectiveConfig.repoRoot, control.manifestPath);
@@ -1580,8 +1616,13 @@ export async function create(args: string[]): Promise<void> {
               createdTmpfsSeedPlan = tmpfsSeedPlan;
             } catch (error) {
               if (createdContainerRef) {
-                runSafeEngine(engine, 'docker', ['stop', createdContainerRef]);
-                runSafeEngine(engine, 'docker', ['rm', createdContainerRef]);
+                if (creationAuthority) {
+                  runSandboxAuthoritySafeCommand(creationAuthority, ['stop', createdContainerRef]);
+                  runSandboxAuthoritySafeCommand(creationAuthority, ['rm', createdContainerRef]);
+                } else {
+                  runSafeEngine(engine, 'docker', ['stop', createdContainerRef]);
+                  runSafeEngine(engine, 'docker', ['rm', createdContainerRef]);
+                }
               }
               if (!hadExistingControlRoot) removeDirRecursive(control.root);
               if (replacementCutover) {

package/lib/sandbox/commands/ls.ts

@@ -11,6 +11,7 @@ import { detectEngine } from '../engine.ts';
 import { formatTable } from '../../table.ts';
 import { loadShortIdByTaskId } from '../../task/short-id.ts';
 import { fetchSandboxRows } from './list-running.ts';
+import { readSandboxControlStatusForRow } from './control-status.ts';
 
 export { containerListFormat, parseLabels } from './list-running.ts';
 
@@ -88,6 +89,12 @@ export function ls(args: string[] = []): void {
       process.stdout.write(`  ${line}\n`);
     }
     process.stdout.write(`  Total: ${ordered.length} containers\n`);
+    for (const row of ordered) {
+      const controlStatus = readSandboxControlStatusForRow(config, row);
+      process.stdout.write(
+        `  ${row.name}: health=${controlStatus?.state ?? 'unavailable'} task-view=${controlStatus?.taskView.state ?? 'unavailable'}\n`
+      );
+    }
     if (tableRows.some((r) => r.shortId === '-')) {
       process.stdout.write(
         `  SHORT '-' = no active task bound; that sandbox is free to remove with 'ai sandbox rm <branch>'.\n`