codehere 0.2.2 → 0.3.0-rc.1

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

@@ -0,0 +1,275 @@
+/**
+ * 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, 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 = ['run', '--format', 'json'];
+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();
+    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';
+        }
+        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 ?? {}) };
+    let child;
+    try {
+        // OpenCode's `run` expects the message as positional args, not stdin.
+        child = spawn('opencode', [...HEADLESS_FLAGS, prompt, ...(options.extraArgs ?? [])], {
+            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 */
+            },
+        };
+    }
+    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 ?? 'opencode_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';
+        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: '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() {
+            if (statusValue !== 'running')
+                return;
+            killRequested = true;
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                if (statusValue === 'running') {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        /* already dead */
+                    }
+                }
+            }, 3000);
+        },
+    };
+}
+export const OpenCodeAdapter = {
+    id: 'opencode',
+    label: 'OpenCode',
+    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 providers`.
+        // Can't statically probe the config without reading its data dir — treat
+        // install as ready, let runtime codehere:error catch auth failures.
+        return { id: this.id, label: this.label, state: 'ready', installed: true };
+    },
+};
+//# sourceMappingURL=opencode-adapter.js.map

package/dist/infrastructure/orchestration/progress-aggregator.js

@@ -0,0 +1,189 @@
+/**
+ * ProgressAggregator — PM UX Layer 2 (principles #1 "web is not a terminal", #2 "info density").
+ *
+ * Ingests the raw TaskEvent stream and produces semantic ProgressStep[] that a
+ * product manager would actually read ("Read src/session.ts", "Run npm test",
+ * "Writing reply…") rather than the underlying token-level chatter.
+ *
+ * Agent-aware by design: Claude's stream-json tool_use blocks and Codex's
+ * item.completed entries label differently, so we dispatch on the agent id.
+ * Keeps the per-adapter files free of PM-layer concerns.
+ */
+const MAX_LABEL = 60;
+function shortPath(p) {
+    const parts = String(p).split('/');
+    return parts.length <= 2 ? p : '…/' + parts.slice(-2).join('/');
+}
+function truncate(s, max = MAX_LABEL) {
+    return s.length > max ? s.slice(0, max - 1) + '…' : s;
+}
+function labelForClaudeToolUse(name, input) {
+    const i = (input && typeof input === 'object' ? input : {});
+    switch (name) {
+        case 'Read':
+            return 'Read ' + shortPath(String(i.file_path ?? 'file'));
+        case 'Write':
+            return 'Write ' + shortPath(String(i.file_path ?? 'file'));
+        case 'Edit':
+            return 'Edit ' + shortPath(String(i.file_path ?? 'file'));
+        case 'MultiEdit': {
+            const edits = Array.isArray(i.edits) ? i.edits : [];
+            const first = edits[0];
+            return `Edit ${shortPath(String(first?.file_path ?? 'file'))} (${edits.length})`;
+        }
+        case 'NotebookEdit':
+            return 'Edit notebook ' + shortPath(String(i.notebook_path ?? 'notebook'));
+        case 'Bash': {
+            const cmd = String(i.command ?? '')
+                .replace(/\n/g, ' ')
+                .trim();
+            return truncate('Run ' + cmd);
+        }
+        case 'Grep':
+            return 'Grep ' + truncate(String(i.pattern ?? ''), 40);
+        case 'Glob':
+            return 'List ' + truncate(String(i.pattern ?? ''), 40);
+        case 'WebFetch':
+            return 'Fetch ' + truncate(String(i.url ?? ''), 50);
+        case 'WebSearch':
+            return 'Search ' + truncate(String(i.query ?? ''), 50);
+        case 'TodoWrite':
+            return 'Plan ' + (Array.isArray(i.todos) ? `${i.todos.length} items` : 'tasks');
+        case 'Task':
+            return 'Delegate to subagent';
+        default:
+            return truncate(String(name || 'tool'));
+    }
+}
+function unwrapShellWrapper(command) {
+    // Codex wraps its shell calls in `/bin/zsh -lc "…"` or `sh -c "…"`. Strip that
+    // so the step label reads as the actual command instead of the wrapper.
+    const m = command.match(/^(?:\/bin\/(?:zsh|bash|sh)|sh|bash|zsh)\s+-l?c\s+["'](.+)["']\s*$/);
+    return m ? m[1].trim() : command.trim();
+}
+function labelForCodexCommand(command) {
+    const raw = unwrapShellWrapper(String(command).replace(/\n/g, ' ').trim());
+    // Heuristic friendly prefix for common operations
+    if (/^cat\s+/.test(raw))
+        return truncate('Read ' + raw.replace(/^cat\s+/, '').split(/\s+/)[0]);
+    if (/^sed\s+-n\s+/.test(raw)) {
+        // e.g. `sed -n '1,260p' README.md` → "Read README.md"
+        const tail = raw.split(/\s+/).slice(-1)[0];
+        return truncate('Read ' + tail);
+    }
+    if (/^(?:ls|find)\b/.test(raw))
+        return truncate('List ' + raw.replace(/^(?:ls|find)\s*/, ''));
+    if (/^(?:mkdir|cp|mv|rm|touch)\b/.test(raw) || /\becho\s+.+>/.test(raw))
+        return truncate('File op: ' + raw);
+    if (/^git\s+/.test(raw))
+        return truncate(raw);
+    if (/^npm\s+test\b/.test(raw) || /^pytest\b/.test(raw) || /^vitest\b/.test(raw))
+        return truncate('Run tests');
+    return truncate('Run ' + raw);
+}
+export class ProgressAggregator {
+    agentId;
+    _steps = [];
+    toolUseIndex = new Map(); // tool_use_id → step idx (Claude)
+    constructor(agentId) {
+        this.agentId = agentId;
+    }
+    get steps() {
+        return this._steps;
+    }
+    /** @returns true if the step list changed (caller emits synthetic event). */
+    ingest(event) {
+        const type = String(event.type || '');
+        const data = (event.data ?? {});
+        if (this.agentId === 'claude-code')
+            return this.ingestClaude(type, data);
+        if (this.agentId === 'codex')
+            return this.ingestCodex(type, data);
+        return false;
+    }
+    /** Flush: mark every still-active step as failed (called on abnormal exit). */
+    finalize(status) {
+        let changed = false;
+        for (const s of this._steps) {
+            if (s.state === 'active' || s.state === 'pending') {
+                s.state = status === 'completed' ? 'done' : 'failed';
+                s.completedAt = Date.now();
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    addStep(label, state = 'active') {
+        const idx = this._steps.push({ label, state, startedAt: Date.now() }) - 1;
+        return idx;
+    }
+    ingestClaude(type, data) {
+        if (type === 'assistant') {
+            const msg = (data.message ?? {});
+            const content = Array.isArray(msg.content) ? msg.content : [];
+            let changed = false;
+            for (const blk of content) {
+                const b = (blk && typeof blk === 'object' ? blk : {});
+                if (b.type === 'tool_use') {
+                    const id = String(b.id ?? '');
+                    const label = labelForClaudeToolUse(String(b.name ?? ''), b.input);
+                    const idx = this.addStep(label, 'active');
+                    if (id)
+                        this.toolUseIndex.set(id, idx);
+                    changed = true;
+                }
+            }
+            return changed;
+        }
+        if (type === 'user') {
+            // Match tool_result blocks back to their tool_use step.
+            const msg = (data.message ?? {});
+            const content = Array.isArray(msg.content) ? msg.content : [];
+            let changed = false;
+            for (const blk of content) {
+                const b = (blk && typeof blk === 'object' ? blk : {});
+                if (b.type === 'tool_result') {
+                    const id = String(b.tool_use_id ?? '');
+                    const idx = id ? this.toolUseIndex.get(id) : undefined;
+                    if (idx !== undefined) {
+                        const step = this._steps[idx];
+                        step.state = b.is_error ? 'failed' : 'done';
+                        step.completedAt = Date.now();
+                        changed = true;
+                    }
+                }
+            }
+            return changed;
+        }
+        return false;
+    }
+    ingestCodex(type, data) {
+        if (type !== 'item.completed')
+            return false;
+        const item = (data.item ?? {});
+        const itemType = String(item.type ?? '');
+        if (itemType === 'command_execution') {
+            const label = labelForCodexCommand(String(item.command ?? ''));
+            const ok = item.exit_code === 0 || item.status === 'completed';
+            this._steps.push({
+                label,
+                state: ok ? 'done' : 'failed',
+                startedAt: Date.now(),
+                completedAt: Date.now(),
+            });
+            return true;
+        }
+        if (itemType === 'tool_call' || itemType === 'local_shell_call') {
+            const name = String(item.tool_name ?? item.name ?? 'tool');
+            this._steps.push({
+                label: truncate(name),
+                state: 'done',
+                startedAt: Date.now(),
+                completedAt: Date.now(),
+            });
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=progress-aggregator.js.map

package/dist/infrastructure/orchestration/readiness.js

@@ -0,0 +1,106 @@
+/**
+ * Readiness detection — F1a foundation.
+ *
+ * Tells the UI whether a user can actually spawn Claude Code right now.
+ * Detects the observable pre-conditions and reports a single state plus a
+ * recovery hint. Never blocks the intake — the user can always try; F1b
+ * catches runtime failures. But the UI uses this to warn before a spawn
+ * wastes the user's time (or their API credits).
+ *
+ * Detection is file-system/env only. We do NOT invoke `claude` just to
+ * probe auth — that costs money / OAuth round-trips and is slow. Runtime
+ * error handling (F1b) covers the cases we can't pre-detect.
+ *
+ * States:
+ *   - not_installed     — `claude` binary missing on PATH (blocker)
+ *   - api_key_shadow    — ANTHROPIC_API_KEY is set in env; will shadow OAuth
+ *                         subscription on every spawn unless we strip it
+ *   - ready             — no detectable issues (doesn't prove OAuth works;
+ *                         runtime F1b detects expired/invalid auth)
+ */
+import { existsSync } from 'fs';
+import { execFileSync } from 'child_process';
+function which(binary) {
+    try {
+        const out = execFileSync('which', [binary], { encoding: 'utf-8', timeout: 2000 });
+        const p = out.trim();
+        return p && existsSync(p) ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+function claudeVersion(binPath) {
+    try {
+        const out = execFileSync(binPath, ['--version'], { encoding: 'utf-8', timeout: 3000 });
+        return out.trim().split('\n')[0] || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Mask an API key for UI display. We intentionally reveal ZERO characters of
+ * the secret — not even a tail fingerprint. Rationale: users post codehere
+ * screenshots when reporting bugs, and even 6 trailing chars give an attacker
+ * enough signal to confirm a stolen key matches a known screenshot. Showing
+ * "set" without value is enough; the user already knows they set it.
+ */
+function maskKey(_key) {
+    return '••••';
+}
+export function detectReadiness(env = process.env) {
+    const claudeBinary = which('claude');
+    const apiKey = env.ANTHROPIC_API_KEY ?? '';
+    const apiKeyPresent = apiKey.length > 0;
+    const detected = {
+        claudeBinary,
+        claudeVersion: claudeBinary ? claudeVersion(claudeBinary) : null,
+        apiKeyPresent,
+        apiKeyMasked: apiKeyPresent ? maskKey(apiKey) : null,
+        daemonCwd: process.cwd(),
+    };
+    if (!claudeBinary) {
+        return {
+            state: 'not_installed',
+            severity: 'blocker',
+            title: 'Claude Code is not installed',
+            detail: 'codehere delegates tasks to Claude Code. Install it first, then refresh this page.',
+            action: {
+                label: 'Open install docs',
+                url: 'https://docs.claude.com/en/docs/claude-code/setup',
+            },
+            canAttemptSpawn: false,
+            preferSubscription: false,
+            detected,
+        };
+    }
+    if (apiKeyPresent) {
+        return {
+            state: 'api_key_shadow',
+            severity: 'warn',
+            title: 'Using your Claude Code subscription',
+            detail: `ANTHROPIC_API_KEY is set in your environment. ` +
+                `codehere unsets it for spawned tasks so they use your Claude subscription — ` +
+                `the same auth your interactive \`claude\` uses. Remove the key from your shell ` +
+                `config to dismiss this warning.`,
+            action: {
+                label: 'Where is it set?',
+                command: 'grep -l ANTHROPIC_API_KEY ~/.zshrc ~/.bashrc ~/.zprofile 2>/dev/null',
+            },
+            canAttemptSpawn: true,
+            preferSubscription: true,
+            detected,
+        };
+    }
+    return {
+        state: 'ready',
+        severity: 'ok',
+        title: 'Ready',
+        detail: 'Claude Code is installed and no API-key conflict detected. Subscription path will be used.',
+        canAttemptSpawn: true,
+        preferSubscription: true,
+        detected,
+    };
+}
+//# sourceMappingURL=readiness.js.map