@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/dist/lib/task/workspace-snapshot.js

@@ -10,15 +10,14 @@ function git(repoRoot, indexFile, args) {
     }
     return result.stdout;
 }
-function captureWorkspaceSnapshot(repoRoot) {
+function captureWorktreeTree(repoRoot, forcedPath) {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-orchestration-index-'));
     const indexFile = path.join(tempDir, 'index');
     try {
         git(repoRoot, indexFile, ['read-tree', 'HEAD']);
         git(repoRoot, indexFile, ['add', '-A', '--', ':/']);
-        const workspace = path.join(repoRoot, '.agents', 'workspace', 'active');
-        if (fs.existsSync(workspace)) {
-            git(repoRoot, indexFile, ['add', '-f', '--', '.agents/workspace/active']);
+        if (forcedPath && fs.existsSync(path.join(repoRoot, forcedPath))) {
+            git(repoRoot, indexFile, ['add', '-f', '--', forcedPath]);
         }
         return git(repoRoot, indexFile, ['write-tree']).trim();
     }
@@ -26,9 +25,22 @@ function captureWorkspaceSnapshot(repoRoot) {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
+function captureWorkspaceSnapshot(repoRoot, taskId) {
+    const workspaceRelative = taskId
+        ? `.agents/workspace/active/${taskId}`
+        : '.agents/workspace/active';
+    return captureWorktreeTree(repoRoot, workspaceRelative);
+}
+function captureRepositorySnapshot(repoRoot) {
+    return {
+        head: git(repoRoot, null, ['rev-parse', 'HEAD']).trim(),
+        headTree: git(repoRoot, null, ['rev-parse', 'HEAD^{tree}']).trim(),
+        worktreeTree: captureWorktreeTree(repoRoot, null)
+    };
+}
 function diffWorkspaceSnapshots(repoRoot, before, after) {
     const output = git(repoRoot, null, ['diff', '--name-only', '-z', before, after]);
     return output.split('\0').filter(Boolean);
 }
-export { captureWorkspaceSnapshot, diffWorkspaceSnapshots };
+export { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots };
 //# sourceMappingURL=workspace-snapshot.js.map

package/lib/agent-clients/adapter.ts

@@ -12,6 +12,7 @@ import {
 } from '../sandbox/tool-types.ts';
 import type {
   AgentClientSandboxRecoveryCheck,
+  AgentClientSandboxImageDescriptor,
   AgentClientSandboxDescriptor,
   SandboxAlias,
   SandboxTool,
@@ -20,6 +21,28 @@ import type {
 
 type AgentClientCapabilities = AgentClientCapabilityMap;
 
+type AgentClientModelSelectionContext =
+  | Readonly<{
+      kind: 'catalog';
+      completeness: 'complete' | 'partial';
+      source: string;
+      models: readonly Readonly<{
+        id: string;
+        reasoningEfforts?: readonly string[];
+      }>[];
+      guidance?: string;
+    }>
+  | Readonly<{
+      kind: 'interactive-only';
+      command: string;
+      guidance: string;
+    }>;
+
+type AgentClientDelegationEvidence = Readonly<{
+  actualModel: 'host-event' | 'unavailable';
+  actualReasoningEffort: 'host-event' | 'spawn-ack' | 'unavailable';
+}>;
+
 type AgentClientSeedCommand = Readonly<{
   templates: Readonly<{
     en: string;
@@ -28,12 +51,21 @@ type AgentClientSeedCommand = Readonly<{
   target: string;
 }>;
 
+type AgentClientCustomCommandDescriptor = Readonly<{
+  target: string;
+  frontmatter: Readonly<Record<string, string | boolean>>;
+  argumentsToken?: string;
+  includeUsage?: boolean;
+  inheritDisableModelInvocation?: boolean;
+}>;
+
 type AgentClientProjectDescriptor = Readonly<{
   ownedPathPrefixes: readonly string[];
   managed: readonly string[];
   merged: readonly string[];
   ejected: readonly string[];
   seedCommands: readonly AgentClientSeedCommand[];
+  customCommand?: AgentClientCustomCommandDescriptor;
 }>;
 
 type AgentClientAdapter = Readonly<{
@@ -41,6 +73,8 @@ type AgentClientAdapter = Readonly<{
   displayName: string;
   invocation: string;
   capabilities: AgentClientCapabilities;
+  modelSelection: AgentClientModelSelectionContext;
+  delegationEvidence: AgentClientDelegationEvidence;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -57,12 +91,59 @@ type AgentClientManifestEntry = Readonly<{
   managed: readonly string[];
   merged: readonly string[];
   ejected: readonly string[];
+  customCommand?: AgentClientCustomCommandDescriptor;
 }>;
 
 const PROJECT_ASSET_CATEGORIES = ['managed', 'merged', 'ejected'] as const;
 const MAX_SANDBOX_HOOK_TIMEOUT_MS = 300_000;
 const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 
+function freezeSandboxImageDescriptor(
+  id: AgentClientId,
+  value: AgentClientSandboxImageDescriptor | undefined
+): AgentClientSandboxImageDescriptor | undefined {
+  if (value === undefined) return undefined;
+  const keys = value && typeof value === 'object' && !Array.isArray(value)
+    ? Object.keys(value)
+    : [];
+  const fragment = value?.dockerfileFragment;
+  const exclusions = value?.dotfilesExclusions;
+  const validExclusion = (entry: unknown): entry is string => {
+    if (
+      typeof entry !== 'string'
+      || entry === ''
+      || entry.startsWith('/')
+      || entry.endsWith('/')
+      || entry.includes('\\')
+      || /[*?[\]]/.test(entry)
+    ) {
+      return false;
+    }
+    return entry.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..');
+  };
+  if (
+    !value
+    || typeof value !== 'object'
+    || Array.isArray(value)
+    || keys.length === 0
+    || keys.some((key) => !['dockerfileFragment', 'dotfilesExclusions'].includes(key))
+    || (fragment !== undefined && (typeof fragment !== 'string' || !TOOL_ID_PATTERN.test(fragment)))
+    || (exclusions !== undefined && (
+      !Array.isArray(exclusions)
+      || exclusions.some((entry) => !validExclusion(entry))
+      || new Set(exclusions).size !== exclusions.length
+    ))
+  ) {
+    throw new Error(`Agent Client '${id}' has an invalid sandbox image descriptor`);
+  }
+  return Object.freeze({
+    ...(fragment === undefined ? {} : { dockerfileFragment: fragment }),
+    ...(exclusions === undefined
+      ? {}
+      : { dotfilesExclusions: Object.freeze([...exclusions]) })
+  });
+}
+
 function freezeRecoveryProbe(
   id: AgentClientId,
   checkId: string,
@@ -211,6 +292,51 @@ function defineAgentClientAdapter(
     })
   ) as AgentClientCapabilities;
 
+  const modelSelection = candidate.modelSelection;
+  if (!modelSelection || typeof modelSelection !== 'object') {
+    throw new Error(`Agent Client '${candidate.id}' has an invalid model-selection context`);
+  }
+  let frozenModelSelection: AgentClientModelSelectionContext;
+  if (modelSelection.kind === 'interactive-only') {
+    if (!modelSelection.command?.trim() || !modelSelection.guidance?.trim()) {
+      throw new Error(`Agent Client '${candidate.id}' has an invalid model-selection context`);
+    }
+    frozenModelSelection = Object.freeze({ ...modelSelection });
+  } else if (
+    modelSelection.kind === 'catalog'
+    && ['complete', 'partial'].includes(modelSelection.completeness)
+    && typeof modelSelection.source === 'string'
+    && modelSelection.source.trim() !== ''
+    && Array.isArray(modelSelection.models)
+  ) {
+    const models = modelSelection.models.map((model) => {
+      if (!model?.id?.trim() || (model.reasoningEfforts && !Array.isArray(model.reasoningEfforts))) {
+        throw new Error(`Agent Client '${candidate.id}' has an invalid model-selection context`);
+      }
+      return Object.freeze({
+        id: model.id,
+        ...(model.reasoningEfforts
+          ? { reasoningEfforts: Object.freeze([...model.reasoningEfforts]) }
+          : {})
+      });
+    });
+    frozenModelSelection = Object.freeze({
+      ...modelSelection,
+      models: Object.freeze(models)
+    });
+  } else {
+    throw new Error(`Agent Client '${candidate.id}' has an invalid model-selection context`);
+  }
+
+  const evidence = candidate.delegationEvidence;
+  if (
+    !evidence
+    || !['host-event', 'unavailable'].includes(evidence.actualModel)
+    || !['host-event', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)
+  ) {
+    throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
+  }
+
   if (
     typeof candidate.project !== 'object'
     || candidate.project === null
@@ -219,8 +345,8 @@ function defineAgentClientAdapter(
     throw new Error(`Agent Client '${candidate.id}' has an invalid project descriptor`);
   }
   const ownedPathPrefixes = candidate.project.ownedPathPrefixes;
-  if (!Array.isArray(ownedPathPrefixes) || ownedPathPrefixes.length === 0) {
-    throw new Error(`Agent Client '${candidate.id}' requires owned path prefixes`);
+  if (!Array.isArray(ownedPathPrefixes)) {
+    throw new Error(`Agent Client '${candidate.id}' has invalid owned path prefixes`);
   }
 
   const paths = ownedPathPrefixes.map((prefix) => {
@@ -325,9 +451,68 @@ function defineAgentClientAdapter(
     });
   });
 
+  let customCommand: AgentClientCustomCommandDescriptor | undefined;
+  if (candidate.project.customCommand !== undefined) {
+    const descriptor = candidate.project.customCommand;
+    const placeholders = typeof descriptor?.target === 'string'
+      ? [...descriptor.target.matchAll(/\$\{([^}]+)\}/g)].map((match) => match[1])
+      : [];
+    const targetProbe = typeof descriptor?.target === 'string'
+      ? descriptor.target.replaceAll('${skillName}', 'skill')
+      : '';
+    const frontmatter = descriptor?.frontmatter;
+    if (
+      !descriptor
+      || typeof descriptor !== 'object'
+      || placeholders.length !== 1
+      || placeholders[0] !== 'skillName'
+      || targetProbe.includes('${')
+      || !isProjectRelativeLiteral(targetProbe)
+      || !paths.some((prefix) => targetProbe.startsWith(prefix))
+      || !frontmatter
+      || typeof frontmatter !== 'object'
+      || Array.isArray(frontmatter)
+      || Object.values(frontmatter).some((value) =>
+        typeof value !== 'string' && typeof value !== 'boolean'
+      )
+      || (
+        descriptor.argumentsToken !== undefined
+        && (
+          typeof descriptor.argumentsToken !== 'string'
+          || descriptor.argumentsToken === ''
+          || /[\r\n]/.test(descriptor.argumentsToken)
+        )
+      )
+      || (
+        descriptor.includeUsage !== undefined
+        && typeof descriptor.includeUsage !== 'boolean'
+      )
+      || (
+        descriptor.inheritDisableModelInvocation !== undefined
+        && typeof descriptor.inheritDisableModelInvocation !== 'boolean'
+      )
+    ) {
+      throw new Error(`Agent Client '${candidate.id}' has an invalid custom command`);
+    }
+    customCommand = Object.freeze({
+      target: descriptor.target,
+      frontmatter: Object.freeze({ ...frontmatter }),
+      ...(descriptor.argumentsToken === undefined
+        ? {}
+        : { argumentsToken: descriptor.argumentsToken }),
+      ...(descriptor.includeUsage === undefined
+        ? {}
+        : { includeUsage: descriptor.includeUsage }),
+      ...(descriptor.inheritDisableModelInvocation === undefined
+        ? {}
+        : { inheritDisableModelInvocation: descriptor.inheritDisableModelInvocation })
+    });
+  }
+
   if (!candidate.sandbox || typeof candidate.sandbox.createTool !== 'function') {
     throw new Error(`Agent Client '${candidate.id}' requires a sandbox descriptor`);
   }
+  const image = freezeSandboxImageDescriptor(candidate.id, candidate.sandbox.image);
   const hookIds = new Set<string>();
   const hooks = Object.freeze(candidate.sandbox.hooks.map((hook) => {
     if (
@@ -441,12 +626,21 @@ function defineAgentClientAdapter(
     displayName: candidate.displayName,
     invocation: candidate.invocation,
     capabilities: Object.freeze(capabilities),
+    modelSelection: frozenModelSelection,
+    delegationEvidence: Object.freeze({ ...evidence }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
-      seedCommands: Object.freeze(seedCommands)
+      seedCommands: Object.freeze(seedCommands),
+      ...(customCommand === undefined ? {} : { customCommand })
     }),
-    sandbox: Object.freeze({ createTool, aliases, hooks, recoveryChecks })
+    sandbox: Object.freeze({
+      createTool,
+      aliases,
+      hooks,
+      recoveryChecks,
+      ...(image === undefined ? {} : { image })
+    })
   });
 }
 
@@ -454,7 +648,10 @@ export { defineAgentClientAdapter };
 export type {
   AgentClientAdapter,
   AgentClientCapabilities,
+  AgentClientCustomCommandDescriptor,
+  AgentClientDelegationEvidence,
   AgentClientManifestEntry,
+  AgentClientModelSelectionContext,
   AgentClientProjectDescriptor,
   AgentClientSeedCommand,
   AgentClientRegistry

package/lib/agent-clients/adapters/antigravity-cli.ts

@@ -0,0 +1,65 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+
+const antigravityCliAdapter = defineAgentClientAdapter({
+  id: 'antigravity-cli',
+  displayName: 'Antigravity CLI',
+  invocation: '/${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'integrated' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'compatible' },
+    subagents: { level: 'unsupported' },
+    orchestration: { level: 'unsupported' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  modelSelection: {
+    kind: 'interactive-only',
+    command: '/model',
+    guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
+  },
+  delegationEvidence: {
+    actualModel: 'unavailable',
+    actualReasoningEffort: 'unavailable'
+  },
+  project: {
+    ownedPathPrefixes: [],
+    managed: [],
+    merged: [],
+    ejected: [],
+    seedCommands: []
+  },
+  sandbox: {
+    createTool: ({ home }) => ({
+      id: 'antigravity-cli',
+      name: 'Antigravity CLI',
+      install: {
+        type: 'shell',
+        cmd: 'curl -fsSL https://antigravity.google/cli/install.sh | bash -s -- --dir /home/devuser/.npm-global/bin'
+      },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'antigravity-cli'),
+      containerMount: '/home/devuser/.gemini',
+      versionCmd: 'agy --version',
+      setupHint: 'Run agy inside the container to finish authentication.',
+      hostPreSeedFiles: [
+        {
+          hostPath: hostJoin(home, '.gemini', 'antigravity-cli', 'keybindings.json'),
+          sandboxName: 'antigravity-cli/keybindings.json'
+        },
+        {
+          hostPath: hostJoin(home, '.gemini', 'config', 'mcp_config.json'),
+          sandboxName: 'config/mcp_config.json'
+        }
+      ]
+    }),
+    aliases: [
+      { name: 'antigravity-yolo', command: 'agy --dangerously-skip-permissions; tput ed' },
+      { name: 'agy-yolo', command: 'agy --dangerously-skip-permissions; tput ed' }
+    ],
+    hooks: []
+  }
+});
+
+export { antigravityCliAdapter };

package/lib/{sandbox/credentials.ts → agent-clients/adapters/claude-code-credentials.ts}

@@ -2,7 +2,8 @@ import { execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { hostJoin } from './engines/wsl2-paths.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+import { redactCommandError } from '../../sandbox/redaction.ts';
 
 type ExecFn = (file: string, args: string[], options?: Record<string, unknown>) => string | Buffer | void;
 type ReadFn = (targetPath: string) => string;
@@ -112,12 +113,6 @@ type CredentialPayload = {
 
 const LOCKED_PATTERN = /errSecInteractionNotAllowed|User interaction is not allowed/i;
 const NOT_FOUND_PATTERN = /errSecItemNotFound|specified item could not be found/i;
-const REDACTION_PATTERNS = [
-  { pattern: /\{[^{}]*"claudeAiOauth"[\s\S]*?\}\s*\}/g, replacement: '[REDACTED credentials blob]' },
-  { pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g, replacement: '[REDACTED claude token]' },
-  { pattern: /gh[psoru]_[A-Za-z0-9]{30,}/g, replacement: '[REDACTED github token]' },
-  { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{20,}/gi, replacement: 'Bearer [REDACTED]' }
-];
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -131,18 +126,8 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : 'unknown error';
 }
 
-export function redactCommandError(text: unknown): string {
-  if (!text || typeof text !== 'string') {
-    return '';
-  }
-
-  return REDACTION_PATTERNS.reduce(
-    (result, { pattern, replacement }) => result.replace(pattern, replacement),
-    text
-  );
-}
-
 export const redactSecurityOutput = redactCommandError;
+export { redactCommandError };
 
 function extractStderrSafely(error: unknown): string {
   const stderr = typeof error === 'object' && error !== null && 'stderr' in error

package/lib/agent-clients/adapters/claude-code-refresh.ts

@@ -0,0 +1,128 @@
+import { homedir } from 'node:os';
+import { parseArgs } from 'node:util';
+import {
+  buildLockedGuidance,
+  discoverProjects,
+  formatCredentialWarnings,
+  formatRemaining,
+  reconcileClaudeCredentials,
+  redactCommandError,
+  validateClaudeCredentialsEnvOverride
+} from './claude-code-credentials.ts';
+import { runProbe } from '../../sandbox/shell.ts';
+
+const USAGE = 'Usage: ai sandbox refresh';
+
+type ReconcileOptions = NonNullable<Parameters<typeof reconcileClaudeCredentials>[1]>;
+
+type RefreshDeps = Partial<ReconcileOptions> & {
+  spawnFn?: typeof runProbe;
+  discoverFn?: typeof discoverProjects;
+  writeStdout?: (chunk: string) => unknown;
+  writeStderr?: (chunk: string) => unknown;
+};
+
+export function probeClaudeStatus(spawnFn: typeof runProbe = runProbe): { ok: boolean; stderr: string; error: string | null } {
+  const result = spawnFn('claude', ['/status'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 30_000
+  });
+  return {
+    ok: result.status === 0,
+    stderr: result.stderr?.toString() ?? '',
+    error: result.error?.message ?? null
+  };
+}
+
+export async function runClaudeCodeRefresh(args: string[], deps: RefreshDeps = {}): Promise<number> {
+  const {
+    spawnFn = runProbe,
+    execFn,
+    readFn,
+    existsFn,
+    writeFn,
+    writeHostFn,
+    discoverFn = discoverProjects,
+    writeStdout = (chunk: string) => process.stdout.write(chunk),
+    writeStderr = (chunk: string) => process.stderr.write(chunk)
+  } = deps;
+
+  if (args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
+    writeStdout(`${USAGE}\n`);
+    return 0;
+  }
+
+  const { positionals } = parseArgs({ args, allowPositionals: true, strict: true });
+  if (positionals.length > 0) {
+    throw new Error(USAGE);
+  }
+  validateClaudeCredentialsEnvOverride();
+
+  const home = homedir();
+  if (!home) {
+    throw new Error('sandbox: home directory is required');
+  }
+
+  const projects = discoverFn(home);
+  if (projects.length === 0) {
+    writeStdout('No project credentials to refresh.\n');
+    return 0;
+  }
+
+  const reconcileOptions = { execFn, readFn, existsFn, writeFn, writeHostFn, projects };
+  let result = reconcileClaudeCredentials(home, reconcileOptions);
+  if (result.status === 'STALE_ACCESS' && result.authoritative === null) {
+    writeStdout('Host credentials appear stale; probing claude /status to trigger refresh...\n');
+    const probe = probeClaudeStatus(spawnFn);
+    if (!probe.ok) {
+      writeStderr(`Probe failed: ${redactCommandError(probe.stderr || probe.error || 'unknown error')}\n`);
+      writeStderr('Run "claude /login" on the host to renew credentials.\n');
+      return 1;
+    }
+    writeStdout('Probe succeeded; re-inspecting host credentials.\n');
+    result = reconcileClaudeCredentials(home, reconcileOptions);
+  }
+
+  if (result.status === 'MISSING') {
+    writeStderr('No Claude Code credentials found on host.\n');
+    writeStderr('Run "claude /login" on the host to authenticate.\n');
+    return 1;
+  }
+
+  if (result.status === 'KEYCHAIN_LOCKED') {
+    writeStderr(`${buildLockedGuidance()}\n`);
+    return 1;
+  }
+
+  if (result.status === 'KEYCHAIN_ERROR') {
+    writeStderr(`Host keychain error: ${redactCommandError(result.detail || 'unknown error')}\n`);
+    writeStderr(`${buildLockedGuidance()}\n`);
+    return 1;
+  }
+
+  if (result.status === 'KEYCHAIN_WRITE_FAILED') {
+    writeStderr(`[host] keychain write failed: ${formatCredentialWarnings(result.warnings) || 'unknown error'}\n`);
+    return 1;
+  }
+
+  if (result.status !== 'OK') {
+    writeStderr('Host credentials still invalid after probe; run "claude /login".\n');
+    return 1;
+  }
+
+  if (result.authoritative && result.authoritative !== 'host' && result.hostWritten) {
+    writeStdout(`[host] reconciled from ${result.authoritative}\n`);
+  }
+
+  for (const project of projects) {
+    const action = result.filesWritten.includes(project) ? 'updated' : 'unchanged';
+    writeStdout(`[${project}] ${action}; expires in ${formatRemaining(result.expiresAt)}\n`);
+  }
+
+  for (const failure of result.fileErrors) {
+    writeStderr(`[${failure.project}] sync failed: ${failure.error}\n`);
+  }
+
+  return result.fileErrors.length > 0 ? 1 : 0;
+}