@fitlab-ai/agent-infra 0.9.1 → 0.9.3

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

@@ -0,0 +1,63 @@
+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' }
+    },
+    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: ['.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/index.js

@@ -0,0 +1,20 @@
+import { AGENT_CLIENT_IDS } from '../types.js';
+import { claudeCodeAdapter } from './claude-code.js';
+import { codexAdapter } from './codex.js';
+import { antigravityCliAdapter } from './antigravity-cli.js';
+import { opencodeAdapter } from './opencode.js';
+const adaptersById = new Map([
+    claudeCodeAdapter,
+    codexAdapter,
+    antigravityCliAdapter,
+    opencodeAdapter
+].map((adapter) => [adapter.id, adapter]));
+const BUILTIN_AGENT_CLIENT_ADAPTERS = 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 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,73 @@
+import { defineAgentClientAdapter } from '../adapter.js';
+import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
+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' }
+    },
+    modelSelection: {
+        kind: 'interactive-only',
+        command: '/models',
+        guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
+    },
+    delegationEvidence: {
+        actualModel: 'unavailable',
+        actualReasoningEffort: 'unavailable'
+    },
+    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 };
+//# sourceMappingURL=opencode.js.map

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

@@ -0,0 +1,215 @@
+import { AGENT_CLIENT_IDS, isAgentClientId } from './types.js';
+class AgentClientConfigError extends Error {
+    code;
+    path;
+    diagnostics;
+    constructor(diagnostic) {
+        super(`${diagnostic.code} at ${diagnostic.path}`);
+        this.name = 'AgentClientConfigError';
+        this.code = diagnostic.code;
+        this.path = diagnostic.path;
+        this.diagnostics = [diagnostic];
+    }
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function fail(code, path) {
+    throw new AgentClientConfigError({ code, path });
+}
+function parseExactText(value, path) {
+    if (typeof value !== 'string' || value.length === 0 || value.trim() !== value) {
+        fail('INVALID_AGENT_CLIENTS', path);
+    }
+    return value;
+}
+function parseOrchestrationPolicy(value, path) {
+    if (!isRecord(value))
+        fail('INVALID_AGENT_CLIENTS', path);
+    const keys = Object.keys(value);
+    if (keys.length !== 2
+        || !hasOwn(value, 'executor')
+        || !hasOwn(value, 'reviewer')) {
+        fail('INVALID_AGENT_CLIENTS', path);
+    }
+    const parseRole = (candidate, rolePath) => {
+        if (!isRecord(candidate)
+            || Object.keys(candidate).length !== 2
+            || !hasOwn(candidate, 'model')
+            || !hasOwn(candidate, 'reasoningEffort')) {
+            fail('INVALID_AGENT_CLIENTS', rolePath);
+        }
+        return Object.freeze({
+            model: parseExactText(candidate.model, `${rolePath}.model`),
+            reasoningEffort: parseExactText(candidate.reasoningEffort, `${rolePath}.reasoningEffort`)
+        });
+    };
+    const executor = parseRole(value.executor, `${path}.executor`);
+    const reviewer = parseRole(value.reviewer, `${path}.reviewer`);
+    return Object.freeze({ executor, reviewer });
+}
+function parseCanonical(value) {
+    if (!Array.isArray(value))
+        fail('INVALID_AGENT_CLIENTS', 'agentClients');
+    const entries = new Map();
+    for (const [index, candidate] of value.entries()) {
+        const path = `agentClients[${index}]`;
+        if (!isRecord(candidate))
+            fail('INVALID_AGENT_CLIENTS', path);
+        const keys = Object.keys(candidate);
+        if ((keys.length !== 3 && keys.length !== 4)
+            || !hasOwn(candidate, 'id')
+            || !hasOwn(candidate, 'enabled')
+            || !hasOwn(candidate, 'installInSandbox')
+            || (keys.length === 4 && !hasOwn(candidate, 'orchestration'))) {
+            fail('INVALID_AGENT_CLIENTS', path);
+        }
+        if (!isAgentClientId(candidate.id)) {
+            fail('UNKNOWN_AGENT_CLIENT', `${path}.id`);
+        }
+        if (entries.has(candidate.id)) {
+            fail('DUPLICATE_AGENT_CLIENT', `${path}.id`);
+        }
+        if (typeof candidate.enabled !== 'boolean'
+            || typeof candidate.installInSandbox !== 'boolean') {
+            fail('INVALID_AGENT_CLIENTS', path);
+        }
+        entries.set(candidate.id, {
+            enabled: candidate.enabled,
+            installInSandbox: candidate.installInSandbox,
+            ...(hasOwn(candidate, 'orchestration')
+                ? { orchestration: parseOrchestrationPolicy(candidate.orchestration, `${path}.orchestration`) }
+                : {})
+        });
+    }
+    for (const id of AGENT_CLIENT_IDS) {
+        if (!entries.has(id))
+            fail('MISSING_AGENT_CLIENT', 'agentClients');
+    }
+    return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, entries.get(id)]));
+}
+function serializeAgentClients(state) {
+    return AGENT_CLIENT_IDS.map((id) => ({
+        id,
+        enabled: state[id].enabled,
+        installInSandbox: state[id].installInSandbox,
+        ...(state[id].orchestration
+            ? { orchestration: structuredClone(state[id].orchestration) }
+            : {})
+    }));
+}
+function projectLegacyTuis(value, diagnostics) {
+    if (!Array.isArray(value)) {
+        return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, true]));
+    }
+    const enabled = new Set();
+    for (const [index, candidate] of value.entries()) {
+        if (isAgentClientId(candidate)) {
+            enabled.add(candidate);
+        }
+        else {
+            diagnostics.push({
+                code: 'LEGACY_VALUE_IGNORED',
+                path: `tuis[${index}]`
+            });
+        }
+    }
+    return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, enabled.has(id)]));
+}
+function projectLegacySandbox(value, diagnostics) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return {
+            installed: Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, true])),
+            clientSignals: new Set(),
+            remainingTools: Array.isArray(value) ? [] : undefined
+        };
+    }
+    const installed = new Set();
+    const remainingTools = [];
+    for (const [index, candidate] of value.entries()) {
+        if (isAgentClientId(candidate)) {
+            installed.add(candidate);
+        }
+        else if (typeof candidate === 'string') {
+            remainingTools.push(candidate);
+        }
+        else {
+            diagnostics.push({
+                code: 'LEGACY_VALUE_IGNORED',
+                path: `sandbox.tools[${index}]`
+            });
+        }
+    }
+    return {
+        installed: Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, installed.has(id)])),
+        clientSignals: installed,
+        remainingTools
+    };
+}
+function stateFromLegacy(enabled, installed) {
+    return Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [
+        id,
+        {
+            enabled: enabled[id],
+            installInSandbox: installed[id]
+        }
+    ]));
+}
+function sameCanonicalOrder(value) {
+    return Array.isArray(value)
+        && value.every((entry, index) => isRecord(entry) && entry.id === AGENT_CLIENT_IDS[index]);
+}
+function normalizeAgentClients(input) {
+    const diagnostics = [];
+    const hasCanonical = hasOwn(input, 'agentClients');
+    const hasLegacyTuis = hasOwn(input, 'tuis');
+    const sandbox = isRecord(input.sandbox) ? input.sandbox : undefined;
+    const hasLegacySandboxTools = sandbox !== undefined && hasOwn(sandbox, 'tools');
+    const tuiProjection = projectLegacyTuis(input.tuis, diagnostics);
+    const sandboxProjection = projectLegacySandbox(sandbox?.tools, diagnostics);
+    if (!hasCanonical) {
+        const state = stateFromLegacy(tuiProjection, sandboxProjection.installed);
+        return {
+            source: 'legacy',
+            state,
+            canonical: serializeAgentClients(state),
+            remainingSandboxTools: sandboxProjection.remainingTools,
+            removeLegacyTuis: hasLegacyTuis,
+            changed: true,
+            diagnostics
+        };
+    }
+    const state = parseCanonical(input.agentClients);
+    if (hasLegacyTuis) {
+        for (const id of AGENT_CLIENT_IDS) {
+            if (state[id].enabled !== tuiProjection[id]) {
+                fail('LEGACY_CONFLICT', 'tuis');
+            }
+        }
+    }
+    if (hasLegacySandboxTools) {
+        for (const id of sandboxProjection.clientSignals) {
+            if (!state[id].installInSandbox) {
+                fail('LEGACY_CONFLICT', 'sandbox.tools');
+            }
+        }
+    }
+    return {
+        source: 'canonical',
+        state,
+        canonical: serializeAgentClients(state),
+        remainingSandboxTools: hasLegacySandboxTools
+            ? sandboxProjection.remainingTools
+            : undefined,
+        removeLegacyTuis: hasLegacyTuis,
+        changed: hasLegacyTuis
+            || sandboxProjection.clientSignals.size > 0
+            || !sameCanonicalOrder(input.agentClients),
+        diagnostics
+    };
+}
+export { AgentClientConfigError, normalizeAgentClients, serializeAgentClients };
+//# sourceMappingURL=config.js.map

