@fitlab-ai/agent-infra 0.9.0 → 0.9.2

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

@@ -0,0 +1,378 @@
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { isAgentClientId } from '../agent-clients/types.ts';
+import {
+  listAgentClientAdapters,
+  listInstalledAgentClientAdapters
+} from '../agent-clients/registry.ts';
+import { hostJoin } from './engines/wsl2-paths.ts';
+import type { AgentClientAdapter } from '../agent-clients/adapter.ts';
+import type { AgentClientState } from '../agent-clients/types.ts';
+import type {
+  AgentClientSandboxRecoveryCheck,
+  AgentClientSandboxHook,
+  AgentClientSandboxHookContext,
+  AgentClientSandboxHookResult,
+  SandboxAlias,
+  SandboxHookCommand,
+  SandboxHookCommandResult,
+  SandboxHookPhase,
+  SandboxHookStatus,
+  SandboxTool
+} from './tool-types.ts';
+
+const DEFAULT_SANDBOX_HOOK_TIMEOUT_MS = 30_000;
+
+type SandboxCapabilityConfig = Readonly<{
+  home: string;
+  project: string;
+  tools: readonly string[];
+  customTools?: readonly SandboxTool[];
+  agentClientState?: AgentClientState;
+}>;
+
+type SandboxRuntimeCapabilityProjection = Readonly<{
+  tools: readonly Readonly<Record<string, unknown>>[];
+  selectedAgentClients: readonly string[];
+  hooks: readonly Readonly<{
+    adapterId: string;
+    id: string;
+    phase: SandboxHookPhase;
+    timeoutMs: number;
+  }>[];
+  recoveryChecks: readonly Readonly<{
+    adapterId: string;
+    id: string;
+    when?: AgentClientSandboxRecoveryCheck['when'];
+    probe: AgentClientSandboxRecoveryCheck['probe'];
+    finding: Readonly<{
+      repairKind: AgentClientSandboxRecoveryCheck['finding']['repairKind'];
+      path?: string;
+    }>;
+    repair?: AgentClientSandboxRecoveryCheck['repair'];
+  }>[];
+}>;
+
+type PlannedAgentClientRecoveryCheck = Readonly<{
+  adapterId: string;
+  check: AgentClientSandboxRecoveryCheck;
+}>;
+
+type SandboxCapabilityPlan = Readonly<{
+  tools: readonly SandboxTool[];
+  selectedAgentClients: readonly AgentClientAdapter[];
+  hooksByPhase: Readonly<Record<SandboxHookPhase, readonly AgentClientSandboxHook[]>>;
+  recoveryChecks: readonly PlannedAgentClientRecoveryCheck[];
+  aliases: readonly SandboxAlias[];
+  imageSignature: string;
+  runtimeSignature: string;
+  runtimeProjection: SandboxRuntimeCapabilityProjection;
+  cleanupInventory: readonly SandboxTool[];
+}>;
+
+type HookExecutionResult = Readonly<{
+  hookId: string;
+  phase: SandboxHookPhase;
+  status: SandboxHookStatus;
+  message?: string;
+}>;
+
+type TimerHandle = ReturnType<typeof setTimeout> | unknown;
+
+function agentInfraTool(home: string): SandboxTool {
+  return {
+    id: 'agent-infra',
+    name: 'agent-infra CLI',
+    install: { type: 'npm', cmd: '@fitlab-ai/agent-infra@latest' },
+    sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'agent-infra'),
+    containerMount: '/home/devuser/.agent-infra-cli',
+    versionCmd: 'ai version --raw',
+    setupHint: 'Provides the ai and agent-infra CLI commands inside the sandbox.'
+  };
+}
+
+function compatAgentClientState(tools: readonly string[]): AgentClientState {
+  return Object.fromEntries(
+    listAgentClientAdapters().map((adapter) => [
+      adapter.id,
+      {
+        enabled: true,
+        installInSandbox: tools.includes(adapter.id)
+      }
+    ])
+  ) as AgentClientState;
+}
+
+function stableValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(stableValue);
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nested]) => [key, stableValue(nested)])
+    );
+  }
+  return value;
+}
+
+function runtimeToolProjection(tool: SandboxTool): Readonly<Record<string, unknown>> {
+  return stableValue({
+    id: tool.id,
+    install: tool.install,
+    containerMount: tool.containerMount,
+    versionCmd: tool.versionCmd,
+    envVars: tool.envVars ?? {},
+    hostPreSeedFiles: (tool.hostPreSeedFiles ?? []).map(({ sandboxName }) => ({ sandboxName })),
+    hostPreSeedDirs: (tool.hostPreSeedDirs ?? []).map(({ sandboxSubdir }) => ({ sandboxSubdir })),
+    pathRewriteFiles: tool.pathRewriteFiles ?? [],
+    hostLiveMounts: (tool.hostLiveMounts ?? []).map(({ containerSubpath }) => ({ containerSubpath })),
+    postSetupCmds: tool.postSetupCmds ?? [],
+    tmpfs: tool.tmpfs ?? null
+  }) as Readonly<Record<string, unknown>>;
+}
+
+function hash(value: unknown): string {
+  return createHash('sha256').update(JSON.stringify(stableValue(value))).digest('hex');
+}
+
+function assertUniqueTools(tools: readonly SandboxTool[]): void {
+  const seen = new Set<string>();
+  for (const tool of tools) {
+    if (seen.has(tool.id)) {
+      throw new Error(`Duplicate sandbox tool id "${tool.id}"`);
+    }
+    seen.add(tool.id);
+  }
+}
+
+function hooksByPhase(
+  adapters: readonly AgentClientAdapter[]
+): SandboxCapabilityPlan['hooksByPhase'] {
+  const phases: SandboxHookPhase[] = [
+    'prepare',
+    'before-container-create',
+    'after-container-start',
+    'before-enter'
+  ];
+  return Object.freeze(Object.fromEntries(
+    phases.map((phase) => [
+      phase,
+      Object.freeze(adapters.flatMap((adapter) =>
+        adapter.sandbox.hooks.filter((hook) => hook.phase === phase)
+      ))
+    ])
+  ) as Record<SandboxHookPhase, readonly AgentClientSandboxHook[]>);
+}
+
+function createSandboxCapabilityPlan(
+  config: SandboxCapabilityConfig
+): SandboxCapabilityPlan {
+  const state = config.agentClientState ?? compatAgentClientState(config.tools);
+  const selectedAgentClients = listInstalledAgentClientAdapters(state);
+  const context = { home: config.home, project: config.project };
+  const selectedTools = selectedAgentClients.map((adapter) =>
+    adapter.sandbox.createTool(context)
+  );
+  const allClientTools = listAgentClientAdapters().map((adapter) =>
+    adapter.sandbox.createTool(context)
+  );
+  const customById = new Map((config.customTools ?? []).map((tool) => [tool.id, tool]));
+  if (customById.size !== (config.customTools ?? []).length) {
+    throw new Error('Duplicate sandbox tool id in customTools');
+  }
+  for (const id of customById.keys()) {
+    if (id === 'agent-infra' || isAgentClientId(id)) {
+      throw new Error(`Custom sandbox tool id "${id}" collides with a built-in tool`);
+    }
+  }
+
+  const nonClientTools: SandboxTool[] = [];
+  const selectedCustomTools: SandboxTool[] = [];
+  for (const id of config.tools) {
+    if (isAgentClientId(id)) continue;
+    if (id === 'agent-infra') {
+      if (!nonClientTools.some((tool) => tool.id === id)) {
+        nonClientTools.push(agentInfraTool(config.home));
+      }
+      continue;
+    }
+    const custom = customById.get(id);
+    if (!custom) {
+      throw new Error(`Unknown sandbox tool: ${id}`);
+    }
+    selectedCustomTools.push(custom);
+  }
+
+  const tools = Object.freeze([...nonClientTools, ...selectedTools, ...selectedCustomTools]);
+  assertUniqueTools(tools);
+  const phaseHooks = hooksByPhase(selectedAgentClients);
+  const hookProjection = selectedAgentClients.flatMap((adapter) =>
+    adapter.sandbox.hooks.map((hook) => ({
+      adapterId: adapter.id,
+      id: hook.id,
+      phase: hook.phase,
+      timeoutMs: hook.timeoutMs ?? DEFAULT_SANDBOX_HOOK_TIMEOUT_MS
+    }))
+  );
+  const recoveryChecks = Object.freeze(selectedAgentClients.flatMap((adapter) =>
+    (adapter.sandbox.recoveryChecks ?? []).map((check) => Object.freeze({
+      adapterId: adapter.id,
+      check
+    }))
+  ));
+  const recoveryCheckProjection = Object.freeze(recoveryChecks.map(({ adapterId, check }) =>
+    Object.freeze({
+      adapterId,
+      id: check.id,
+      ...(check.when === undefined ? {} : { when: check.when }),
+      probe: check.probe,
+      finding: Object.freeze({
+        repairKind: check.finding.repairKind,
+        ...(check.finding.path === undefined ? {} : { path: check.finding.path })
+      }),
+      ...(check.repair === undefined ? {} : { repair: check.repair })
+    })
+  ));
+  const runtimeProjection = Object.freeze({
+    tools: Object.freeze(tools.map(runtimeToolProjection)),
+    selectedAgentClients: Object.freeze(selectedAgentClients.map((adapter) => adapter.id)),
+    hooks: Object.freeze(hookProjection),
+    recoveryChecks: recoveryCheckProjection
+  });
+  const cleanupInventory = Object.freeze([
+    agentInfraTool(config.home),
+    ...allClientTools,
+    ...customById.values()
+  ]);
+  assertUniqueTools(cleanupInventory);
+
+  return Object.freeze({
+    tools,
+    selectedAgentClients,
+    hooksByPhase: phaseHooks,
+    recoveryChecks,
+    aliases: Object.freeze(
+      listAgentClientAdapters().flatMap((adapter) => adapter.sandbox.aliases)
+    ),
+    imageSignature: hash(tools.map(({ id, install }) => ({ id, install }))),
+    runtimeSignature: hash(runtimeProjection),
+    runtimeProjection,
+    cleanupInventory
+  });
+}
+
+function timeoutStatus(phase: SandboxHookPhase): SandboxHookStatus {
+  if (phase === 'before-enter') return 'warning';
+  return 'fatal';
+}
+
+async function runSandboxHooks({
+  hooks,
+  phase,
+  context,
+  runCommand = async () => {
+    throw new Error('Sandbox hook command runner is unavailable');
+  },
+  scheduleTimeout = (callback, timeoutMs) => setTimeout(callback, timeoutMs),
+  clearScheduledTimeout = (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>)
+}: {
+  hooks: readonly AgentClientSandboxHook[];
+  phase: SandboxHookPhase;
+  context: Omit<AgentClientSandboxHookContext, 'signal' | 'runCommand'>;
+  runCommand?: (
+    command: SandboxHookCommand,
+    options: { signal: AbortSignal; timeoutMs: number }
+  ) => Promise<SandboxHookCommandResult>;
+  scheduleTimeout?: (callback: () => void, timeoutMs: number) => TimerHandle;
+  clearScheduledTimeout?: (handle: TimerHandle) => void;
+}): Promise<HookExecutionResult[]> {
+  const results: HookExecutionResult[] = [];
+  for (const hook of hooks) {
+    if (hook.phase !== phase) continue;
+    const timeoutMs = hook.timeoutMs ?? DEFAULT_SANDBOX_HOOK_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    let timer: TimerHandle;
+    const timeout = new Promise<AgentClientSandboxHookResult>((resolve) => {
+      timer = scheduleTimeout(() => {
+        timedOut = true;
+        controller.abort();
+        resolve({
+          status: timeoutStatus(phase),
+          message: `Sandbox hook '${hook.id}' timed out after ${timeoutMs}ms.`
+        });
+      }, timeoutMs);
+    });
+    let result: AgentClientSandboxHookResult;
+    try {
+      const execution = Promise.resolve().then(() => hook.run({
+        ...context,
+        signal: controller.signal,
+        runCommand: (command) => runCommand(command, {
+          signal: controller.signal,
+          timeoutMs
+        })
+      }));
+      result = await Promise.race([execution, timeout]);
+    } catch (error) {
+      result = {
+        status: timeoutStatus(phase),
+        message: error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      clearScheduledTimeout(timer!);
+    }
+    results.push({
+      hookId: hook.id,
+      phase,
+      status: result.status,
+      ...(result.message ? { message: result.message } : {})
+    });
+    if (timedOut || result.status === 'fatal' || result.status === 'hard-failure') {
+      break;
+    }
+  }
+  return results;
+}
+
+function runBoundedSandboxHookCommand(
+  command: SandboxHookCommand,
+  options: { signal: AbortSignal; timeoutMs: number }
+): Promise<SandboxHookCommandResult> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      command.command,
+      [...(command.args ?? [])],
+      {
+        cwd: command.cwd,
+        env: command.env,
+        encoding: 'utf8',
+        signal: options.signal,
+        timeout: options.timeoutMs
+      },
+      (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve({ stdout: stdout.trim() });
+      }
+    );
+  });
+}
+
+export {
+  DEFAULT_SANDBOX_HOOK_TIMEOUT_MS,
+  createSandboxCapabilityPlan,
+  runBoundedSandboxHookCommand,
+  runSandboxHooks
+};
+export type {
+  HookExecutionResult,
+  SandboxCapabilityConfig,
+  SandboxCapabilityPlan,
+  PlannedAgentClientRecoveryCheck,
+  SandboxRuntimeCapabilityProjection
+};

