@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/dist/lib/agent-clients/adapter.js

@@ -0,0 +1,294 @@
+import { AGENT_CLIENT_CAPABILITY_IDS, AGENT_CLIENT_SUPPORT_LEVELS, isAgentClientId } from './types.js';
+import { SANDBOX_HOOK_PHASES } from '../sandbox/tool-types.js';
+const PROJECT_ASSET_CATEGORIES = ['managed', 'merged', 'ejected'];
+const MAX_SANDBOX_HOOK_TIMEOUT_MS = 300_000;
+const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+function freezeRecoveryProbe(id, checkId, value) {
+    if (!value
+        || typeof value.script !== 'string'
+        || value.script.trim() === ''
+        || !Array.isArray(value.args)
+        || value.args.some((arg) => typeof arg !== 'string')
+        || (value.user !== undefined && (typeof value.user !== 'string' || value.user === ''))) {
+        throw new Error(`Agent Client '${id}' recovery check '${checkId}' has an invalid probe`);
+    }
+    return Object.freeze({
+        script: value.script,
+        args: Object.freeze([...value.args]),
+        ...(value.user === undefined ? {} : { user: value.user })
+    });
+}
+function freezeTool(tool) {
+    if (typeof tool.id !== 'string' || !TOOL_ID_PATTERN.test(tool.id)) {
+        throw new Error(`Invalid sandbox tool id: ${String(tool.id)}`);
+    }
+    if (!tool.install?.cmd || !['npm', 'shell'].includes(tool.install.type)) {
+        throw new Error(`Sandbox tool '${tool.id}' has invalid install`);
+    }
+    if (!tool.containerMount.startsWith('/')) {
+        throw new Error(`Sandbox tool '${tool.id}' containerMount must be absolute`);
+    }
+    if (!tool.versionCmd) {
+        throw new Error(`Sandbox tool '${tool.id}' requires versionCmd`);
+    }
+    return Object.freeze({
+        ...tool,
+        install: Object.freeze({ ...tool.install }),
+        ...(tool.envVars ? { envVars: Object.freeze({ ...tool.envVars }) } : {}),
+        ...(tool.hostPreSeedFiles ? {
+            hostPreSeedFiles: Object.freeze(tool.hostPreSeedFiles.map((entry) => Object.freeze({ ...entry })))
+        } : {}),
+        ...(tool.hostPreSeedDirs ? {
+            hostPreSeedDirs: Object.freeze(tool.hostPreSeedDirs.map((entry) => Object.freeze({ ...entry })))
+        } : {}),
+        ...(tool.pathRewriteFiles ? { pathRewriteFiles: Object.freeze([...tool.pathRewriteFiles]) } : {}),
+        ...(tool.hostLiveMounts ? {
+            hostLiveMounts: Object.freeze(tool.hostLiveMounts.map((entry) => Object.freeze({ ...entry })))
+        } : {}),
+        ...(tool.postSetupCmds ? { postSetupCmds: Object.freeze([...tool.postSetupCmds]) } : {}),
+        ...(tool.tmpfs ? {
+            tmpfs: Object.freeze({
+                ...tool.tmpfs,
+                ...(tool.tmpfs.seed ? { seed: Object.freeze([...tool.tmpfs.seed]) } : {})
+            })
+        } : {})
+    });
+}
+function freezeAliases(id, aliases) {
+    const names = new Set();
+    return Object.freeze(aliases.map((alias) => {
+        if (!alias.name || !alias.command || names.has(alias.name)) {
+            throw new Error(`Agent Client '${id}' has invalid or duplicate sandbox alias '${alias.name}'`);
+        }
+        names.add(alias.name);
+        return Object.freeze({ ...alias });
+    }));
+}
+function isProjectRelativeLiteral(value) {
+    if (value.length === 0
+        || value.startsWith('/')
+        || /^[a-zA-Z]:/.test(value)
+        || value.includes('\\')
+        || /[*?[\]{}]/.test(value)) {
+        return false;
+    }
+    return !value.split('/').some((segment) => segment === '..');
+}
+function defineAgentClientAdapter(candidate) {
+    if (!isAgentClientId(candidate.id)) {
+        throw new Error(`Unknown Agent Client ID '${String(candidate.id)}'`);
+    }
+    if (typeof candidate.displayName !== 'string' || candidate.displayName.trim() === '') {
+        throw new Error(`Agent Client '${candidate.id}' requires a display name`);
+    }
+    if (typeof candidate.invocation !== 'string'
+        || candidate.invocation.trim() === ''
+        || /[\r\n]/.test(candidate.invocation)) {
+        throw new Error(`Agent Client '${candidate.id}' requires a single-line invocation`);
+    }
+    const invocationPlaceholders = [
+        ...candidate.invocation.matchAll(/\$\{([^}]+)\}/g)
+    ].map((match) => match[1]);
+    if (!invocationPlaceholders.includes('skillName')
+        || invocationPlaceholders.some((placeholder) => placeholder !== 'skillName' && placeholder !== 'projectName')
+        || candidate.invocation
+            .replaceAll('${skillName}', '')
+            .replaceAll('${projectName}', '')
+            .includes('${')) {
+        throw new Error(`Agent Client '${candidate.id}' has an invalid invocation`);
+    }
+    if (typeof candidate.capabilities !== 'object'
+        || candidate.capabilities === null
+        || Array.isArray(candidate.capabilities)) {
+        throw new Error(`Agent Client '${candidate.id}' has an invalid capability map`);
+    }
+    const capabilityKeys = Object.keys(candidate.capabilities);
+    if (capabilityKeys.length !== AGENT_CLIENT_CAPABILITY_IDS.length
+        || AGENT_CLIENT_CAPABILITY_IDS.some((capability) => !Object.prototype.hasOwnProperty.call(candidate.capabilities, capability))) {
+        throw new Error(`Agent Client '${candidate.id}' has an invalid capability map`);
+    }
+    const capabilities = Object.fromEntries(AGENT_CLIENT_CAPABILITY_IDS.map((capability) => {
+        const support = candidate.capabilities[capability];
+        if (typeof support !== 'object'
+            || support === null
+            || !AGENT_CLIENT_SUPPORT_LEVELS.includes(support.level)) {
+            throw new Error(`Agent Client '${candidate.id}' has invalid support for '${capability}'`);
+        }
+        return [capability, Object.freeze({ level: support.level })];
+    }));
+    if (typeof candidate.project !== 'object'
+        || candidate.project === null
+        || Array.isArray(candidate.project)) {
+        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`);
+    }
+    const paths = ownedPathPrefixes.map((prefix) => {
+        if (typeof prefix !== 'string'
+            || !isProjectRelativeLiteral(prefix)
+            || !prefix.endsWith('/')) {
+            throw new Error(`Agent Client '${candidate.id}' has invalid owned path prefix '${String(prefix)}'`);
+        }
+        return prefix;
+    });
+    if (new Set(paths).size !== paths.length) {
+        throw new Error(`Agent Client '${candidate.id}' has duplicate owned path prefixes`);
+    }
+    const projectAssets = Object.fromEntries(PROJECT_ASSET_CATEGORIES.map((category) => {
+        const values = candidate.project[category];
+        if (!Array.isArray(values)) {
+            throw new Error(`Agent Client '${candidate.id}' has invalid '${category}' project assets`);
+        }
+        const assets = values.map((asset) => {
+            if (typeof asset !== 'string'
+                || !isProjectRelativeLiteral(asset)
+                || !paths.some((prefix) => asset === prefix.slice(0, -1) || asset.startsWith(prefix))) {
+                throw new Error(`Agent Client '${candidate.id}' has invalid '${category}' project asset '${String(asset)}'`);
+            }
+            return asset;
+        });
+        if (new Set(assets).size !== assets.length) {
+            throw new Error(`Agent Client '${candidate.id}' has duplicate '${category}' project assets`);
+        }
+        return [category, Object.freeze(assets)];
+    }));
+    const categorizedAssets = PROJECT_ASSET_CATEGORIES.flatMap((category) => projectAssets[category].map((asset) => ({ asset, category })));
+    const seenAssets = new Map();
+    for (const { asset, category } of categorizedAssets) {
+        const previous = seenAssets.get(asset);
+        if (previous) {
+            throw new Error(`Agent Client '${candidate.id}' project asset '${asset}' overlaps '${previous}' and '${category}'`);
+        }
+        seenAssets.set(asset, category);
+    }
+    if (!Array.isArray(candidate.project.seedCommands)) {
+        throw new Error(`Agent Client '${candidate.id}' has invalid seed commands`);
+    }
+    const seedTargets = new Set();
+    const seedCommands = candidate.project.seedCommands.map((seed) => {
+        if (!seed || typeof seed !== 'object') {
+            throw new Error(`Agent Client '${candidate.id}' has an invalid seed command`);
+        }
+        const placeholders = [
+            ...seed.target.matchAll(/\$\{([^}]+)\}/g)
+        ].map((match) => match[1]);
+        const targetProbe = seed.target.replaceAll('${projectName}', 'project');
+        if (placeholders.some((placeholder) => placeholder !== 'projectName')
+            || targetProbe.includes('${')
+            || !isProjectRelativeLiteral(targetProbe)
+            || !paths.some((prefix) => targetProbe === prefix.slice(0, -1) || targetProbe.startsWith(prefix))
+            || seedTargets.has(seed.target)) {
+            throw new Error(`Agent Client '${candidate.id}' has invalid seed target '${String(seed.target)}'`);
+        }
+        if (!seed.templates
+            || typeof seed.templates.en !== 'string'
+            || typeof seed.templates['zh-CN'] !== 'string'
+            || !isProjectRelativeLiteral(seed.templates.en)
+            || !isProjectRelativeLiteral(seed.templates['zh-CN'])) {
+            throw new Error(`Agent Client '${candidate.id}' has invalid seed templates`);
+        }
+        seedTargets.add(seed.target);
+        return Object.freeze({
+            templates: Object.freeze({ ...seed.templates }),
+            target: seed.target
+        });
+    });
+    if (!candidate.sandbox || typeof candidate.sandbox.createTool !== 'function') {
+        throw new Error(`Agent Client '${candidate.id}' requires a sandbox descriptor`);
+    }
+    const hookIds = new Set();
+    const hooks = Object.freeze(candidate.sandbox.hooks.map((hook) => {
+        if (!hook.id
+            || hookIds.has(hook.id)
+            || !SANDBOX_HOOK_PHASES.includes(hook.phase)
+            || typeof hook.run !== 'function') {
+            throw new Error(`Agent Client '${candidate.id}' has an invalid sandbox hook`);
+        }
+        if (hook.timeoutMs !== undefined
+            && (!Number.isInteger(hook.timeoutMs)
+                || hook.timeoutMs <= 0
+                || hook.timeoutMs > MAX_SANDBOX_HOOK_TIMEOUT_MS)) {
+            throw new Error(`Agent Client '${candidate.id}' hook '${hook.id}' has invalid timeoutMs`);
+        }
+        hookIds.add(hook.id);
+        return Object.freeze({ ...hook });
+    }));
+    const recoveryCheckIds = new Set();
+    if (candidate.sandbox.recoveryChecks !== undefined
+        && !Array.isArray(candidate.sandbox.recoveryChecks)) {
+        throw new Error(`Agent Client '${candidate.id}' has invalid recovery checks`);
+    }
+    const recoveryChecks = Object.freeze((candidate.sandbox.recoveryChecks ?? []).map((check) => {
+        if (!check
+            || typeof check.id !== 'string'
+            || !TOOL_ID_PATTERN.test(check.id)
+            || recoveryCheckIds.has(check.id)) {
+            throw new Error(`Agent Client '${candidate.id}' has an invalid recovery check`);
+        }
+        const probe = freezeRecoveryProbe(candidate.id, check.id, check.probe);
+        const when = check.when === undefined
+            ? undefined
+            : freezeRecoveryProbe(candidate.id, check.id, check.when);
+        if (!check.finding
+            || !['permissions', 'builtin-link', 'hard-failure'].includes(check.finding.repairKind)
+            || typeof check.finding.message !== 'string'
+            || check.finding.message.trim() === ''
+            || (check.finding.path !== undefined
+                && (typeof check.finding.path !== 'string' || !check.finding.path.startsWith('/')))
+            || (check.finding.repairKind === 'permissions'
+                && check.finding.path === undefined)) {
+            throw new Error(`Agent Client '${candidate.id}' recovery check '${check.id}' has an invalid finding`);
+        }
+        let repair;
+        if (check.repair !== undefined) {
+            if (typeof check.repair.user !== 'string'
+                || check.repair.user === ''
+                || typeof check.repair.command !== 'string'
+                || check.repair.command === ''
+                || !Array.isArray(check.repair.args)
+                || check.repair.args.some((arg) => typeof arg !== 'string')) {
+                throw new Error(`Agent Client '${candidate.id}' recovery check '${check.id}' has an invalid repair`);
+            }
+            repair = Object.freeze({
+                user: check.repair.user,
+                command: check.repair.command,
+                args: Object.freeze([...check.repair.args])
+            });
+        }
+        if (check.finding.repairKind === 'builtin-link' && repair === undefined) {
+            throw new Error(`Agent Client '${candidate.id}' recovery check '${check.id}' requires a repair`);
+        }
+        recoveryCheckIds.add(check.id);
+        return Object.freeze({
+            id: check.id,
+            ...(when === undefined ? {} : { when }),
+            probe,
+            finding: Object.freeze({ ...check.finding }),
+            ...(repair === undefined ? {} : { repair })
+        });
+    }));
+    const aliases = freezeAliases(candidate.id, candidate.sandbox.aliases);
+    const createTool = (context) => {
+        const tool = freezeTool(candidate.sandbox.createTool(context));
+        if (tool.id !== candidate.id) {
+            throw new Error(`Agent Client '${candidate.id}' sandbox tool id must match the adapter id`);
+        }
+        return tool;
+    };
+    return Object.freeze({
+        id: candidate.id,
+        displayName: candidate.displayName,
+        invocation: candidate.invocation,
+        capabilities: Object.freeze(capabilities),
+        project: Object.freeze({
+            ownedPathPrefixes: Object.freeze(paths),
+            ...projectAssets,
+            seedCommands: Object.freeze(seedCommands)
+        }),
+        sandbox: Object.freeze({ createTool, aliases, hooks, recoveryChecks })
+    });
+}
+export { defineAgentClientAdapter };
+//# sourceMappingURL=adapter.js.map

package/dist/lib/agent-clients/adapters/claude-code.js

@@ -0,0 +1,62 @@
+import { defineAgentClientAdapter } from '../adapter.js';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+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 };
+//# sourceMappingURL=claude-code.js.map

package/dist/lib/agent-clients/adapters/codex-sandbox.js

@@ -0,0 +1,210 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as toml from 'smol-toml';
+function isJsonObjectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function resolveHostCatalogPath(value, hostHomeDir) {
+    if (typeof value !== 'string' || value === '') {
+        return null;
+    }
+    let resolved;
+    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'];
+function removeCodexMcpServers(sandboxParsed) {
+    if (!Object.hasOwn(sandboxParsed, 'mcp_servers')) {
+        return false;
+    }
+    delete sandboxParsed.mcp_servers;
+    return true;
+}
+function inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) {
+    if (!isJsonObjectRecord(hostParsed.features)) {
+        return false;
+    }
+    if (Object.hasOwn(sandboxParsed, 'features') && !isJsonObjectRecord(sandboxParsed.features)) {
+        return false;
+    }
+    let sandboxFeatures = sandboxParsed.features;
+    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, hostHomeDir, containerCodexDir = '/home/devuser/.codex') {
+    if (!hostHomeDir) {
+        return;
+    }
+    const hostConfigPath = path.join(hostHomeDir, '.codex', 'config.toml');
+    if (!fs.existsSync(hostConfigPath)) {
+        return;
+    }
+    let hostParsed;
+    try {
+        hostParsed = toml.parse(fs.readFileSync(hostConfigPath, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    const sandboxConfigPath = path.join(toolDir, 'config.toml');
+    // This rewrites sandbox-side TOML and drops comments; the host config stays untouched.
+    let sandboxParsed = {};
+    if (fs.existsSync(sandboxConfigPath)) {
+        try {
+            sandboxParsed = toml.parse(fs.readFileSync(sandboxConfigPath, 'utf8'));
+        }
+        catch {
+            return;
+        }
+    }
+    let changed = removeCodexMcpServers(sandboxParsed);
+    changed = inheritDisabledCodexFeatureFlags(sandboxParsed, hostParsed) || changed;
+    const inheritSpecs = [
+        ['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) {
+    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 = {
+    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 = [
+    {
+        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 };
+//# sourceMappingURL=codex-sandbox.js.map

package/dist/lib/agent-clients/adapters/codex.js

@@ -0,0 +1,54 @@
+import { defineAgentClientAdapter } from '../adapter.js';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+import { codexBeforeContainerCreateHook, codexRecoveryChecks } from './codex-sandbox.js';
+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 };
+//# sourceMappingURL=codex.js.map

package/dist/lib/agent-clients/adapters/gemini-cli.js

@@ -0,0 +1,64 @@
+import { defineAgentClientAdapter } from '../adapter.js';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+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 };
+//# sourceMappingURL=gemini-cli.js.map