package/dist/lib/agent-clients/custom-tuis.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+const CUSTOM_TUI_CONTRACT = Object.freeze({
+    requiredFields: Object.freeze(['name', 'dir', 'invoke']),
+    allowedPlaceholders: Object.freeze(['skillName', 'projectName'])
+});
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptySingleLine(value) {
+    return typeof value === 'string'
+        && value.trim() !== ''
+        && !/[\r\n]/.test(value);
+}
+function normalizeDir(projectRoot, value) {
+    if (!isNonEmptySingleLine(value)
+        || value.includes('\\')
+        || path.isAbsolute(value)
+        || /^[a-zA-Z]:/.test(value)) {
+        return null;
+    }
+    const normalized = path.posix.normalize(value);
+    if (normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || normalized.split('/').includes('..')) {
+        return null;
+    }
+    const relative = path.relative(path.resolve(projectRoot), path.resolve(projectRoot, normalized));
+    return relative === ''
+        || path.isAbsolute(relative)
+        || relative === '..'
+        || relative.startsWith(`..${path.sep}`)
+        ? null
+        : normalized;
+}
+function hasValidPlaceholders(invocation) {
+    const placeholders = [
+        ...invocation.matchAll(/\$\{([^}]+)\}/g)
+    ].map((match) => match[1]);
+    return placeholders.includes('skillName')
+        && placeholders.every((placeholder) => CUSTOM_TUI_CONTRACT.allowedPlaceholders.includes(placeholder))
+        && !invocation
+            .replaceAll('${skillName}', '')
+            .replaceAll('${projectName}', '')
+            .includes('${');
+}
+function normalizeCustomTUIs(projectRoot, input) {
+    const items = [];
+    const diagnostics = [];
+    if (!Array.isArray(input)) {
+        return Object.freeze({
+            items: Object.freeze([]),
+            diagnostics: Object.freeze([
+                Object.freeze({
+                    code: 'INVALID_CUSTOM_TUIS',
+                    path: 'customTUIs'
+                })
+            ])
+        });
+    }
+    for (const [index, candidate] of input.entries()) {
+        const base = `customTUIs[${index}]`;
+        if (!isRecord(candidate)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: base });
+            continue;
+        }
+        if (!isNonEmptySingleLine(candidate.name)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.name` });
+            continue;
+        }
+        const dir = normalizeDir(projectRoot, candidate.dir);
+        if (!dir) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.dir` });
+            continue;
+        }
+        if (!isNonEmptySingleLine(candidate.invoke)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TUI', path: `${base}.invoke` });
+            continue;
+        }
+        if (!hasValidPlaceholders(candidate.invoke)) {
+            diagnostics.push({
+                code: 'INVALID_CUSTOM_TUI_PLACEHOLDER',
+                path: `${base}.invoke`
+            });
+            continue;
+        }
+        items.push(Object.freeze({
+            name: candidate.name,
+            dir,
+            invocation: candidate.invoke
+        }));
+    }
+    return Object.freeze({
+        items: Object.freeze(items),
+        diagnostics: Object.freeze(diagnostics.map((diagnostic) => Object.freeze(diagnostic)))
+    });
+}
+export { CUSTOM_TUI_CONTRACT, normalizeCustomTUIs };
+//# sourceMappingURL=custom-tuis.js.map

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

