@fitlab-ai/agent-infra 0.9.12 → 0.9.14

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;
@@ -38,54 +39,94 @@ export type RunSkillOptions = {
   writeStderr?: (chunk: string) => void;
 };
 
-const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>] [--recreate]
+const USAGE = `Usage: ai run --skill <skill> [--task <task-ref>] [--tui <name>] [--recreate] [-- <skill-args...>]
 
 Task skills are scheduled inside the sandbox tmux session; ai run returns once
 the tmux window is created. --recreate authorizes container-only replacement
 when in-place sandbox recovery fails; it is not included in the TUI prompt.
 
 Examples:
-  ai run create-task "describe the task" --tui codex
-  ai run code-task #7 --tui codex --recreate`;
+  ai run --skill create-task "describe the task" --tui codex
+  ai run --skill code-task --task 7 --tui codex --recreate`;
 
-function extractTui(args: string[]): { rest: string[]; tui: string | null } {
-  const rest: string[] = [];
+function optionValue(args: string[], index: number, option: string): string {
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${option} requires a value`);
+  return value;
+}
+
+function extractHostOptions(args: string[]): {
+  positionals: string[];
+  forwarded: string[];
+  skill: string | null;
+  taskRef: string | null;
+  tui: string | null;
+  recreate: boolean;
+} {
+  const positionals: string[] = [];
+  const forwarded: string[] = [];
+  let skill: string | null = null;
+  let taskRef: string | null = null;
   let tui: string | null = null;
+  let recreate = false;
+  let separator = false;
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i] as string;
-    if (arg === '--tui') {
-      const value = args[i + 1];
-      if (!value) throw new Error('--tui requires a value');
-      tui = value;
+    if (separator) {
+      forwarded.push(arg);
+    } else if (arg === '--') {
+      separator = true;
+    } else if (arg === '--skill') {
+      if (skill !== null) throw new Error("duplicate option '--skill'");
+      skill = optionValue(args, i, '--skill');
+      i += 1;
+    } else if (arg === '--task') {
+      if (taskRef !== null) throw new Error("duplicate option '--task'");
+      taskRef = optionValue(args, i, '--task');
       i += 1;
-      continue;
+    } else if (arg === '--tui') {
+      if (tui !== null) throw new Error("duplicate option '--tui'");
+      tui = optionValue(args, i, '--tui');
+      i += 1;
+    } else if (arg === '--recreate') {
+      if (recreate) throw new Error("duplicate option '--recreate'");
+      recreate = true;
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option '${arg}'`);
+    } else {
+      positionals.push(arg);
     }
-    rest.push(arg);
   }
-  return { rest, tui };
+  return { positionals, forwarded, skill, taskRef, tui, recreate };
 }
 
 export function parseRunArgs(args: string[]): ParsedRunArgs {
   if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
     throw new Error(USAGE);
   }
-  const { rest: withRecoveryFlags, tui } = extractTui(args);
-  const recreate = withRecoveryFlags.includes('--recreate');
-  const rest = withRecoveryFlags.filter((arg) => arg !== '--recreate');
-  const [skill = '', maybeTaskRef, ...remaining] = rest;
+  const { positionals, forwarded, skill, taskRef, tui, recreate } = extractHostOptions(args);
+  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');
-    const createArgs = rest.slice(1);
+    const createArgs = [...positionals, ...forwarded];
     if (createArgs.length === 0) throw new Error('create-task requires a description');
     return { skill, taskRef: null, args: createArgs, tui };
   }
-  if (!maybeTaskRef) throw new Error(`${skill} requires a task-ref`);
+  if (positionals.length > 0) {
+    throw new Error('ai run requires --skill and --task; positional host arguments are not supported');
+  }
+  if (taskRef === null) throw new Error(`${skill} requires a task-ref`);
   return {
     skill,
-    taskRef: maybeTaskRef,
-    args: remaining,
+    taskRef,
+    args: forwarded,
     tui,
     ...(recreate ? { recreate: true as const } : {})
   };
@@ -200,8 +241,7 @@ export async function runSkill(args: string[], options: RunSkillOptions = {}): P
   const commandConfig = options.command ?? config?.command ?? {};
   assertAllowedByConfig(parsed.skill, commandConfig);
   const tui = selectTui(parsed.skill, { cliTui: parsed.tui, command: commandConfig });
-  const promptArgs = parsed.taskRef === null ? parsed.args : [parsed.taskRef, ...parsed.args];
-  const prompt = renderPrompt({ tui, skill: parsed.skill, args: promptArgs });
+  const prompt = renderPrompt({ tui, skill: parsed.skill, args: parsed.args });
   const [file, argv] = buildTuiCommand(tui, prompt);
   const command = [file, ...argv];
 

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[] {
@@ -1481,8 +1505,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',
@@ -1537,11 +1564,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 +1593,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 +1615,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`