codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/orchestration/claude-code-adapter.js

@@ -0,0 +1,352 @@
+/**
+ * Claude Code adapter — F1 foundation of the PM layer (v0.3).
+ *
+ * Wraps `claude -p "<task>" --output-format=stream-json …` as a subprocess
+ * and exposes a tight interface: spawn, subscribe to events, kill.
+ *
+ * Deep module: everything about process management, stream parsing, line
+ * buffering, SIGTERM→SIGKILL escalation, and late-joiner replay is hidden
+ * behind four exported names (TaskSession type, spawnClaudeCode, TaskEvent,
+ * TaskStatus). Callers never see a child_process handle.
+ *
+ * Safety note: spawned sessions inherit the user's global PreToolUse hook
+ * via ~/.claude/settings.json automatically — we do NOT re-wire it here.
+ * That's F0 doing its job for free.
+ */
+import { spawn } from 'child_process';
+import { execFileSync } from 'child_process';
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { ProgressAggregator } from './progress-aggregator.js';
+import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
+// Runtime-error fingerprints → structured codehere:error events with recovery hints.
+// Matched against any stderr line or assistant-text content we see on the stream.
+const ERROR_PATTERNS = [
+    {
+        code: 'credit_low',
+        regex: /credit balance is too low/i,
+        message: 'Your Claude API account has no credits.',
+        recovery: 'codehere tries to use your Claude Code subscription by default. If you are seeing this, ' +
+            'ANTHROPIC_API_KEY is still being used somehow. Unset it in your shell (e.g. remove from ~/.zshrc), ' +
+            'or top up at console.anthropic.com.',
+    },
+    {
+        code: 'auth_invalid',
+        regex: /invalid api key|authentication.*failed|not authenticated|401 unauth/i,
+        message: 'Claude Code auth was rejected.',
+        recovery: 'Run `claude` in a terminal, sign in, then retry the task.',
+    },
+    {
+        code: 'rate_limit',
+        regex: /rate.?limit(ed)?|429|too many requests/i,
+        message: 'Claude rate-limited the request.',
+        recovery: 'Wait a minute and retry. If this persists, check your Claude usage dashboard.',
+    },
+];
+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;
+}
+const HEADLESS_FLAGS = [
+    '--output-format',
+    'stream-json',
+    '--include-partial-messages',
+    '--include-hook-events',
+    '--verbose',
+    // Pre-grant common tools so -p mode doesn't dead-end at interactive permission
+    // prompts we cannot surface to the user. Safety is still enforced by codehere's
+    // PreToolUse hook (F0) on every tool call — that's the real gate.
+    '--allowedTools',
+    'Bash',
+    'Edit',
+    'Write',
+    'Read',
+    'Grep',
+    'Glob',
+    'MultiEdit',
+    'NotebookEdit',
+];
+export function spawnClaudeCode(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. Shared helper modules; per-session instances.
+    const cwd = options.cwd ?? process.cwd();
+    const snapshot = snapshotCwd(cwd);
+    const aggregator = new ProgressAggregator('claude-code');
+    let stepsSnapshot = [];
+    let artifactsSnapshot;
+    let textAccum = ''; // accumulates assistant text + result summary for test-count parsing
+    let usageSnapshot; // token accumulator (principle #7)
+    let errorEmitted = false;
+    const emit = (event) => {
+        buffer.push(event);
+        emitter.emit('event', event);
+        // Layer 2: feed aggregator; on step change, emit synthetic snapshot event.
+        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);
+        }
+        // Accumulate text for test-summary parsing (Layer 3).
+        if (event.type === 'assistant') {
+            const msg = event.data?.message;
+            if (msg?.content) {
+                for (const b of msg.content) {
+                    if (b.type === 'text' && b.text)
+                        textAccum += b.text + '\n';
+                }
+            }
+        }
+        else if (event.type === 'result') {
+            const d = event.data;
+            if (d?.result)
+                textAccum += d.result + '\n';
+            // Claude Code's stream-json `result` event is the final summary — carries
+            // the full session's usage totals. One event per session; overwrite, don't sum.
+            if (d?.usage) {
+                usageSnapshot = {
+                    inputTokens: Number(d.usage.input_tokens ?? 0),
+                    outputTokens: Number(d.usage.output_tokens ?? 0),
+                    cacheReadTokens: d.usage.cache_read_input_tokens ? Number(d.usage.cache_read_input_tokens) : undefined,
+                    cacheCreationTokens: d.usage.cache_creation_input_tokens
+                        ? Number(d.usage.cache_creation_input_tokens)
+                        : undefined,
+                };
+            }
+        }
+        else if (event.type === 'user') {
+            const msg = event.data?.message;
+            if (msg?.content) {
+                for (const b of msg.content) {
+                    if (b.type === 'tool_result') {
+                        const raw = Array.isArray(b.content)
+                            ? b.content.map((c) => c.text ?? '').join('')
+                            : String(b.content ?? '');
+                        textAccum += raw + '\n';
+                    }
+                }
+            }
+        }
+        // F1b: scan for known failure patterns once per session
+        if (!errorEmitted) {
+            const data = event.data;
+            let text = '';
+            if (event.type === 'stderr' && data && typeof data.line === 'string') {
+                text = data.line;
+            }
+            else if (event.type === 'assistant' && data && typeof data === 'object') {
+                const msg = data.message;
+                if (msg?.content) {
+                    text = msg.content.map((b) => (b.type === 'text' ? (b.text ?? '') : '')).join(' ');
+                }
+            }
+            else if (event.type === 'result' && data && typeof data.result === 'string') {
+                text = String(data.result ?? '');
+            }
+            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 preferSubscription = options.preferSubscription !== false;
+    const spawnEnv = { ...process.env, ...(options.env ?? {}) };
+    if (preferSubscription) {
+        // Force keychain/OAuth path — matches what the user's interactive `claude` uses.
+        delete spawnEnv.ANTHROPIC_API_KEY;
+        delete spawnEnv.ANTHROPIC_AUTH_TOKEN;
+        delete spawnEnv.CLAUDE_API_KEY;
+    }
+    let child;
+    try {
+        child = spawn('claude', ['-p', prompt, ...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], {
+            cwd,
+            env: spawnEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        statusValue = 'error';
+        const msg = err instanceof Error ? err.message : String(err);
+        // Emit synchronously so subscribers added immediately after see it
+        queueMicrotask(() => emit({ type: 'error', timestamp: Date.now(), data: { message: msg } }));
+        return {
+            sessionId,
+            startedAt,
+            prompt,
+            agent: 'claude-code',
+            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 */
+            },
+        };
+    }
+    // ── stdout: newline-delimited JSON from `--output-format stream-json` ────────
+    let stdoutBuf = '';
+    child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString('utf-8');
+        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);
+                emit({ type: data.type ?? 'message', timestamp: Date.now(), data });
+            }
+            catch {
+                // Non-JSON stdout line — preserve so callers can see raw output
+                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
+            }
+        }
+    });
+    // ── stderr: Claude prints debug/errors here; forward raw ─────────────────────
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString('utf-8');
+        for (const line of text.split('\n')) {
+            if (line.trim())
+                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
+        }
+    });
+    child.on('exit', (code, signal) => {
+        statusValue =
+            killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';
+        // Emit synthetic PM events BEFORE 'exit' so the client has time to render
+        // them before its onmessage handler closes the SSE stream in response to exit.
+        // (Client must close on exit to avoid leaking connections — but close() cancels
+        //  pending messages, so order matters.)
+        // Layer 2: flip any still-active steps to done/failed so the UI stops spinning.
+        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 } });
+        }
+        // Layer 3: on clean completion, extract artifacts (git diff + trust + tests + tokens) and announce.
+        if (statusValue === 'completed') {
+            try {
+                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
+                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
+            }
+            catch {
+                /* best-effort; don't break exit path */
+            }
+        }
+        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: 'claude-code',
+        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');
+            // Escalate if it doesn't die in 3s
+            setTimeout(() => {
+                if (statusValue === 'running') {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        /* already dead */
+                    }
+                }
+            }, 3000);
+        },
+    };
+}
+// ── AgentAdapter implementation ─────────────────────────────────────────────
+export const ClaudeCodeAdapter = {
+    id: 'claude-code',
+    label: 'Claude Code',
+    processPattern: /(?:^|\/)claude(?:\s|$)/,
+    isInstalled() {
+        try {
+            const out = execFileSync('which', ['claude'], { encoding: 'utf-8', timeout: 2000 });
+            return out.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    },
+    spawn(prompt, options) {
+        return spawnClaudeCode(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 @anthropic-ai/claude-code',
+                    url: 'https://docs.claude.com/en/docs/claude-code/setup',
+                },
+            };
+        }
+        // Claude Code supports BOTH subscription (OAuth via keychain) and API key.
+        // "Ready" if either path works. We can't verify subscription without
+        // calling the API, so we treat any Claude Code install as ready by default —
+        // runtime F1b error-fingerprints catch real auth failures after spawn.
+        return { id: this.id, label: this.label, state: 'ready', installed: true };
+    },
+};
+//# sourceMappingURL=claude-code-adapter.js.map

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