@@ -0,0 +1,9 @@
+function renderAgentClientInvocation(template, input) {
+    let command = template.replaceAll('${skillName}', input.skillName);
+    if (input.projectName !== undefined) {
+        command = command.replaceAll('${projectName}', input.projectName);
+    }
+    return [command, ...(input.args ?? [])].join(' ').trim();
+}
+export { renderAgentClientInvocation };
+//# sourceMappingURL=invocation.js.map

package/dist/lib/agent-clients/next-steps.js

@@ -0,0 +1,47 @@
+import { listEnabledAgentClientAdapters } from './registry.js';
+import { renderAgentClientInvocation } from './invocation.js';
+import semver from 'semver';
+const SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const SAFE_TASK_REF = /^(?:\d+|TASK-\d{8}-\d{6})$/;
+function requireSafeName(value, field) {
+    if (!SAFE_NAME.test(value)) {
+        throw new Error(`Invalid ${field}`);
+    }
+}
+function renderNextStepCommands(input) {
+    requireSafeName(input.projectName, 'project name');
+    requireSafeName(input.skillName, 'skill name');
+    if (input.taskRef !== undefined && !SAFE_TASK_REF.test(input.taskRef)) {
+        throw new Error('Invalid task ref');
+    }
+    if (input.version !== undefined
+        && (!/^[0-9]/.test(input.version) || semver.valid(input.version) !== input.version)) {
+        throw new Error('Invalid version');
+    }
+    const args = [
+        ...(input.taskRef === undefined ? [] : [input.taskRef]),
+        ...(input.version === undefined ? [] : [input.version])
+    ];
+    const builtins = listEnabledAgentClientAdapters(input.state).map((adapter) => Object.freeze({
+        source: 'builtin',
+        clientId: adapter.id,
+        displayName: adapter.displayName,
+        command: renderAgentClientInvocation(adapter.invocation, {
+            projectName: input.projectName,
+            skillName: input.skillName,
+            args
+        })
+    }));
+    const custom = input.customTUIs.map((tool) => Object.freeze({
+        source: 'custom',
+        displayName: tool.name,
+        command: renderAgentClientInvocation(tool.invocation, {
+            projectName: input.projectName,
+            skillName: input.skillName,
+            args
+        })
+    }));
+    return Object.freeze([...builtins, ...custom]);
+}
+export { renderNextStepCommands };
+//# sourceMappingURL=next-steps.js.map

