codehere 1.0.1 → 1.0.2

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

@@ -1,580 +0,0 @@
-/**
- * OpenCode adapter — fourth concrete AgentAdapter.
- *
- * `opencode run --format json "<prompt>"`
- *
- * OpenCode's --format json emits newline-delimited JSON (same general shape as
- * Claude Code and Codex). Event types observed: step_start, text, step_finish
- * (carries token counts + cost). Tool-call events likely fire in larger tasks
- * (unconfirmed on probe) — renderer falls through gracefully for unknowns.
- *
- * Same spawn-pattern pattern as Codex.
- */
-import { spawn, execFile, execFileSync } from 'child_process';
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { startRecording } from './cassette-recorder.js';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { promisify } from 'util';
-import { ProgressAggregator } from './progress-aggregator.js';
-import { resolveAgentSpawn, isMockMode } from './mocks/resolve-agent-spawn.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-import { detectOllama } from './detect-ollama.js';
-import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-const execFileAsync = promisify(execFile);
-const HEADLESS_FLAGS = ['run', '--format', 'json'];
-/**
- * Tag prefix written into opencode's `--title` so we can find a session by
- * codehere's own UUID later (opencode's `ses_*` ID isn't observable until
- * the LLM call completes — see appendMessage docblock for the full story).
- */
-const CODEHERE_TITLE_PREFIX = 'codehere-';
-/**
- * Parse `opencode session list --format json` output and return the opencode
- * session ID (`ses_*`) for the row whose title starts with our codehere
- * tag. Pure function so tests don't need a real opencode binary.
- *
- * Schema verified live (2026-05-04):
- *   [{ "id": "ses_212f...", "title": "...", "updated": <ms>, "created": <ms>,
- *      "projectId": "...", "directory": "..." }, ...]
- *
- * Returns the session whose title is exactly `<prefix><codehereSessionId>`.
- * Falls back to null if not found, the input is malformed, or the array is
- * empty. Caller falls back to --continue in that case.
- */
-export function parseOpenCodeSessionIdByTitle(listJson, codehereSessionId) {
-    if (!codehereSessionId)
-        return null;
-    const wantedTitle = `${CODEHERE_TITLE_PREFIX}${codehereSessionId}`;
-    let parsed;
-    try {
-        parsed = JSON.parse(listJson);
-    }
-    catch {
-        return null;
-    }
-    if (!Array.isArray(parsed))
-        return null;
-    for (const row of parsed) {
-        if (!row || typeof row !== 'object')
-            continue;
-        const r = row;
-        if (typeof r.id === 'string' && typeof r.title === 'string' && r.title === wantedTitle) {
-            // Defense in depth: opencode's IDs are always `ses_<base32-ish>`. If
-            // an attacker (or upstream bug) injects a row with a poisoned id like
-            // ` --rm-rf` we don't want to feed it back as a CLI arg.
-            if (/^ses_[A-Za-z0-9]+$/.test(r.id))
-                return r.id;
-        }
-    }
-    return null;
-}
-const ERROR_PATTERNS = [
-    {
-        code: 'auth_invalid',
-        regex: /not\s+logged\s+in|authentication\s+failed|401 unauth|no credentials/i,
-        message: 'OpenCode auth missing or rejected.',
-        recovery: 'Run `opencode providers` (alias `opencode auth`) to configure a provider, then retry.',
-    },
-    {
-        code: 'rate_limit',
-        regex: /rate.?limit(ed)?|429|too many requests/i,
-        message: 'OpenCode rate-limited the request.',
-        recovery: 'Wait a minute and retry, or swap provider via --model.',
-    },
-];
-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 spawnOpenCode(prompt, options = {}) {
-    const sessionId = randomUUID();
-    const startedAt = Date.now();
-    const emitter = new EventEmitter();
-    const buffer = [];
-    let statusValue = 'running';
-    let killRequested = false;
-    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('opencode');
-    let stepsSnapshot = [];
-    let artifactsSnapshot;
-    let textAccum = '';
-    let usageSnapshot;
-    let errorEmitted = false;
-    const emit = (event) => {
-        buffer.push(event);
-        emitter.emit('event', 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);
-        }
-        // OpenCode token accounting: step_finish events carry .part.tokens.{input,output,cache.{read,write}}.
-        // Sum across all steps for session total.
-        if (event.type === 'step_finish') {
-            const part = event.data?.part;
-            const t = part?.tokens;
-            if (t) {
-                const input = Number(t.input ?? 0);
-                const output = Number(t.output ?? 0);
-                const cache = t.cache ?? {};
-                const acc = usageSnapshot ?? { inputTokens: 0, outputTokens: 0 };
-                acc.inputTokens += input;
-                // OpenCode's output_tokens is sometimes negative on error/cancellation; floor at 0
-                acc.outputTokens += Math.max(0, output);
-                if (cache.read)
-                    acc.cacheReadTokens = (acc.cacheReadTokens ?? 0) + Number(cache.read);
-                if (cache.write)
-                    acc.cacheCreationTokens = (acc.cacheCreationTokens ?? 0) + Number(cache.write);
-                usageSnapshot = acc;
-            }
-        }
-        // Text for test-summary parsing: pull from `text` events' part.text
-        if (event.type === 'text') {
-            const txt = event.data?.part?.text;
-            if (txt)
-                textAccum += txt + '\n';
-        }
-        // #114 — cross-vendor audit mirror for opencode (closes the gap left by
-        // #110 slice 4, which wired Codex/Aider/Gemini but deferred opencode).
-        // OpenCode's `run --format json` emits `tool_use` events with shape
-        // { type: 'tool_use', part: { tool: 'bash'|'read'|'write'|..., state:
-        // { input: {...}, output, status, ... } } } (verified via deepwiki +
-        // takopi cheatsheet). Same post-hoc visibility surface as Codex/Aider/
-        // Gemini — no synchronous block until upstream pre-tool hooks land.
-        //
-        // v0.7 CRIT-2 fix — only mirror on state.status === 'completed' to
-        // avoid double-firing (state transitions running → completed both arrive
-        // as tool_use events; mirroring twice doubles audit entries + trust
-        // scans). Per docs/contracts/opencode.md, status is canonical.
-        if (event.type === 'tool_use') {
-            const part = event.data?.part;
-            // CRIT-2 guard: skip in-flight running state. Only audit on terminal.
-            const status = part?.state?.status;
-            if (status && status !== 'completed') {
-                return;
-            }
-            const rawTool = String(part?.tool ?? 'tool').toLowerCase();
-            // Normalize to Claude-cased tool names so /history filter chips group
-            // cross-vendor (a bash call from claude-code and opencode show under
-            // the same "Bash" filter chip).
-            const toolNameMap = {
-                bash: 'Bash',
-                read: 'Read',
-                write: 'Write',
-                edit: 'Edit',
-                grep: 'Grep',
-                glob: 'Glob',
-                webfetch: 'WebFetch',
-                websearch: 'WebSearch',
-                task: 'Task',
-            };
-            const toolName = toolNameMap[rawTool] ?? rawTool;
-            const input = part?.state?.input ?? {};
-            const inputStr = (typeof input.command === 'string' && input.command) ||
-                (typeof input.file_path === 'string' && input.file_path) ||
-                (typeof input.path === 'string' && input.path) ||
-                (typeof input.pattern === 'string' && input.pattern) ||
-                (typeof input.query === 'string' && input.query) ||
-                JSON.stringify(input).slice(0, 500);
-            mirrorToolCallToAudit({
-                sessionId,
-                agent: 'opencode',
-                toolName,
-                toolInput: String(inputStr),
-                cwd,
-            });
-        }
-        if (!errorEmitted) {
-            const data = event.data;
-            let text = '';
-            if (event.type === 'stderr' && typeof data?.line === 'string')
-                text = data.line;
-            else if (event.type === 'stdout' && typeof data?.line === 'string')
-                text = data.line;
-            else if (data && typeof data === 'object')
-                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 ?? {}) };
-    // Cost-bounded by default: when the user hasn't pinned a model and Ollama is
-    // serving one locally, route opencode to it (opencode lists it as
-    // `ollama/<model>`). This makes opencode a FREE, LOCAL vendor on a machine
-    // with Ollama — the same pattern proven on aider (aider-adapter.ts ~314) —
-    // so the "vendor-neutral + cost-bounded" promise isn't aider-only. Without
-    // it, opencode falls to its config default (e.g. a paid byteplus model),
-    // silently spending. Always overridable: --model in extraArgs, or
-    // CODEHERE_NO_LOCAL_OLLAMA=1 to opt out.
-    const _extra = options.extraArgs ?? [];
-    const _modelPinned = _extra.some((a) => a === '--model' || a.startsWith('--model='));
-    const _localArgs = [];
-    if (!_modelPinned && spawnEnv.CODEHERE_NO_LOCAL_OLLAMA !== '1') {
-        const ollama = detectOllama();
-        if (ollama.available && ollama.model)
-            _localArgs.push('--model', `ollama/${ollama.model}`);
-    }
-    let child;
-    try {
-        // OpenCode's `run` expects the message as positional args, not stdin.
-        // --title 'codehere-<sessionId>' tags the session with codehere's own
-        // UUID; appendMessage later looks it up by this title (see
-        // parseOpenCodeSessionIdByTitle for the why — opencode buffers the
-        // ses_* id until LLM completion, so we can't capture it mid-stream).
-        const titleTag = `${CODEHERE_TITLE_PREFIX}${sessionId}`;
-        const sp = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, '--title', titleTag, ..._localArgs, finalPrompt, ...(options.extraArgs ?? [])], finalPrompt);
-        child = spawn(sp.command, sp.args, {
-            cwd,
-            env: spawnEnv,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-    }
-    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: 'opencode',
-            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 */
-            },
-        };
-    }
-    // Organic cassette recording (S2b · capture-first plan) · no-op unless
-    // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
-    const recorder = startRecording({ adapter: 'opencode', sessionId, prompt: finalPrompt, cwd });
-    let stdoutBuf = '';
-    let eventsParsed = 0;
-    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);
-                eventsParsed++;
-                emit({ type: data.type ?? 'opencode_event', timestamp: Date.now(), data });
-            }
-            catch {
-                // Non-JSON output still counts as observed work — the no-op guard below
-                // must fire only when opencode produced NOTHING at all (refuter 2026-07-18).
-                eventsParsed++;
-                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 } });
-        }
-    });
-    // 'close', not 'exit' — opencode buffers stdout until the LLM call completes,
-    // so the final burst can be delivered AFTER 'exit' fires. 'close' waits for
-    // all stdio to drain, which the zero-events guard below depends on (refuter
-    // 2026-07-18: checking in 'exit' could flip a true success to error).
-    child.on('close', (code, signal) => {
-        recorder.onExit(code ?? -1, signal);
-        // Flush a final line that arrived without a trailing newline — it would
-        // otherwise sit unparsed in stdoutBuf and read as "no output".
-        const remnant = stdoutBuf.trim();
-        if (remnant) {
-            stdoutBuf = '';
-            try {
-                const data = JSON.parse(remnant);
-                eventsParsed++;
-                emit({ type: data.type ?? 'opencode_event', timestamp: Date.now(), data });
-            }
-            catch {
-                eventsParsed++;
-                emit({ type: 'stdout', timestamp: Date.now(), data: { line: remnant } });
-            }
-        }
-        // Trust the PROCESS's own exit code for success. The catch-all error-pattern
-        // scan above flips `errorEmitted` on any transient "rate limit"/"error" token
-        // anywhere in the stream — which falsely marked a SUCCESSFUL local-model run
-        // as a failure (opencode read+edited the file, said "I've added…", exited 0).
-        // For a trust product, lying that a success failed is the worst bug. So a
-        // clean exit (code 0, not killed) = completed; errorEmitted only carries the
-        // reason for a genuine non-zero failure.
-        statusValue = killRequested || signal !== null ? 'killed' : code === 0 ? 'completed' : 'error';
-        // BUG-8 (E2E 3.4) · the inverse lie: exit 0 with ZERO observed output lines
-        // means opencode did nothing observable. "Done" over a no-op misleads worse
-        // than an honest failure.
-        if (statusValue === 'completed' && eventsParsed === 0) {
-            statusValue = 'error';
-            emit({
-                type: 'error',
-                timestamp: Date.now(),
-                data: {
-                    message: 'opencode exited cleanly but reported no work at all (no events, no output). ' +
-                        'Usually a provider/model config issue — try `opencode run "say hi"` in this folder to see the real behavior.',
-                },
-            });
-        }
-        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 } });
-        }
-        // Capture artifacts ALWAYS, not only on completion — a failed run that still
-        // edited files must report those files, never "no files changed" (the second
-        // half of the same lie). The honesty layer downstream needs the real diff.
-        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: 'opencode',
-        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.x — UUID→ses_* resolution (replaces the prior --continue shortcut).
-         * OpenCode's `run --format json` buffers stdout until the LLM call
-         * completes, so the ses_* session ID isn't observable mid-stream like
-         * claude-code's session_id or codex's thread_id.
-         *
-         * Strategy: spawn() above tags the session with `--title codehere-<our
-         * UUID>`. Here, run `opencode session list --format json` (clean array,
-         * no parsing of column-aligned text), find the row whose title matches
-         * our tag, capture its ses_* id, and use `-s <ses_*>`. Falls back to
-         * --continue if anything fails (binary missing, no match, parse error)
-         * — same posture as before for safety, never worse.
-         *
-         * Concurrency win: spawning a sibling opencode session in the same cwd
-         * between original spawn and reply no longer hijacks the reply target.
-         *
-         * Output parsing: same shape as spawn — text events carry assistant text.
-         */
-        async appendMessage(text) {
-            const startedAt = Date.now();
-            // Resolve our codehere session UUID → opencode ses_* id asynchronously.
-            // Async (not execFileSync) because this runs in the daemon's HTTP
-            // request path; sync exec would block the event loop for up to the
-            // timeout, freezing every other in-flight session.
-            let resumeArgs = ['--continue'];
-            try {
-                // Override timeout via env for slow boxes; default 15s mirrors the
-                // gemini adapter's choice (and is well above any LLM-tied internal
-                // timer opencode might have).
-                const timeoutMs = Number(process.env.CODEHERE_OPENCODE_LIST_TIMEOUT_MS) || 15000;
-                // S9 · never execute the real binary under mock — the session-id
-                // refinement is meaningless against the mock REPL anyway.
-                if (isMockMode())
-                    throw new Error('mock mode: skip real session list');
-                const { stdout: listOut } = await execFileAsync('opencode', ['session', 'list', '--format', 'json'], {
-                    cwd,
-                    env: spawnEnv,
-                    encoding: 'utf-8',
-                    timeout: timeoutMs,
-                    // opencode's session-list output can grow as the user accumulates
-                    // sessions. Default exec maxBuffer is 1MB; bump to 8MB so a long
-                    // history doesn't ENOBUFS the lookup.
-                    maxBuffer: 8 * 1024 * 1024,
-                });
-                const sesId = parseOpenCodeSessionIdByTitle(listOut, sessionId);
-                if (sesId)
-                    resumeArgs = ['-s', sesId];
-            }
-            catch {
-                // Binary missing, slow auth, or no list — fall through to --continue.
-            }
-            return new Promise((resolve, reject) => {
-                let stdout = '';
-                let stderr = '';
-                // S9 · route follow-ups through the mock seam too — under
-                // CODEHERE_MOCK=1 this hits the mock REPL, not real opencode.
-                // (Was a real-spend leak on reply; mirrors the codex fix.)
-                const sp2 = resolveAgentSpawn('opencode', 'opencode', [...HEADLESS_FLAGS, ...resumeArgs, text], text);
-                const followup = spawn(sp2.command, sp2.args, {
-                    cwd,
-                    env: spawnEnv,
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                });
-                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(`opencode ${resumeArgs.join(' ')} exited ${code}: ${stderr.slice(0, 300)}`));
-                        return;
-                    }
-                    // Parse JSONL — extract assistant text from `text` events
-                    // (same shape spawn() consumes via textAccum logic above).
-                    const fragments = [];
-                    for (const line of stdout.split('\n')) {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            continue;
-                        try {
-                            const obj = JSON.parse(trimmed);
-                            if (obj.type === 'text' && obj.part?.text) {
-                                fragments.push(obj.part.text);
-                            }
-                        }
-                        catch {
-                            /* non-JSON — skip */
-                        }
-                    }
-                    const result = fragments.join('\n').trim() || '(opencode returned no text events)';
-                    resolve({ result, durationMs: Date.now() - startedAt });
-                });
-            });
-        },
-    };
-}
-export const OpenCodeAdapter = {
-    id: 'opencode',
-    label: 'OpenCode',
-    description: "Runs several agents at once for genuinely independent jobs. You won't see live progress while it works — the trade-off for the speed of doing things in parallel.",
-    processPattern: /(?:^|\/)opencode(?:\s|$)/,
-    isInstalled() {
-        try {
-            const out = execFileSync('which', ['opencode'], { encoding: 'utf-8', timeout: 2000 });
-            return out.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    },
-    spawn(prompt, options) {
-        return spawnOpenCode(prompt, options);
-    },
-    checkReadiness() {
-        const installed = this.isInstalled();
-        if (!installed) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_install',
-                installed: false,
-                installHint: { command: 'curl -fsSL https://opencode.ai/install | bash', url: 'https://opencode.ai' },
-            };
-        }
-        // OpenCode manages its own provider credentials via `opencode auth`
-        // (alias `opencode providers`). The auth file lives at
-        // $XDG_DATA_HOME/opencode/auth.json (default ~/.local/share/opencode/auth.json
-        // on Linux/macOS) — created with mode 600 the first time a provider is added.
-        //
-        // Pre-May-1 we returned 'ready' on install alone, deferring to runtime to
-        // catch missing-auth via ERROR_PATTERNS.auth_missing. That was dishonest:
-        // /api/readiness/agents would say 'ready' → user would spawn → ~50s later
-        // the task errored with no clear next step. Surfaced May 1 2026 by the
-        // multi-agent dogfood test alongside the same-shape gemini fix.
-        const xdgData = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
-        const opencodeAuthPath = join(xdgData, 'opencode', 'auth.json');
-        if (!existsSync(opencodeAuthPath)) {
-            return {
-                id: this.id,
-                label: this.label,
-                state: 'needs_auth',
-                installed: true,
-                authHint: {
-                    command: 'opencode auth  # interactive provider/key wizard',
-                    url: 'https://opencode.ai/docs/configuration',
-                    detail: `OpenCode found on PATH but no provider configured (${opencodeAuthPath} missing). Run \`opencode auth\` once to add an AI provider — supports 75+ providers BYOK including Anthropic, OpenAI, Mistral, etc.`,
-                },
-            };
-        }
-        return { id: this.id, label: this.label, state: 'ready', installed: true };
-    },
-};
-//# sourceMappingURL=opencode-adapter.js.map