codehere 1.0.1 → 1.0.2

package/dist/infrastructure/orchestration/codex-adapter.js

@@ -1,574 +0,0 @@
-/**
- * Codex adapter — F2 second concrete AgentAdapter (v0.4 → shipping in v0.3.0-alpha.4).
- *
- * Wraps `codex exec --json "<prompt>"` as a subprocess. Codex CLI's --json
- * flag emits JSONL on stdout; we tokenize, parse, forward as TaskEvents.
- *
- * Event shapes are not fully documented — renderer handles unknowns by falling
- * through (same pattern as ClaudeCodeAdapter: skip tokens we can't shape, fire
- * raw stdout for anything else). First dogfood session will show what's real.
- *
- * Same structural pattern as ClaudeCodeAdapter: event buffer, late-joiner replay,
- * SIGTERM→SIGKILL escalation, known-error fingerprints. Intentionally duplicates
- * some structure — premature shared-base-class abstraction would couple adapters
- * that may diverge substantially (each agent CLI has its own quirks).
- */
-import { spawn, execFileSync } from 'child_process';
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { startRecording } from './cassette-recorder.js';
-import { ProgressAggregator } from './progress-aggregator.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
-import { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
-const HEADLESS_FLAGS = [
-    'exec',
-    '--json',
-    // codehere is the external safety layer — every tool call goes through
-    // our PreToolUse hook (F0) which is where destructive-command scanning
-    // happens. codex's own gates in -p mode are redundant AND block tasks
-    // from actually running, so we bypass both:
-    //
-    //   --skip-git-repo-check: run outside a git repo (like /tmp, home, etc)
-    //   --dangerously-bypass-approvals-and-sandbox: skip codex's read-only
-    //     sandbox (blocks writes) and its interactive approval prompts
-    //     (impossible to answer in -p mode anyway).
-    //
-    // codex's own help text: "EXTREMELY DANGEROUS. Intended solely for
-    // running in environments that are externally sandboxed." — that's us.
-    '--skip-git-repo-check',
-    '--dangerously-bypass-approvals-and-sandbox',
-];
-const ERROR_PATTERNS = [
-    {
-        code: 'auth_invalid',
-        regex: /not\s+logged\s+in|authentication\s+failed|401 unauth/i,
-        message: 'Codex auth missing or rejected.',
-        recovery: 'Run `codex login` in a terminal, then retry the task.',
-    },
-    {
-        code: 'rate_limit',
-        regex: /rate.?limit(ed)?|429|too many requests/i,
-        message: 'Codex rate-limited the request.',
-        recovery: 'Wait a minute and retry, or check your OpenAI usage dashboard.',
-    },
-    {
-        code: 'quota_exceeded',
-        regex: /quota|insufficient_quota|you exceeded your current quota/i,
-        message: 'OpenAI quota exhausted.',
-        recovery: 'Top up at platform.openai.com or switch to a different agent.',
-    },
-];
-function scanForKnownError(text) {
-    for (const p of ERROR_PATTERNS) {
-        if (p.regex.test(text))
-            return { code: p.code, message: p.message, recovery: p.recovery };
-    }
-    return null;
-}
-export function spawnCodex(prompt, options = {}) {
-    const sessionId = randomUUID();
-    const startedAt = Date.now();
-    const emitter = new EventEmitter();
-    const buffer = [];
-    let statusValue = 'running';
-    let killRequested = false;
-    // PM UX Layer 2+3 state — same shape as claude-code-adapter. Kept in-file (not
-    // extracted to a base class) because the two CLIs diverge in more than they share.
-    const cwd = options.cwd ?? process.cwd();
-    // F3 Task 8 — memory injection (same shape as every other adapter).
-    const injected = applyMemoryPrefix(prompt, cwd, options);
-    const finalPrompt = injected.prompt;
-    const snapshot = snapshotCwd(cwd);
-    const aggregator = new ProgressAggregator('codex');
-    let stepsSnapshot = [];
-    let artifactsSnapshot;
-    let textAccum = '';
-    // Codex emits one turn.completed per turn; sum across turns for session total.
-    let usageSnapshot;
-    let errorEmitted = false;
-    const emit = (event) => {
-        buffer.push(event);
-        emitter.emit('event', event);
-        // Layer 2: aggregate + emit synthetic snapshot on change.
-        if (aggregator.ingest(event)) {
-            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
-            const snapEvt = { type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } };
-            buffer.push(snapEvt);
-            emitter.emit('event', snapEvt);
-        }
-        // Collect text for test-summary parsing (Layer 3). Codex surfaces command
-        // output via item.completed.aggregated_output and agent messages via item.text.
-        //
-        // v0.7 CRIT-1 fix — extended item subtypes parsed:
-        //   - command_execution (Bash) — existing, mirrored to audit
-        //   - agent_message (assistant text) — existing
-        //   - file_change (Edit/Write batch) — NEW, mirrored as Edit per file
-        //   - mcp_tool_call (MCP servers) — NEW, mirrored as Tool with server prefix
-        //   - collab_tool_call (SUBAGENT FAN-OUT, multi-agent v2 GA 2026-05-18) — NEW
-        //     · spawn_agent / send_input / wait / close_agent / resume_agent
-        //     · mirrored to audit as "Subagent" toolName so the audit feed shows the
-        //       child-spawn activity. Without this, multi-agent Codex tasks fall
-        //       silently through (audit + cost claim breach per CRIT-1).
-        //     · Token usage of children remains UNDER-REPORTED in this fix —
-        //       child usage lives on a separate app-server stream we don't yet
-        //       subscribe to. Disclosed honestly in docs/contracts/00-FINDINGS.md.
-        //   - todo_list — NEW, fed through as a synthetic 'todo' tool call (lets
-        //     ProgressAggregator surface plan changes for PM Layer 2 UX parity)
-        //   - web_search — NEW, mirrored as WebSearch tool
-        //   - reasoning — NOT mirrored (private CoT trace; not an action)
-        //   - error (item) — NEW, surfaced as codehere:error for non-fatal errors
-        if (event.type === 'item.completed') {
-            const item = event.data?.item;
-            if (!item?.type) {
-                // unknown shape — let it pass for textAccum below
-            }
-            else if (item.type === 'command_execution') {
-                if (item.aggregated_output)
-                    textAccum += item.aggregated_output + '\n';
-                if (typeof item.command === 'string' && item.command) {
-                    mirrorToolCallToAudit({
-                        sessionId,
-                        agent: 'codex',
-                        toolName: 'Bash',
-                        toolInput: item.command,
-                        cwd,
-                    });
-                }
-            }
-            else if (item.type === 'agent_message') {
-                if (item.text)
-                    textAccum += item.text + '\n';
-            }
-            else if (item.type === 'file_change') {
-                // One audit entry per changed file. Codehere-cased toolName per
-                // /history filter convention (matches Claude Edit/Write rows).
-                for (const change of item.changes ?? []) {
-                    const path = String(change.path ?? '');
-                    const kind = String(change.kind ?? 'update');
-                    if (!path)
-                        continue;
-                    const toolName = kind === 'add' ? 'Write' : kind === 'delete' ? 'Delete' : 'Edit';
-                    mirrorToolCallToAudit({
-                        sessionId,
-                        agent: 'codex',
-                        toolName,
-                        toolInput: path,
-                        cwd,
-                    });
-                }
-            }
-            else if (item.type === 'mcp_tool_call') {
-                const server = String(item.server ?? '');
-                const tool = String(item.tool ?? 'mcp');
-                mirrorToolCallToAudit({
-                    sessionId,
-                    agent: 'codex',
-                    toolName: `MCP.${server}.${tool}`,
-                    toolInput: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments ?? {}).slice(0, 500),
-                    cwd,
-                });
-            }
-            else if (item.type === 'collab_tool_call') {
-                // SUBAGENT FAN-OUT — the v0.7 fix that closes CRIT-1's audit gap.
-                // Mirror every collab call to the audit log so the audit feed shows the
-                // subagent activity. Tool naming convention: "Subagent.<tool>".
-                const collabTool = String(item.tool ?? 'collab');
-                const receivers = (item.receiver_thread_ids ?? []).join(',');
-                const promptExcerpt = item.prompt ? String(item.prompt).slice(0, 200) : '';
-                const auditPayload = JSON.stringify({
-                    tool: collabTool,
-                    sender: item.sender_thread_id,
-                    receivers,
-                    prompt: promptExcerpt,
-                    agents_states: item.agents_states ?? {},
-                }).slice(0, 1000);
-                mirrorToolCallToAudit({
-                    sessionId,
-                    agent: 'codex',
-                    toolName: `Subagent.${collabTool}`,
-                    toolInput: auditPayload,
-                    cwd,
-                });
-            }
-            else if (item.type === 'todo_list') {
-                // Feed into textAccum for Final Report visibility. Future v0.8: wire
-                // into ProgressAggregator for PM Layer 2 parity with Claude TodoWrite.
-                const items = (item.items ?? []).map((t) => `- [${t.completed ? 'x' : ' '}] ${t.text ?? ''}`).join('\n');
-                if (items)
-                    textAccum += `Todo list:\n${items}\n`;
-            }
-            else if (item.type === 'web_search') {
-                mirrorToolCallToAudit({
-                    sessionId,
-                    agent: 'codex',
-                    toolName: 'WebSearch',
-                    toolInput: String(item.query ?? ''),
-                    cwd,
-                });
-            }
-            else if (item.type === 'error') {
-                // Non-fatal item-level error (distinct from top-level `error` + `turn.failed`).
-                // Don't flip errorEmitted — caller may still complete successfully.
-                if (item.message)
-                    textAccum += `[error] ${item.message}\n`;
-            }
-            // reasoning: intentionally not mirrored (private trace, not an action)
-        }
-        // Accumulate token usage across all turns (one turn.completed per turn).
-        // v0.7 MED-3 parity — also sum reasoning_output_tokens into outputTokens.
-        if (event.type === 'turn.completed') {
-            const u = event.data?.usage;
-            if (u) {
-                const acc = usageSnapshot ?? { inputTokens: 0, outputTokens: 0 };
-                acc.inputTokens += Number(u.input_tokens ?? 0);
-                acc.outputTokens += Number(u.output_tokens ?? 0);
-                // Reasoning tokens billed at output rate per OpenAI pricing — fold in.
-                if (u.reasoning_output_tokens)
-                    acc.outputTokens += Number(u.reasoning_output_tokens);
-                if (u.cached_input_tokens)
-                    acc.cacheReadTokens = (acc.cacheReadTokens ?? 0) + Number(u.cached_input_tokens);
-                usageSnapshot = acc;
-            }
-        }
-        // v0.7 MED-1 — explicit handler for turn.failed. Previously caught only by
-        // the catch-all stringify scan below (load-bearing accident). Now the
-        // canonical wire surface for API errors is parsed directly.
-        if (event.type === 'turn.failed' && !errorEmitted) {
-            const errObj = event.data?.error;
-            const message = String(errObj?.message ?? '');
-            if (message) {
-                errorEmitted = true;
-                // A recognized error gets codehere's curated message + recovery. An
-                // UNRECOGNIZED one (e.g. ChatGPT-plan "You've hit your usage limit — try
-                // again Jul 14") must NOT be swallowed: surface codex's REAL words so the
-                // user sees the actual, actionable reason instead of a generic guess.
-                const hit = scanForKnownError(message);
-                const errEvent = {
-                    type: 'codehere:error',
-                    timestamp: Date.now(),
-                    data: hit
-                        ? { code: hit.code, message: hit.message, recovery: hit.recovery }
-                        : { code: 'agent_error', message, recovery: '' },
-                };
-                buffer.push(errEvent);
-                emitter.emit('event', errEvent);
-            }
-        }
-        if (!errorEmitted) {
-            const data = event.data;
-            let text = '';
-            if (event.type === 'stderr' && data && typeof data.line === 'string') {
-                text = data.line;
-            }
-            else if (event.type === 'stdout' && data && typeof data.line === 'string') {
-                text = data.line;
-            }
-            else if (data && typeof data === 'object') {
-                // Catch-all (kept for stream-level `error` events + any future shape we
-                // don't have an explicit handler for). MED-1's explicit turn.failed
-                // handler above runs first; this is the safety net.
-                text = JSON.stringify(data);
-            }
-            if (text) {
-                const hit = scanForKnownError(text);
-                if (hit) {
-                    errorEmitted = true;
-                    const errEvent = {
-                        type: 'codehere:error',
-                        timestamp: Date.now(),
-                        data: { code: hit.code, message: hit.message, recovery: hit.recovery },
-                    };
-                    buffer.push(errEvent);
-                    emitter.emit('event', errEvent);
-                }
-            }
-        }
-    };
-    const spawnEnv = { ...process.env, ...(options.env ?? {}) };
-    let child;
-    try {
-        // Codex expects the prompt via stdin when stdin is piped; passing as argv
-        // while stdin is 'ignore' causes codex to hang waiting for EOF → exit 0
-        // with no task run. Pipe stdin, write prompt, close.
-        const sp = resolveAgentSpawn('codex', 'codex', [...HEADLESS_FLAGS, ...(options.extraArgs ?? [])]);
-        child = spawn(sp.command, sp.args, {
-            cwd,
-            env: spawnEnv,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        child.stdin?.write(finalPrompt);
-        child.stdin?.end();
-    }
-    catch (err) {
-        statusValue = 'error';
-        const msg = err instanceof Error ? err.message : String(err);
-        queueMicrotask(() => emit({ type: 'error', timestamp: Date.now(), data: { message: msg } }));
-        return {
-            sessionId,
-            startedAt,
-            prompt,
-            agent: 'codex',
-            get status() {
-                return statusValue;
-            },
-            get steps() {
-                return stepsSnapshot;
-            },
-            get artifacts() {
-                return artifactsSnapshot;
-            },
-            subscribe(handler) {
-                for (const e of buffer)
-                    handler(e);
-                emitter.on('event', handler);
-                return () => emitter.off('event', handler);
-            },
-            kill() {
-                /* already not running */
-            },
-        };
-    }
-    // v0.6.0 — capture codex's thread_id from the `thread.started` event so
-    // appendMessage() can use `codex exec resume <thread_id> <prompt>` for
-    // multi-turn continuity. Same pattern as claude-code-adapter capturing
-    // session_id from the init event for `claude --resume`.
-    let codexThreadId;
-    // Organic cassette recording (S2b · capture-first plan) · no-op unless
-    // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
-    const recorder = startRecording({ adapter: 'codex', sessionId, prompt: finalPrompt, cwd });
-    let stdoutBuf = '';
-    child.stdout?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStdout(text);
-        stdoutBuf += text;
-        let idx;
-        while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
-            const line = stdoutBuf.slice(0, idx).trim();
-            stdoutBuf = stdoutBuf.slice(idx + 1);
-            if (!line)
-                continue;
-            try {
-                const data = JSON.parse(line);
-                if (codexThreadId === undefined && data.type === 'thread.started' && typeof data.thread_id === 'string') {
-                    codexThreadId = data.thread_id;
-                }
-                emit({ type: data.type ?? 'codex_event', timestamp: Date.now(), data });
-            }
-            catch {
-                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
-            }
-        }
-    });
-    child.stderr?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStderr(text);
-        for (const line of text.split('\n')) {
-            if (line.trim())
-                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
-        }
-    });
-    child.on('exit', (code, signal) => {
-        recorder.onExit(code ?? -1, signal);
-        statusValue =
-            killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';
-        // PM events BEFORE 'exit' — see claude-code-adapter for rationale
-        // (client closes SSE on exit; close() cancels pending messages, so order matters).
-        if (aggregator.finalize(statusValue === 'completed' ? 'completed' : statusValue === 'killed' ? 'killed' : 'error')) {
-            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
-            emit({ type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } });
-        }
-        if (statusValue === 'completed') {
-            try {
-                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
-                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
-        emit({
-            type: 'exit',
-            timestamp: Date.now(),
-            data: { code, signal, status: statusValue, durationMs: Date.now() - startedAt },
-        });
-    });
-    child.on('error', (err) => {
-        statusValue = 'error';
-        emit({ type: 'error', timestamp: Date.now(), data: { message: err.message } });
-    });
-    return {
-        sessionId,
-        startedAt,
-        prompt,
-        agent: 'codex',
-        memoryInjection: injected.record,
-        get status() {
-            return statusValue;
-        },
-        get steps() {
-            return stepsSnapshot;
-        },
-        get artifacts() {
-            return artifactsSnapshot;
-        },
-        subscribe(handler) {
-            for (const e of buffer)
-                handler(e);
-            emitter.on('event', handler);
-            return () => emitter.off('event', handler);
-        },
-        kill() {
-            if (statusValue !== 'running')
-                return;
-            killRequested = true;
-            child.kill('SIGTERM');
-            setTimeout(() => {
-                if (statusValue === 'running') {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch {
-                        /* already dead */
-                    }
-                }
-            }, 3000);
-        },
-        canAppendMessage: true,
-        /**
-         * v0.6.0 — Slice 1 of REPL persistence. Spawns `codex exec resume <thread_id>`
-         * with the follow-up prompt via stdin (codex exec resume accepts `-` to read
-         * prompt from stdin per `codex exec resume --help`). Re-uses the original
-         * thread context so this is a true continuation, not a fresh session.
-         *
-         * Same shape as claude-code's appendMessage:
-         *   - One-shot Q&A (no streaming reply yet)
-         *   - Returns assistant text + duration
-         *   - Rejects if thread_id wasn't captured (init event missed)
-         *
-         * Founder hit codex usage cap at smoke time; the real-error path is
-         * exercised by the rate-limit fingerprint that lands in stderr/JSONL.
-         */
-        appendMessage(text) {
-            const startedAt = Date.now();
-            return new Promise((resolve, reject) => {
-                if (!codexThreadId) {
-                    reject(new Error('Cannot reply: codex thread_id was never captured (thread.started event missed)'));
-                    return;
-                }
-                let stdout = '';
-                let stderr = '';
-                // codex exec resume <SESSION_ID> -  → reads prompt from stdin
-                // Route follow-ups through the mock seam too — under CODEHERE_MOCK=1 this
-                // hits the mock REPL, not real codex. (Was a real-spend leak.)
-                const sp2 = resolveAgentSpawn('codex', 'codex', [
-                    'exec',
-                    '--json',
-                    '--skip-git-repo-check',
-                    '--dangerously-bypass-approvals-and-sandbox',
-                    'resume',
-                    codexThreadId,
-                    '-',
-                ], text);
-                const followup = spawn(sp2.command, sp2.args, {
-                    cwd,
-                    env: spawnEnv,
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
-                followup.stdin?.write(text);
-                followup.stdin?.end();
-                followup.on('error', (err) => reject(err));
-                followup.stdout?.on('data', (chunk) => {
-                    stdout += chunk.toString('utf-8');
-                });
-                followup.stderr?.on('data', (chunk) => {
-                    stderr += chunk.toString('utf-8');
-                });
-                followup.on('exit', (code) => {
-                    if (code !== 0) {
-                        reject(new Error(`codex exec resume exited ${code}: ${stderr.slice(0, 300)}`));
-                        return;
-                    }
-                    // Parse JSONL — extract assistant message text from item.completed
-                    // events of type agent_message (same shape codex emits during the
-                    // initial exec; reuse the textAccum logic).
-                    const lines = stdout.split('\n').filter((l) => l.trim());
-                    const fragments = [];
-                    for (const line of lines) {
-                        try {
-                            const obj = JSON.parse(line);
-                            if (obj.type === 'item.completed' && obj.item?.type === 'agent_message' && obj.item.text) {
-                                fragments.push(obj.item.text);
-                            }
-                        }
-                        catch {
-                            /* non-JSON line — skip */
-                        }
-                    }
-                    const result = fragments.join('\n').trim() || '(codex returned no agent_message text)';
-                    resolve({ result, durationMs: Date.now() - startedAt });
-                });
-            });
-        },
-    };
-}
-export const CodexAdapter = {
-    id: 'codex',
-    label: 'Codex',
-    description: "OpenAI's coding agent. Good when the task needs reading a lot of code first, then changing several files together.",
-    processPattern: /(?:^|\/)codex(?:\s|$)/,
-    isInstalled() {
-        try {
-            const out = execFileSync('which', ['codex'], { encoding: 'utf-8', timeout: 2000 });
-            return out.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    },
-    spawn(prompt, options) {
-        return spawnCodex(prompt, options);
-    },
-    checkReadiness() {
-        const installed = this.isInstalled();
-        if (!installed) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_install',
-                installed: false,
-                installHint: { command: 'npm install -g @openai/codex', url: 'https://github.com/openai/codex-cli' },
-            };
-        }
-        // Codex supports two auth paths, both detectable fs/env-only (no spawn —
-        // same honesty fix gemini/opencode got May 1: returning 'ready' on install
-        // alone sent users into a ~40s spawn that errored "not logged in" with no
-        // next step):
-        //   file: $CODEX_HOME/auth.json (default ~/.codex/auth.json, mode 600) —
-        //         written by `codex login` (ChatGPT account OAuth) or a stored key
-        //   env:  OPENAI_API_KEY (billed API path)
-        const codexHome = process.env.CODEX_HOME || join(homedir(), '.codex');
-        const codexAuthPath = join(codexHome, 'auth.json');
-        const hasFileAuth = existsSync(codexAuthPath);
-        const hasEnvAuth = !!process.env.OPENAI_API_KEY;
-        if (!hasFileAuth && !hasEnvAuth) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_auth',
-                installed: true,
-                authHint: {
-                    command: 'codex login  # ChatGPT account (Plus/Pro) — no per-token billing',
-                    url: 'https://github.com/openai/codex#authentication',
-                    detail: `Codex found on PATH but no auth detected (${codexAuthPath} missing and no OPENAI_API_KEY). Cheapest path: \`codex login\` with a ChatGPT Plus/Pro account (flat, no per-token charge). Or set OPENAI_API_KEY for the billed API.`,
-                },
-            };
-        }
-        return { id: this.id, label: this.label, state: 'ready', installed: true };
-    },
-};
-//# sourceMappingURL=codex-adapter.js.map