package/dist/lib/agent-clients/project-assets.js

@@ -0,0 +1,45 @@
+function unique(values) {
+    return Object.freeze([...new Set(values)]);
+}
+function planAgentClientProjectAssets(input) {
+    const enabledIds = new Set(input.enabledAdapters.map((adapter) => adapter.id));
+    const enabledAdapters = input.allAdapters.filter((adapter) => enabledIds.has(adapter.id));
+    const disabledAdapters = input.allAdapters.filter((adapter) => !enabledIds.has(adapter.id));
+    const enabledManaged = unique(enabledAdapters.flatMap((adapter) => adapter.project.managed));
+    const enabledMerged = unique(enabledAdapters.flatMap((adapter) => adapter.project.merged));
+    const enabledEjected = unique(enabledAdapters.flatMap((adapter) => adapter.project.ejected));
+    const disabledManaged = unique(disabledAdapters.flatMap((adapter) => adapter.project.managed));
+    const allAdapterAssets = new Set(input.allAdapters.flatMap((adapter) => [
+        ...adapter.project.managed,
+        ...adapter.project.merged,
+        ...adapter.project.ejected
+    ]));
+    const ejected = unique([
+        ...input.current.ejected,
+        ...enabledEjected,
+        ...input.sharedDefaults.ejected
+    ]);
+    const ejectedSet = new Set(ejected);
+    const preserveCurrent = (values, enabledValues) => values.filter((entry) => !ejectedSet.has(entry)
+        && (!allAdapterAssets.has(entry) || enabledValues.includes(entry)));
+    const managed = unique([
+        ...preserveCurrent(input.current.managed, enabledManaged),
+        ...enabledManaged.filter((entry) => !ejectedSet.has(entry)),
+        ...input.sharedDefaults.managed.filter((entry) => !ejectedSet.has(entry))
+    ]);
+    const managedSet = new Set(managed);
+    const merged = unique([
+        ...preserveCurrent(input.current.merged, enabledMerged),
+        ...enabledMerged.filter((entry) => !ejectedSet.has(entry) && !managedSet.has(entry)),
+        ...input.sharedDefaults.merged.filter((entry) => !ejectedSet.has(entry) && !managedSet.has(entry))
+    ]);
+    return Object.freeze({
+        registry: Object.freeze({ managed, merged, ejected }),
+        enabledManaged,
+        enabledMerged,
+        enabledEjected,
+        disabledManaged
+    });
+}
+export { planAgentClientProjectAssets };
+//# sourceMappingURL=project-assets.js.map