@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/process-data/index.js

@@ -9,6 +9,7 @@ import { readAppliedOverlays, repairSnapshot } from './repair.js';
 import { collectGitHubBoundary, resolveGitHubRepository } from './sources.js';
 import { canonicalJsonBytes, createObjectStore, findSnapshot, publishSnapshotV2, verifySnapshot } from './store.js';
 import { createGitHubClient } from '../platform/github-client.js';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from '../internal/cli-route-inventory.js';
 const USAGE = `Usage: ai data <command> [options]
 
 Commands:
@@ -18,6 +19,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;
 function parseArgs(args, valueOptions, booleanOptions) {
     const positionals = [];
     const options = new Map();
@@ -286,6 +288,11 @@ async function cmdData(args) {
         return command ? 0 : 1;
     }
     try {
+        if (!DATA_OPERATIONS.includes(command)) {
+            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/dist/lib/release/workflow.js

@@ -26,7 +26,7 @@ function createPostConfirmation(version, post) {
         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/dist/lib/run/index.js

@@ -7,6 +7,7 @@ import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.js'
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.js';
 import { getSkillRunSpec } from './skills.js';
 import { runHostCommand } from './host.js';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from '../internal/cli-route-inventory.js';
 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
@@ -80,6 +81,10 @@ export function parseRunArgs(args) {
     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)) {
+        throw new Error(`Unsupported run route '${routeSelector}'`);
+    }
     if (spec.kind === 'create') {
         if (taskRef !== null)
             throw new Error("create-task does not accept '--task'");

package/dist/lib/sandbox/commands/control-status.js

@@ -0,0 +1,22 @@
+import { readSandboxControlStatus } from '../control/state.js';
+import { sandboxControlPaths } from '../workspace-view.js';
+export function readSandboxControlStatusForRow(config, row) {
+    if (!row.workspaceMode || row.workspaceMode === 'legacy-invalid')
+        return null;
+    const identity = row.workspaceMode === 'task-bound' && row.taskId
+        ? { mode: 'task-bound', taskId: row.taskId }
+        : { mode: 'branch-only' };
+    const control = sandboxControlPaths({
+        base: config.controlBase,
+        project: config.project,
+        container: row.name,
+        identity
+    });
+    try {
+        return readSandboxControlStatus(control.statusDir);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=control-status.js.map

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

@@ -24,6 +24,7 @@ import { sandboxCoreBindMounts } from '../mounts.js';
 import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTargets, sandboxControlPaths, } from '../workspace-view.js';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
 import { validateSelinuxDisableEnv } from '../engines/selinux.js';
+import { captureSandboxAuthority, commandForSandboxAuthority, verifySandboxAuthority } from '../engines/authority.js';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
 import { ensureSandboxDiscoveryReadmes } from '../readme-scaffold.js';
 import { removeDirRecursive } from '../../remove-dir.js';
@@ -616,6 +617,14 @@ function runEngineTaskCommand(engine, cmd, args, opts = {}) {
     const command = commandForEngine(engine, cmd, args);
     return runTaskCommand(command.cmd, command.args, opts);
 }
+function runSandboxAuthorityTaskCommand(authority, cmd, args, opts = {}) {
+    const command = commandForSandboxAuthority(authority, cmd, args);
+    return runTaskCommand(command.cmd, command.args, opts);
+}
+function runSandboxAuthoritySafeCommand(authority, args) {
+    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, tmpfs) {
@@ -992,6 +1001,9 @@ export async function create(args) {
                                 container,
                                 identity: target.workspace
                             });
+                            const taskSource = target.workspace.mode === 'task-bound'
+                                ? assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId)
+                                : null;
                             prepareSandboxWorkspaceMountTargets(worktree);
                             if (previousCutoverSnapshot) {
                                 assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
@@ -1014,7 +1026,7 @@ export async function create(args) {
                                 branch,
                                 identity: target.workspace,
                                 engine,
-                                replacementLease
+                                replacementLease,
                             });
                             hostShellConfig = prepareHostShellConfig({
                                 home: effectiveConfig.home,
@@ -1031,7 +1043,7 @@ export async function create(args) {
                                 ...(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
                                     }
                                     : {})
@@ -1076,8 +1088,11 @@ export async function create(args) {
                             const hostTz = detectHostTimezone();
                             const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
                             let createdContainerRef = null;
+                            let creationAuthority = null;
                             try {
-                                const dockerRunId = runEngineTaskCommand(engine, 'docker', [
+                                creationAuthority = captureSandboxAuthority(engine);
+                                commandForSandboxAuthority(creationAuthority, 'docker');
+                                const dockerRunId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
                                     'run',
                                     '-d',
                                     '--init',
@@ -1107,6 +1122,8 @@ export async function create(args) {
                                     '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']
                                         : []),
@@ -1128,12 +1145,12 @@ export async function create(args) {
                                     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;
@@ -1160,10 +1177,18 @@ export async function create(args) {
                                     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);
@@ -1175,8 +1200,14 @@ export async function create(args) {
                             }
                             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);

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

@@ -6,6 +6,7 @@ import { detectEngine } from '../engine.js';
 import { formatTable } from '../../table.js';
 import { loadShortIdByTaskId } from '../../task/short-id.js';
 import { fetchSandboxRows } from './list-running.js';
+import { readSandboxControlStatusForRow } from './control-status.js';
 export { containerListFormat, parseLabels } from './list-running.js';
 const USAGE = `Usage: ai sandbox ls
 
@@ -57,6 +58,10 @@ export function ls(args = []) {
             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`);
         }