package/lib/sandbox/build-proxy.ts

@@ -0,0 +1,94 @@
+import semver from 'semver';
+import { engineDisplayName } from './engine.ts';
+import { runSafeEngine } from './shell.ts';
+
+export const BUILD_PROXY_ENV_KEYS = ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY'] as const;
+export const MIN_BUILD_PROXY_DOCKER_VERSION = '20.10.0';
+export const MIN_BUILD_PROXY_BUILDKIT_VERSION = '0.9.0';
+
+export type BuildProxyPlan = {
+  args: string[];
+  env: NodeJS.ProcessEnv;
+  redactionValues: string[];
+};
+
+type EngineRunSafeFn = (engine: string, cmd: string, args: string[]) => string;
+
+export function prepareBuildProxy(
+  enabled: boolean,
+  hostEnv: NodeJS.ProcessEnv,
+  engine: string
+): BuildProxyPlan {
+  const env = { ...hostEnv };
+  if (!enabled) {
+    return { args: [], env, redactionValues: [] };
+  }
+
+  const entries = BUILD_PROXY_ENV_KEYS.flatMap((key) => {
+    const value = hostEnv[key]?.trim();
+    return value ? [[key, value] as const] : [];
+  });
+  if (entries.length === 0) {
+    throw new Error(
+      `No non-empty build proxy variables are set. Configure one of: ${BUILD_PROXY_ENV_KEYS.join(', ')}.`
+    );
+  }
+
+  for (const [key, value] of entries) env[key] = value;
+  if (engine === 'wsl2') {
+    const existing = (env.WSLENV ?? '').split(':').filter(Boolean);
+    env.WSLENV = [...new Set([...existing, ...entries.map(([key]) => key)])].join(':');
+  }
+
+  return {
+    args: entries.flatMap(([key]) => ['--secret', `id=${key},env=${key}`]),
+    env,
+    redactionValues: entries.map(([, value]) => value)
+  };
+}
+
+function parsedVersion(raw: string): string | null {
+  return semver.coerce(raw.trim())?.version ?? null;
+}
+
+export function assertBuildProxyCompatibility(
+  engine: string,
+  runSafeEngineFn: EngineRunSafeFn = runSafeEngine
+): void {
+  const dockerRaw = runSafeEngineFn(engine, 'docker', ['version', '--format', '{{.Server.Version}}']);
+  const dockerVersion = parsedVersion(dockerRaw);
+  if (!dockerVersion || !semver.gte(dockerVersion, MIN_BUILD_PROXY_DOCKER_VERSION)) {
+    throw new Error(
+      `Build proxy requires Docker Engine ${MIN_BUILD_PROXY_DOCKER_VERSION} or newer; `
+      + `observed ${dockerVersion ?? 'an unparseable version'}.`
+    );
+  }
+
+  const buildxRaw = runSafeEngineFn(engine, 'docker', ['buildx', 'inspect', '--bootstrap']);
+  const versions = [...buildxRaw.matchAll(/BuildKit(?:\s+version)?:\s*v?(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/gi)]
+    .map((match) => parsedVersion(match[1] ?? ''))
+    .filter((version): version is string => version !== null);
+  if (versions.length === 0) {
+    throw new Error(
+      `Build proxy requires BuildKit ${MIN_BUILD_PROXY_BUILDKIT_VERSION} or newer, `
+      + 'but the active builder version could not be determined.'
+    );
+  }
+  const oldVersion = versions.find((version) => !semver.gte(version, MIN_BUILD_PROXY_BUILDKIT_VERSION));
+  if (oldVersion) {
+    throw new Error(
+      `Build proxy observed BuildKit ${oldVersion}; version ${MIN_BUILD_PROXY_BUILDKIT_VERSION} or newer is required.`
+    );
+  }
+}
+
+export function redactBuildProxyValues(text: string, values: readonly string[]): string {
+  return [...new Set(values.filter(Boolean))]
+    .sort((left, right) => right.length - left.length)
+    .reduce((result, value) => result.replaceAll(value, '[REDACTED_BUILD_PROXY]'), text);
+}
+
+export function buildProxyFailureHint(engine: string): string {
+  return `Build-step proxy inheritance is enabled for ${engineDisplayName(engine)}. `
+    + 'Image pulls and Dockerfile FROM resolution use the Docker daemon or builder proxy configuration.';
+}

package/lib/sandbox/clipboard/linux.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import type { ExecFileSyncOptions } from 'node:child_process';
+import { removeDirRecursive } from '../../remove-dir.ts';
 
 const PROBE_TIMEOUT_MS = 2_000;
 const READ_IMAGE_TIMEOUT_MS = 5_000;
@@ -26,7 +27,7 @@ export function createLinuxClipboardAdapter({
   execToFileFn = execToFile,
   mkdtempFn = fs.mkdtempSync,
   readFileFn = fs.readFileSync,
-  rmFn = fs.rmSync
+  rmFn = removeDirRecursive as typeof fs.rmSync
 }: {
   env?: NodeJS.ProcessEnv;
   execFn?: ExecFn;