@@ -0,0 +1,310 @@
+/**
+ * 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 { ProgressAggregator } from './progress-aggregator.js';
+import { snapshotCwd, extractArtifacts } from './artifacts-extractor.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();
+    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.
+        if (event.type === 'item.completed') {
+            const item = event.data?.item;
+            if (item?.type === 'command_execution' && item.aggregated_output)
+                textAccum += item.aggregated_output + '\n';
+            if (item?.type === 'agent_message' && item.text)
+                textAccum += item.text + '\n';
+        }
+        // Accumulate token usage across all turns (one turn.completed per turn).
+        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);
+                if (u.cached_input_tokens)
+                    acc.cacheReadTokens = (acc.cacheReadTokens ?? 0) + Number(u.cached_input_tokens);
+                usageSnapshot = acc;
+            }
+        }
+        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: scan any string fields for known error patterns
+                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.
+        child = spawn('codex', [...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], {
+            cwd,
+            env: spawnEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stdin?.write(prompt);
+        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 */
+            },
+        };
+    }
+    let stdoutBuf = '';
+    child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString('utf-8');
+        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);
+                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');
+        for (const line of text.split('\n')) {
+            if (line.trim())
+                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
+        }
+    });
+    child.on('exit', (code, 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',
+        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);
+        },
+    };
+}
+export const CodexAdapter = {
+    id: 'codex',
+    label: 'Codex',
+    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 ChatGPT account auth via `codex login` (similar to Claude
+        // Code's OAuth) OR OPENAI_API_KEY. Can't verify without calling out — let
+        // runtime catch real failures.
+        return { id: this.id, label: this.label, state: 'ready', installed: true };
+    },
+};
+//# sourceMappingURL=codex-adapter.js.map