@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/lib/process-data/types.ts

@@ -0,0 +1,135 @@
+type JsonPrimitive = null | boolean | number | string;
+type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+type Availability<T> =
+  | { state: 'known'; value: T }
+  | { state: 'unknown' | 'unavailable'; reason: string };
+
+type SourceKind = 'local-file' | 'github-rest' | 'operational-report' | 'structured-telemetry';
+
+type PrivacyDisposition =
+  | { state: 'included' }
+  | { state: 'excluded-sensitive'; ruleId: string }
+  | { state: 'unavailable'; reason: string };
+
+type CapturedObject = {
+  sourceKind: SourceKind;
+  sourceIdentity: string;
+  sha256: string;
+  bytes: number;
+  content?: string;
+  disposition?: PrivacyDisposition;
+};
+
+type StoredObjectEvidence = Omit<CapturedObject, 'content'>;
+
+type RestPageEvidence = {
+  index: number;
+  itemCount: number;
+  canonicalSha256: string;
+};
+
+type RestCollectionEvidence = {
+  endpoint: string;
+  requestCount: number;
+  dataPageCount: number;
+  itemCount: number;
+  termination: 'short-page';
+  pages: RestPageEvidence[];
+};
+
+type NormalizedKind =
+  | 'task'
+  | 'artifact'
+  | 'platform-resource'
+  | 'lifecycle-event'
+  | 'review-finding'
+  | 'human-ruling'
+  | 'telemetry'
+  | 'operational-report'
+  | 'missing'
+  | 'conflict';
+
+type NormalizedRecord = {
+  recordId: string;
+  kind: NormalizedKind;
+  sourceIdentity: string;
+  sourceSha256: string;
+  binding?: string;
+  observedAt?: Availability<string>;
+  data?: JsonValue;
+};
+
+type QualityCategory =
+  | 'missing-local'
+  | 'missing-remote'
+  | 'duplicate-identity'
+  | 'binding-conflict'
+  | 'content-mismatch'
+  | 'schema-difference'
+  | 'mutable-remote'
+  | 'unrecoverable'
+  | 'privacy-excluded';
+
+type QualityFinding = {
+  findingId: string;
+  category: QualityCategory;
+  severity: 'info' | 'warning' | 'error';
+  identities: string[];
+  repairable: boolean;
+  reason: string;
+};
+
+type RepairAction = {
+  repairId: string;
+  operation: 'add' | 'supersede' | 'link';
+  sourceRecordId: string;
+  targetRecordId: string;
+  preconditionSha256: string;
+};
+
+type SnapshotManifest = {
+  schema: 'raw-manifest/v1';
+  snapshotId: string;
+  scope: 'all' | 'local' | 'github';
+  repository: string;
+  observedFrom: string;
+  observedTo: string;
+  objects: StoredObjectEvidence[];
+  endpoints: RestCollectionEvidence[];
+  recordCount: number;
+  findingCount: number;
+  repairCount: number;
+  privacyPolicyVersion: 'process-data-privacy/v1';
+  excerptsEnabled: boolean;
+  dispositionCounts: Record<'included' | 'excluded-sensitive' | 'unavailable', number>;
+  manifestSha256: string;
+};
+
+type ProcessDataError = {
+  code: string;
+  message: string;
+  retryable?: boolean;
+};
+
+type ProcessResult<T> = { ok: true; value: T } | { ok: false; error: ProcessDataError };
+
+export type {
+  Availability,
+  CapturedObject,
+  JsonPrimitive,
+  JsonValue,
+  NormalizedKind,
+  NormalizedRecord,
+  PrivacyDisposition,
+  ProcessDataError,
+  ProcessResult,
+  QualityCategory,
+  QualityFinding,
+  RepairAction,
+  RestCollectionEvidence,
+  RestPageEvidence,
+  SnapshotManifest,
+  SourceKind,
+  StoredObjectEvidence
+};

package/lib/run/index.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadServerConfig } from '../server/config.ts';
-import { resolveTaskBranch } from '../sandbox/task-resolver.ts';
+import { resolveSandboxTarget, type SandboxWorkspaceIdentity } from '../sandbox/workspace-identity.ts';
 import { createRunId, runInSandbox, type SandboxRunMetadata } from '../sandbox/capture.ts';
 import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
