@fitlab-ai/agent-infra 0.9.1 → 0.9.2

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

@@ -0,0 +1,70 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+
+const claudeCodeAdapter = defineAgentClientAdapter({
+  id: 'claude-code',
+  displayName: 'Claude Code',
+  invocation: '/${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'compatible' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'integrated' },
+    subagents: { level: 'experimental' },
+    orchestration: { level: 'experimental' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  project: {
+    ownedPathPrefixes: ['.claude/'],
+    managed: ['.claude/commands/', '.claude/agents/'],
+    merged: ['.claude/settings.json'],
+    ejected: [],
+    seedCommands: [{
+      templates: {
+        en: '.claude/commands/update-agent-infra.en.md',
+        'zh-CN': '.claude/commands/update-agent-infra.zh-CN.md'
+      },
+      target: '.claude/commands/update-agent-infra.md'
+    }]
+  },
+  sandbox: {
+    createTool: ({ home, project }) => ({
+      id: 'claude-code',
+      name: 'Claude Code',
+      install: { type: 'npm', cmd: '@anthropic-ai/claude-code@latest' },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
+      containerMount: '/home/devuser/.claude',
+      versionCmd: 'claude --version',
+      setupHint: 'Authenticates via host credentials live-mounted at ~/.claude/.credentials.json',
+      envVars: { CLAUDE_CONFIG_DIR: '/home/devuser/.claude' },
+      hostPreSeedDirs: [
+        { hostDir: hostJoin(home, '.claude', 'plugins'), sandboxSubdir: 'plugins' }
+      ],
+      pathRewriteFiles: [
+        'plugins/installed_plugins.json',
+        'plugins/known_marketplaces.json'
+      ],
+      hostLiveMounts: [
+        {
+          hostPath: hostJoin(
+            home,
+            '.agent-infra',
+            'credentials',
+            project,
+            'claude-code',
+            '.credentials.json'
+          ),
+          containerSubpath: '.credentials.json'
+        }
+      ]
+    }),
+    aliases: [
+      { name: 'claude-yolo', command: 'claude --dangerously-skip-permissions; tput ed' },
+      { name: 'cy', command: 'claude --dangerously-skip-permissions; tput ed' }
+    ],
+    hooks: []
+  }
+});
+
+export { claudeCodeAdapter };

package/lib/agent-clients/adapters/codex-sandbox.ts

@@ -0,0 +1,245 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as toml from 'smol-toml';
+
+import type {
+  AgentClientSandboxHook,
+  AgentClientSandboxRecoveryCheck
+} from '../../sandbox/tool-types.ts';
+
+type JsonObject = Record<string, unknown>;
+
+function isJsonObjectRecord(value: unknown): value is JsonObject {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function resolveHostCatalogPath(value: unknown, hostHomeDir: string): string | null {
+  if (typeof value !== 'string' || value === '') {
+    return null;
+  }
+  let resolved: string;
+  if (value === '~' || value.startsWith('~/') || value.startsWith('~\\')) {
+    resolved = path.join(hostHomeDir, value.slice(1).replace(/^[/\\]+/, ''));
+  } else if (path.isAbsolute(value)) {
+    resolved = value;
+  } else {
+    resolved = path.join(hostHomeDir, '.codex', value);
+  }
+  try {
+    if (!fs.statSync(resolved).isFile()) {
+      return null;
+    }
+    fs.accessSync(resolved, fs.constants.R_OK);
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+
+const CODEX_DISABLED_FEATURE_FLAGS = ['apps', 'enable_mcp_apps'] as const;
+
+function removeCodexMcpServers(sandboxParsed: JsonObject): boolean {
+  if (!Object.hasOwn(sandboxParsed, 'mcp_servers')) {
+    return false;
+  }
+  delete sandboxParsed.mcp_servers;
+  return true;
+}
+
+function inheritDisabledCodexFeatureFlags(
+  sandboxParsed: JsonObject,
+  hostParsed: JsonObject
+): boolean {
+  if (!isJsonObjectRecord(hostParsed.features)) {
+    return false;
+  }
+  if (Object.hasOwn(sandboxParsed, 'features') && !isJsonObjectRecord(sandboxParsed.features)) {
+    return false;
+  }
+
+  let sandboxFeatures = sandboxParsed.features as JsonObject | undefined;
+  let changed = false;
+  for (const key of CODEX_DISABLED_FEATURE_FLAGS) {
+    if (hostParsed.features[key] !== false) {
+      continue;
+    }
+    if (!sandboxFeatures) {
+      sandboxFeatures = {};
+      sandboxParsed.features = sandboxFeatures;
+    }
+    if (sandboxFeatures[key] !== false) {
+      sandboxFeatures[key] = false;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function ensureCodexModelInheritance(
+  toolDir: string,
+  hostHomeDir?: string,
+  containerCodexDir: string = '/home/devuser/.codex'
+): void {
+  if (!hostHomeDir) {
+    return;
+  }
+
+  const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
+  if (!fs.existsSync(hostConfigPath)) {
+    return;
+  }
+
+  let hostParsed: JsonObject;
+  try {
+    hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8')) as JsonObject;
+  } catch {
+    return;
+  }
+
+  const sandboxConfigPath = path.join(toolDir, 'config.toml');
+  // This rewrites sandbox-side TOML and drops comments; the host config stays untouched.
+  let sandboxParsed: JsonObject = {};
+  if (fs.existsSync(sandboxConfigPath)) {
+    try {
+      sandboxParsed = toml.parse(fs.readFileSync(sandboxConfigPath, 'utf8')) as JsonObject;
+    } catch {
+      return;
+    }
+  }
+
+  let changed = removeCodexMcpServers(sandboxParsed);
+  changed = inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) || changed;
+
+  const inheritSpecs: Array<readonly [string, 'string' | 'number']> = [
+    ['model', 'string'],
+    ['model_reasoning_effort', 'string'],
+    ['model_auto_compact_token_limit', 'number']
+  ];
+
+  for (const [key, type] of inheritSpecs) {
+    if (Object.hasOwn(sandboxParsed, key)) {
+      continue;
+    }
+    const value = hostParsed[key];
+    if (type === 'string' && (typeof value !== 'string' || value === '')) {
+      continue;
+    }
+    if (type === 'number' && (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)) {
+      continue;
+    }
+    sandboxParsed[key] = value;
+    changed = true;
+  }
+
+  if (!Object.hasOwn(sandboxParsed, 'model_catalog_json')) {
+    const hostCatalogPath = resolveHostCatalogPath(hostParsed['model_catalog_json'], hostHomeDir);
+    if (hostCatalogPath) {
+      try {
+        const basename = path.basename(hostCatalogPath);
+        const destDir = path.join(toolDir, 'model-catalogs');
+        fs.mkdirSync(destDir, { recursive: true });
+        fs.copyFileSync(hostCatalogPath, path.join(destDir, basename));
+        sandboxParsed['model_catalog_json'] = path.posix.join(
+          containerCodexDir,
+          'model-catalogs',
+          basename
+        );
+        changed = true;
+      } catch {
+        // Copy failed (e.g. permissions): skip catalog, keep scalar inheritance intact.
+      }
+    }
+  }
+
+  if (changed) {
+    fs.writeFileSync(sandboxConfigPath, `${toml.stringify(sandboxParsed)}\n`, 'utf8');
+  }
+}
+
+function ensureCodexWorkspaceTrust(toolDir: string): void {
+  const configPath = path.join(toolDir, 'config.toml');
+  let content = '';
+  if (fs.existsSync(configPath)) {
+    content = fs.readFileSync(configPath, 'utf8');
+  }
+  if (!content.includes('[projects."/workspace"]')) {
+    const entry = '\n[projects."/workspace"]\ntrust_level = "trusted"\n';
+    fs.writeFileSync(configPath, content + entry, 'utf8');
+  }
+}
+
+const codexBeforeContainerCreateHook: AgentClientSandboxHook = {
+  id: 'codex-before-container-create',
+  phase: 'before-container-create',
+  async run(context) {
+    const create = context.create;
+    const entry = create?.resolvedTools.find(({ tool }) => tool.id === 'codex');
+    if (!create || !entry) {
+      return {
+        status: 'fatal',
+        message: 'Codex sandbox hook requires its resolved tool state.'
+      };
+    }
+    ensureCodexModelInheritance(entry.dir, create.hostHome, entry.tool.containerMount);
+    ensureCodexWorkspaceTrust(entry.dir);
+    return { status: 'ready' };
+  }
+};
+
+const codexRecoveryChecks: readonly AgentClientSandboxRecoveryCheck[] = [
+  {
+    id: 'command-available',
+    probe: {
+      script: 'command -v "$1"',
+      args: ['codex']
+    },
+    finding: {
+      repairKind: 'hard-failure',
+      message: 'Codex is not available on PATH inside the sandbox.'
+    }
+  },
+  {
+    id: 'state-writable',
+    probe: {
+      script: 'probe="$1/.agent-infra-codex-state-$$"; trap \'rm -f -- "$probe"\' EXIT; : > "$probe"',
+      args: ['/home/devuser/.codex']
+    },
+    finding: {
+      repairKind: 'permissions',
+      message: 'Codex state directory is not writable by devuser.',
+      path: '/home/devuser/.codex'
+    }
+  },
+  {
+    id: 'prompts-link',
+    when: {
+      script: 'test -d "$1"',
+      args: ['/workspace/.codex/commands']
+    },
+    probe: {
+      script: 'test "$(readlink -- "$1")" = "$2"',
+      args: ['/home/devuser/.codex/prompts', '/workspace/.codex/commands']
+    },
+    finding: {
+      repairKind: 'builtin-link',
+      message: 'Codex prompts link does not point to the workspace commands directory.',
+      path: '/home/devuser/.codex/prompts'
+    },
+    repair: {
+      user: 'devuser',
+      command: 'ln',
+      args: [
+        '-sfn',
+        '/workspace/.codex/commands',
+        '/home/devuser/.codex/prompts'
+      ]
+    }
+  }
+];
+
+export {
+  codexBeforeContainerCreateHook,
+  codexRecoveryChecks,
+  ensureCodexModelInheritance,
+  ensureCodexWorkspaceTrust
+};

package/lib/agent-clients/adapters/codex.ts

@@ -0,0 +1,58 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+import {
+  codexBeforeContainerCreateHook,
+  codexRecoveryChecks
+} from './codex-sandbox.ts';
+
+const codexAdapter = defineAgentClientAdapter({
+  id: 'codex',
+  displayName: 'Codex',
+  invocation: '$${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'compatible' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'integrated' },
+    subagents: { level: 'experimental' },
+    orchestration: { level: 'unsupported' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  project: {
+    ownedPathPrefixes: ['.codex/'],
+    managed: ['.codex/hooks.json', '.codex/agents/'],
+    merged: [],
+    ejected: [],
+    seedCommands: []
+  },
+  sandbox: {
+    createTool: ({ home }) => ({
+      id: 'codex',
+      name: 'Codex',
+      install: { type: 'npm', cmd: '@openai/codex' },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'codex'),
+      containerMount: '/home/devuser/.codex',
+      versionCmd: 'codex --version',
+      setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
+      tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
+      hostLiveMounts: [
+        {
+          hostPath: hostJoin(home, '.codex', 'auth.json'),
+          containerSubpath: 'auth.json'
+        }
+      ],
+      postSetupCmds: [
+        'test -d /workspace/.codex/commands && ln -sfn /workspace/.codex/commands /home/devuser/.codex/prompts || true'
+      ]
+    }),
+    aliases: [
+      { name: 'codex-yolo', command: 'codex --yolo; tput ed' },
+      { name: 'xy', command: 'codex --yolo; tput ed' }
+    ],
+    hooks: [codexBeforeContainerCreateHook],
+    recoveryChecks: codexRecoveryChecks
+  }
+});
+
+export { codexAdapter };

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

@@ -0,0 +1,65 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+
+const geminiCliAdapter = defineAgentClientAdapter({
+  id: 'gemini-cli',
+  displayName: 'Gemini CLI',
+  invocation: '/${projectName}:${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'compatible' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'compatible' },
+    subagents: { level: 'unsupported' },
+    orchestration: { level: 'unsupported' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  project: {
+    ownedPathPrefixes: ['.gemini/'],
+    managed: ['.gemini/commands/'],
+    merged: ['.gemini/settings.json'],
+    ejected: [],
+    seedCommands: [{
+      templates: {
+        en: '.gemini/commands/_project_/update-agent-infra.en.toml',
+        'zh-CN': '.gemini/commands/_project_/update-agent-infra.zh-CN.toml'
+      },
+      target: '.gemini/commands/${projectName}/update-agent-infra.toml'
+    }]
+  },
+  sandbox: {
+    createTool: ({ home }) => ({
+      id: 'gemini-cli',
+      name: 'Gemini CLI',
+      install: { type: 'npm', cmd: '@google/gemini-cli' },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'gemini-cli'),
+      containerMount: '/home/devuser/.gemini',
+      versionCmd: 'gemini --version',
+      setupHint: 'Run gemini inside the container to finish authentication.',
+      hostLiveMounts: [
+        {
+          hostPath: hostJoin(home, '.gemini', 'oauth_creds.json'),
+          containerSubpath: 'oauth_creds.json'
+        }
+      ],
+      hostPreSeedFiles: [
+        {
+          hostPath: hostJoin(home, '.gemini', 'settings.json'),
+          sandboxName: 'settings.json'
+        },
+        {
+          hostPath: hostJoin(home, '.gemini', 'google_accounts.json'),
+          sandboxName: 'google_accounts.json'
+        }
+      ]
+    }),
+    aliases: [
+      { name: 'gemini-yolo', command: 'gemini --yolo; tput ed' },
+      { name: 'gy', command: 'gemini --yolo; tput ed' }
+    ],
+    hooks: []
+  }
+});
+
+export { geminiCliAdapter };

package/lib/agent-clients/adapters/index.ts

@@ -0,0 +1,27 @@
+import { AGENT_CLIENT_IDS } from '../types.ts';
+import type { AgentClientAdapter } from '../adapter.ts';
+import { claudeCodeAdapter } from './claude-code.ts';
+import { codexAdapter } from './codex.ts';
+import { geminiCliAdapter } from './gemini-cli.ts';
+import { opencodeAdapter } from './opencode.ts';
+
+const adaptersById = new Map(
+  [
+    claudeCodeAdapter,
+    codexAdapter,
+    geminiCliAdapter,
+    opencodeAdapter
+  ].map((adapter) => [adapter.id, adapter])
+);
+
+const BUILTIN_AGENT_CLIENT_ADAPTERS: readonly AgentClientAdapter[] = Object.freeze(
+  AGENT_CLIENT_IDS.map((id) => {
+    const adapter = adaptersById.get(id);
+    if (!adapter) {
+      throw new Error(`Missing built-in Agent Client adapter '${id}'`);
+    }
+    return adapter;
+  })
+);
+
+export { BUILTIN_AGENT_CLIENT_ADAPTERS };

package/lib/agent-clients/adapters/opencode.ts

@@ -0,0 +1,66 @@
+import { defineAgentClientAdapter } from '../adapter.ts';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.ts';
+
+const YOLO_PERMISSION = '{"*":"allow","read":"allow","bash":"allow","edit":"allow","webfetch":"allow","external_directory":"allow","doom_loop":"allow"}';
+
+const opencodeAdapter = defineAgentClientAdapter({
+  id: 'opencode',
+  displayName: 'OpenCode',
+  invocation: '/${skillName}',
+  capabilities: {
+    instructions: { level: 'compatible' },
+    skills: { level: 'compatible' },
+    commands: { level: 'integrated' },
+    hooks: { level: 'compatible' },
+    subagents: { level: 'unsupported' },
+    orchestration: { level: 'unsupported' },
+    sandbox: { level: 'integrated' },
+    verification: { level: 'compatible' }
+  },
+  project: {
+    ownedPathPrefixes: ['.opencode/'],
+    managed: ['.opencode/commands/'],
+    merged: [],
+    ejected: [],
+    seedCommands: [{
+      templates: {
+        en: '.opencode/commands/update-agent-infra.en.md',
+        'zh-CN': '.opencode/commands/update-agent-infra.zh-CN.md'
+      },
+      target: '.opencode/commands/update-agent-infra.md'
+    }]
+  },
+  sandbox: {
+    createTool: ({ home }) => ({
+      id: 'opencode',
+      name: 'OpenCode',
+      install: { type: 'npm', cmd: 'opencode-ai' },
+      sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'opencode'),
+      containerMount: '/home/devuser/.local/share/opencode',
+      versionCmd: 'opencode --version',
+      setupHint: 'Configure OpenCode credentials inside the container before first use.',
+      envVars: {
+        OPENCODE_CONFIG: '/home/devuser/.local/share/opencode/opencode.json'
+      },
+      hostLiveMounts: [
+        {
+          hostPath: hostJoin(home, '.local', 'share', 'opencode', 'auth.json'),
+          containerSubpath: 'auth.json'
+        }
+      ]
+    }),
+    aliases: [
+      {
+        name: 'opencode-yolo',
+        command: `OPENCODE_PERMISSION='${YOLO_PERMISSION}' opencode; tput ed`
+      },
+      {
+        name: 'oy',
+        command: `OPENCODE_PERMISSION='${YOLO_PERMISSION}' opencode; tput ed`
+      }
+    ],
+    hooks: []
+  }
+});
+
+export { opencodeAdapter };