@@ -19,6 +19,7 @@ export type ParsedRunArgs = {
 export type SandboxRunRequest = {
   taskRef: string;
   branch: string;
+  workspace?: SandboxWorkspaceIdentity;
   command: string[];
   runId?: string;
   recreate?: boolean;
@@ -136,7 +137,6 @@ function resolveActiveTaskIdentity(taskRef: string, repoRoot: string): ActiveTas
 
   if (TASK_ID_RE.test(taskRef)) {
     taskId = taskRef;
-    resolvedTaskRef = loadShortIdByTaskId(repoRoot).get(taskId) ?? taskRef;
   } else {
     const normalized = normalizeShortIdInput(taskRef, { shortIdLength: readShortIdLength(repoRoot) });
     if (normalized.kind !== 'shortId') return null;
@@ -211,7 +211,8 @@ export async function runSkill(args: string[], options: RunSkillOptions = {}): P
   }
 
   const repoRoot = options.repoRoot ?? config?.repoRoot ?? process.cwd();
-  const branch = resolveTaskBranch(parsed.taskRef, repoRoot);
+  const target = resolveSandboxTarget(parsed.taskRef, repoRoot);
+  const branch = target.branch;
   const identity = resolveActiveTaskIdentity(parsed.taskRef, repoRoot);
   const runId = identity ? createRunId() : undefined;
   const writeStdout = options.writeStdout ?? ((chunk: string) => process.stdout.write(chunk));
@@ -222,6 +223,7 @@ export async function runSkill(args: string[], options: RunSkillOptions = {}): P
   const result = await runSandbox({
     taskRef: parsed.taskRef,
     branch,
+    workspace: target.workspace,
     command,
     runId,
     recreate: parsed.recreate

package/lib/run/tui.ts

@@ -1,9 +1,16 @@
 import { renderAgentClientInvocation } from '../agent-clients/invocation.ts';
 import { getAgentClientAdapter } from '../agent-clients/registry.ts';
+import type { AgentClientId } from '../agent-clients/types.ts';
 
-export type TuiName = 'claude' | 'codex' | 'gemini' | 'opencode';
+export type TuiName = 'claude' | 'codex' | 'antigravity' | 'opencode';
 
-const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode']);
+const TUI_AGENT_CLIENT_IDS: Readonly<Record<TuiName, AgentClientId>> = Object.freeze({
+  claude: 'claude-code',
+  codex: 'codex',
+  antigravity: 'antigravity-cli',
+  opencode: 'opencode'
+});
 
 export type CommandConfig = {
   defaultTui?: unknown;
@@ -29,20 +36,15 @@ export function selectTui(
 }
 
 export function renderPrompt(params: { tui: TuiName; skill: string; args: string[] }): string {
-  const suffix = [params.skill, ...params.args].join(' ').trim();
-  if (params.tui === 'codex') {
-    return renderAgentClientInvocation(getAgentClientAdapter('codex').invocation, {
-      skillName: params.skill,
-      args: params.args
-    });
-  }
-  if (params.tui === 'gemini') return `/agent-infra:${suffix}`;
-  return `/${suffix}`;
+  return renderAgentClientInvocation(
+    getAgentClientAdapter(TUI_AGENT_CLIENT_IDS[params.tui]).invocation,
+    { skillName: params.skill, args: params.args }
+  );
 }
 
 export function buildTuiCommand(tui: TuiName, prompt: string): [string, string[]] {
   if (tui === 'claude') return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
-  if (tui === 'gemini') return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+  if (tui === 'antigravity') return ['agy', ['--dangerously-skip-permissions', '--print', prompt]];
   if (tui === 'opencode') return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
   return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
 }

package/lib/sandbox/agent-client-reconciler.ts

@@ -51,6 +51,12 @@ type SandboxRuntimeCapabilityProjection = Readonly<{
     }>;
     repair?: AgentClientSandboxRecoveryCheck['repair'];
   }>[];
+  image: SandboxImageContribution;
+}>;
+
+type SandboxImageContribution = Readonly<{
+  dockerfileFragments: readonly string[];
+  dotfilesExclusions: readonly string[];
 }>;
 
 type PlannedAgentClientRecoveryCheck = Readonly<{
@@ -64,6 +70,7 @@ type SandboxCapabilityPlan = Readonly<{
   hooksByPhase: Readonly<Record<SandboxHookPhase, readonly AgentClientSandboxHook[]>>;
   recoveryChecks: readonly PlannedAgentClientRecoveryCheck[];
   aliases: readonly SandboxAlias[];
+  image: SandboxImageContribution;
   imageSignature: string;
   runtimeSignature: string;
   runtimeProjection: SandboxRuntimeCapabilityProjection;
@@ -147,6 +154,36 @@ function assertUniqueTools(tools: readonly SandboxTool[]): void {
   }
 }
 
+function unique(values: readonly string[]): readonly string[] {
+  return Object.freeze([...new Set(values)]);
+}
+
+function sandboxImageContribution(
+  adapters: readonly AgentClientAdapter[],
+  tools: readonly SandboxTool[]
+): SandboxImageContribution {
+  const homePrefix = '/home/devuser/';
+  const derivedExclusions = tools.map((tool) => {
+    if (!tool.containerMount.startsWith(homePrefix)) {
+      throw new Error(
+        `Agent Client '${tool.id}' container mount must be below ${homePrefix.slice(0, -1)}`
+      );
+    }
+    return tool.containerMount.slice(homePrefix.length);
+  });
+  return Object.freeze({
+    dockerfileFragments: unique(adapters.flatMap((adapter) =>
+      adapter.sandbox.image?.dockerfileFragment
+        ? [adapter.sandbox.image.dockerfileFragment]
+        : []
+    )),
+    dotfilesExclusions: unique([
+      ...derivedExclusions,
+      ...adapters.flatMap((adapter) => adapter.sandbox.image?.dotfilesExclusions ?? [])
+    ])
+  });
+}
+
 function hooksByPhase(
   adapters: readonly AgentClientAdapter[]
 ): SandboxCapabilityPlan['hooksByPhase'] {
@@ -207,6 +244,7 @@ function createSandboxCapabilityPlan(
 
   const tools = Object.freeze([...nonClientTools, ...selectedTools, ...selectedCustomTools]);
   assertUniqueTools(tools);
+  const image = sandboxImageContribution(selectedAgentClients, selectedTools);
   const phaseHooks = hooksByPhase(selectedAgentClients);
   const hookProjection = selectedAgentClients.flatMap((adapter) =>
     adapter.sandbox.hooks.map((hook) => ({
@@ -239,7 +277,8 @@ function createSandboxCapabilityPlan(
     tools: Object.freeze(tools.map(runtimeToolProjection)),
     selectedAgentClients: Object.freeze(selectedAgentClients.map((adapter) => adapter.id)),
     hooks: Object.freeze(hookProjection),
-    recoveryChecks: recoveryCheckProjection
+    recoveryChecks: recoveryCheckProjection,
+    image
   });
   const cleanupInventory = Object.freeze([
     agentInfraTool(config.home),
@@ -256,6 +295,7 @@ function createSandboxCapabilityPlan(
     aliases: Object.freeze(
       listAgentClientAdapters().flatMap((adapter) => adapter.sandbox.aliases)
     ),
+    image,
     imageSignature: hash(tools.map(({ id, install }) => ({ id, install }))),
     runtimeSignature: hash(runtimeProjection),
     runtimeProjection,
@@ -367,12 +407,14 @@ export {
   DEFAULT_SANDBOX_HOOK_TIMEOUT_MS,
   createSandboxCapabilityPlan,
   runBoundedSandboxHookCommand,
-  runSandboxHooks
+  runSandboxHooks,
+  sandboxImageContribution
 };
 export type {
   HookExecutionResult,
   SandboxCapabilityConfig,
   SandboxCapabilityPlan,
+  SandboxImageContribution,
   PlannedAgentClientRecoveryCheck,
   SandboxRuntimeCapabilityProjection
 };

package/lib/sandbox/capture.ts

@@ -11,10 +11,12 @@ import {
   startSandboxContainer,
   type SandboxRow
 } from './commands/list-running.ts';
+import { resolveSandboxTarget, type SandboxWorkspaceIdentity } from './workspace-identity.ts';
 
 export type SandboxCaptureRequest = {
   taskRef: string;
   branch: string;
+  workspace?: SandboxWorkspaceIdentity;
   command: string[];
   timeoutMs?: number;
   recreate?: boolean;
@@ -44,6 +46,7 @@ export type SandboxCaptureOptions = {
   startContainer?: (name: string) => void;
   ensureReady?: (params: {
     branch: string;
+    workspace?: SandboxWorkspaceIdentity;
     row: SandboxRow;
     allowRecreate: boolean;
   }) => Promise<SandboxReadyResult>;
@@ -183,6 +186,8 @@ export async function runInSandbox(
 ): Promise<SandboxCaptureResult> {
   const config = options.engine ? null : loadConfig();
   const engine = options.engine ?? detectEngine(config!);
+  const workspace = request.workspace
+    ?? (config ? resolveSandboxTarget(request.taskRef, config.repoRoot).workspace : undefined);
   const rows =
     options.rows ??
     (() => {
@@ -200,6 +205,7 @@ export async function runInSandbox(
   if (options.ensureReady) {
     container = (await options.ensureReady({
       branch: request.branch,
+      workspace,
       row: found,
       allowRecreate: request.recreate ?? false
     })).container;
@@ -208,11 +214,12 @@ export async function runInSandbox(
       config,
       engine,
       branch: request.branch,
+      workspace,
       row: found,
       allowRecreate: request.recreate,
-      recreate: async (targetBranch) => {
+      recreate: async () => {
         const { create } = await import('./commands/create.ts');
-        await create([targetBranch, '--no-refresh']);
+        await create([request.taskRef, '--no-refresh']);
       }
     })).container;
   } else if (!found.running) {