codehere 0.8.0 → 1.0.2

package/dist/infrastructure/orchestration/generic-cli-adapter.js

@@ -1,558 +0,0 @@
-/**
- * Generic CLI adapter — user-configurable catch-all.
- *
- * Kills the "codehere only supports N agents" narrative. Users plug ANY CLI
- * that takes a prompt and streams stdout, via a config file, without writing
- * TypeScript. codehere still wraps every subprocess in the safety hook + audit
- * trail; the per-agent concerns (auth flags, stdin-vs-argv prompt delivery,
- * process-detection regex) move into config.
- *
- * Config file: ~/.codehere/agents.yaml (or .json — parser auto-detects).
- *
- * Shape:
- *   agents:
- *     - id: gemini
- *       label: Gemini CLI
- *       command: gemini
- *       args: [--prompt]            # "<prompt>" slots in after these args
- *       prompt_via: argv              # or "stdin"
- *       process_pattern: '(?:^|/)gemini(?:\\s|$)'
- *       format: text                   # or "jsonl" if the CLI streams JSON lines
- *
- *     - id: my-internal-agent
- *       label: Internal Agent
- *       command: /opt/tools/my-agent
- *       args: [run, --json]
- *       prompt_via: stdin
- *       format: jsonl
- *
- * Each top-level entry becomes a first-class AgentAdapter registered alongside
- * the built-in ones (Claude Code, Codex, Aider, OpenCode).
- */
-import { spawn, execFileSync } from 'child_process';
-import { EventEmitter } from 'events';
-import { readFileSync, existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-import { ProgressAggregator } from './progress-aggregator.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-const CONFIG_PATH = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'agents.yaml');
-const CONFIG_PATH_JSON = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'agents.json');
-/** Minimal YAML parser for the narrow shape above. Intentionally NOT a full YAML
- *  parser — avoids dragging in a dep. Handles: `key: value`, lists with `- key: val`,
- *  nested lists of simple strings via `[a, b]`, comments after `#`. Errors loud.
- *
- *  @internal — exported for the T4-B fuzz suite; not part of the public API. */
-export function parseSimpleYaml(text) {
-    const lines = text.split('\n').map((l) => l.replace(/#.*$/, '').replace(/\s+$/, ''));
-    const agents = [];
-    let current = null;
-    let inAgentsList = false;
-    for (const raw of lines) {
-        if (!raw.trim())
-            continue;
-        if (/^agents\s*:\s*$/.test(raw)) {
-            inAgentsList = true;
-            continue;
-        }
-        if (!inAgentsList)
-            continue;
-        const listItem = raw.match(/^\s*-\s+(\w+)\s*:\s*(.*)$/);
-        const field = raw.match(/^\s{4,}(\w+)\s*:\s*(.*)$/);
-        if (listItem) {
-            if (current)
-                agents.push(current);
-            current = {};
-            const [, k, v] = listItem;
-            applyField(current, k, v);
-            continue;
-        }
-        if (field && current) {
-            const [, k, v] = field;
-            applyField(current, k, v);
-        }
-    }
-    if (current)
-        agents.push(current);
-    return { agents: agents.filter((a) => a.id && a.command) };
-}
-function applyField(acc, k, v) {
-    const val = v.trim();
-    if (k === 'args') {
-        // Expect e.g. [a, b, --json]
-        const m = val.match(/^\[(.*)\]$/);
-        acc.args = m
-            ? m[1]
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean)
-            : [];
-    }
-    else if (k === 'env') {
-        // Inline JSON only for simplicity
-        try {
-            acc.env = JSON.parse(val);
-        }
-        catch {
-            acc.env = {};
-        }
-    }
-    else if (k === 'prompt_via') {
-        acc.prompt_via = val === 'stdin' ? 'stdin' : 'argv';
-    }
-    else if (k === 'format') {
-        acc.format = val === 'jsonl' ? 'jsonl' : 'text';
-    }
-    else if (k === 'install_command' || k === 'install_url') {
-        acc[k] = val.replace(/^['"]|['"]$/g, '');
-    }
-    else {
-        acc[k] = val.replace(/^['"]|['"]$/g, '');
-    }
-}
-export function loadAgentsConfig() {
-    try {
-        if (existsSync(CONFIG_PATH_JSON)) {
-            const raw = JSON.parse(readFileSync(CONFIG_PATH_JSON, 'utf-8'));
-            return raw.agents ?? [];
-        }
-        if (existsSync(CONFIG_PATH)) {
-            return parseSimpleYaml(readFileSync(CONFIG_PATH, 'utf-8')).agents;
-        }
-    }
-    catch {
-        // Config exists but unparseable — silently skip. A noisier mode can be added later.
-    }
-    return [];
-}
-function spawnGeneric(cfg, 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).
-    // Apr 29: caught via the adapter-injection-wiring trip-wire — generic
-    // adapters were silently exempt from F3 even though Task 8 said
-    // "every spawned agent." Now consistent.
-    const injected = applyMemoryPrefix(prompt, cwd, options);
-    const finalPrompt = injected.prompt;
-    const snapshot = snapshotCwd(cwd);
-    const aggregator = new ProgressAggregator(cfg.id);
-    let stepsSnapshot = [];
-    let artifactsSnapshot;
-    let textAccum = '';
-    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);
-        }
-        if (event.type === 'stdout' && event.data?.line) {
-            textAccum += String(event.data.line) + '\n';
-        }
-    };
-    const spawnEnv = { ...process.env, ...(cfg.env ?? {}), ...(options.env ?? {}) };
-    const usesStdin = cfg.prompt_via === 'stdin';
-    const fixedArgs = cfg.args ?? [];
-    const argv = usesStdin ? [...fixedArgs] : [...fixedArgs, finalPrompt];
-    let child;
-    try {
-        // SAFE · array form (not shell:true) means no shell interpretation.
-        // The prompt and args land as separate argv entries; shell metacharacters
-        // pass through to the spawned process verbatim. Per-arg arrays are the
-        // recommended safe form (Node docs, OWASP, CWE-78).
-        // The `cfg.command` path is from a user-edited YAML and is therefore
-        // user-controlled; the user choosing what binary to launch on their own
-        // machine is documented + accepted in CODEHERE.md threat-model section.
-        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
-        child = spawn(cfg.command, [...argv, ...(options.extraArgs ?? [])], {
-            cwd,
-            env: spawnEnv,
-            stdio: [usesStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-        });
-        if (usesStdin) {
-            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: cfg.id,
-            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;
-            if (cfg.format === 'jsonl') {
-                try {
-                    const data = JSON.parse(line);
-                    emit({ type: data.type ?? `${cfg.id}_event`, timestamp: Date.now(), data });
-                    continue;
-                }
-                catch {
-                    /* not JSON — fall through to stdout */
-                }
-            }
-            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' : 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);
-                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: cfg.id,
-        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);
-        },
-    };
-}
-/**
- * Detect regex shapes that are statically known to enable catastrophic
- * backtracking. The check is conservative — it errs toward false positives,
- * because any pattern flagged here can only ever match process names (a
- * narrow domain that the fallback already handles fine).
- *
- * Strategy: simple substring checks instead of trying to parse paren balance.
- * The tell of every classic ReDoS shape is a quantifier *followed by* another
- * quantifier — possibly with `)`, `}`, or whitespace between. We catch the
- * combinations directly.
- *
- * Shapes covered:
- *   1. Quantifier-after-quantifier separated by `)` — `(a+)+`, `(a*)*`,
- *      `(([a-z])+.)+`, `(a+)*`, `(a+){0,5}`, etc. The first quantifier sits
- *      inside the inner group; the second sits outside the outer group.
- *   2. Quantifier-after-`}` — `a{1,3}+`, `(a{1,3}){0,5}` — bounded
- *      repetitions stacked under another quantifier.
- *   3. Overlapping alternation under a quantifier — `(a|a)+`, `(a|aa)*`,
- *      where one branch is a prefix of another.
- *
- * Returns the first reason the source is rejected, or null if it looks safe.
- */
-function detectRedosShape(source) {
-    // A user-supplied process_pattern over 4KB is suspicious on its face —
-    // legitimate process patterns are rarely longer than 100 chars. Reject
-    // outright so we never walk a hostile-sized input.
-    if (source.length > 4096) {
-        return 'oversized-pattern';
-    }
-    // Paren-depth walk · O(n), no regex, cannot ReDoS itself.
-    // For each parenthesised group we track whether its body contains an
-    // unbounded quantifier (`+`, `*`, or `{m,}` with no upper bound, or `{m,n}`
-    // with n large). If such a group is itself followed by `+`, `*`, `?`, or
-    // `{...}`, we have the canonical nested-quantifier shape that causes
-    // catastrophic backtracking on inputs that almost-match.
-    const stack = [];
-    let inCharClass = false;
-    for (let i = 0; i < source.length; i++) {
-        const c = source[i];
-        if (c === '\\') {
-            i++;
-            continue;
-        }
-        if (inCharClass) {
-            if (c === ']')
-                inCharClass = false;
-            continue;
-        }
-        if (c === '[') {
-            inCharClass = true;
-            continue;
-        }
-        if (c === '(') {
-            stack.push({ hasQuantifier: false, hasOverlapAlt: false, altChecked: false });
-            continue;
-        }
-        if (c === ')') {
-            const frame = stack.pop();
-            if (!frame)
-                continue;
-            // Peek next non-whitespace char for an outer quantifier.
-            let j = i + 1;
-            while (j < source.length && /\s/.test(source[j]))
-                j++;
-            const next = source[j];
-            const outerQuantified = next === '+' || next === '*' || next === '?' || next === '{';
-            if (outerQuantified && frame.hasQuantifier) {
-                return 'nested-quantifier';
-            }
-            if (outerQuantified && frame.hasOverlapAlt) {
-                return 'overlapping-alternation';
-            }
-            // Propagate "contains quantifier" up — the outer quantifier on this
-            // group counts as a quantifier inside any further-outer group.
-            if (outerQuantified && stack.length > 0) {
-                stack[stack.length - 1].hasQuantifier = true;
-            }
-            continue;
-        }
-        if (stack.length > 0 && (c === '+' || c === '*')) {
-            stack[stack.length - 1].hasQuantifier = true;
-            continue;
-        }
-        if (stack.length > 0 && c === '{') {
-            // `{m,n}` — flag as quantifier when n is missing or large enough to
-            // multiply meaningfully.
-            const close = source.indexOf('}', i);
-            if (close > i && close - i < 16) {
-                const body = source.slice(i + 1, close);
-                const m = body.match(/^(\d+)\s*,?\s*(\d*)$/);
-                if (m) {
-                    const upper = m[2] ? parseInt(m[2], 10) : Infinity;
-                    if (upper >= 3)
-                        stack[stack.length - 1].hasQuantifier = true;
-                }
-                i = close;
-            }
-            continue;
-        }
-        if (stack.length > 0 && c === '|') {
-            const frame = stack[stack.length - 1];
-            // Run the body-scan at most once per group · keeps total work O(n).
-            if (frame.altChecked)
-                continue;
-            frame.altChecked = true;
-            const groupStart = findGroupStart(source, i);
-            const groupEnd = findGroupEnd(source, i);
-            if (groupStart >= 0 && groupEnd > groupStart) {
-                const body = source.slice(groupStart + 1, groupEnd);
-                const branches = body.split('|');
-                for (let k = 0; k < branches.length - 1; k++) {
-                    const a = branches[k];
-                    const b = branches[k + 1];
-                    if (a && b && (a === b || a.startsWith(b) || b.startsWith(a))) {
-                        frame.hasOverlapAlt = true;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
-function findGroupStart(s, from) {
-    let depth = 1;
-    for (let i = from - 1; i >= 0; i--) {
-        if (s[i] === '\\') {
-            i--;
-            continue;
-        }
-        if (s[i] === ')')
-            depth++;
-        else if (s[i] === '(') {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-function findGroupEnd(s, from) {
-    let depth = 1;
-    for (let i = from + 1; i < s.length; i++) {
-        if (s[i] === '\\') {
-            i++;
-            continue;
-        }
-        if (s[i] === '(')
-            depth++;
-        else if (s[i] === ')') {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-/**
- * Compile a regex from user-supplied YAML, with a static + dynamic ReDoS guard.
- *
- * CRIT-4 fix · `cfg.process_pattern` is user-controlled (anyone editing
- * ~/.codehere/agents.yaml). A pattern like `(a+)+b` causes catastrophic
- * backtracking that hangs the daemon every time it enumerates processes.
- *
- * Two-layer guard:
- *   1. STATIC · `detectRedosShape` rejects known-dangerous shapes *before*
- *      handing the source to the regex engine. This is the only fully
- *      reliable defense, because Node's regex engine is not interruptible
- *      mid-evaluation — once a pathological pattern reaches it, the process
- *      can hang for minutes.
- *   2. DYNAMIC · 100ms smoke test against a benign 1000-char string catches
- *      patterns the static heuristic missed. Best-effort only; included as
- *      defense-in-depth.
- *
- * On any failure we fall back to a safe pattern derived from the command name.
- */
-/** @internal — exported for the T4-B fuzz suite; not part of the public API. */
-export function compileSafePattern(source, fallback, agentId) {
-    // Layer 1 · static shape check — this is the only fully reliable defense.
-    const danger = detectRedosShape(source);
-    if (danger) {
-        console.warn(`[codehere] Regex for "${agentId}" rejected (${danger}) — using fallback`);
-        return fallback;
-    }
-    let candidate;
-    try {
-        candidate = new RegExp(source);
-    }
-    catch {
-        console.warn(`[codehere] Invalid regex in agents.yaml for "${agentId}" — using fallback`);
-        return fallback;
-    }
-    // Layer 2 · dynamic smoke test — catches anything the static heuristic missed.
-    try {
-        const start = Date.now();
-        candidate.test('a'.repeat(1000));
-        if (Date.now() - start > 100) {
-            console.warn(`[codehere] Regex for "${agentId}" too slow (likely ReDoS) — using fallback`);
-            return fallback;
-        }
-    }
-    catch {
-        return fallback;
-    }
-    return candidate;
-}
-/** Build an AgentAdapter from a user config entry. */
-export function buildGenericAdapter(cfg) {
-    const fallbackPattern = new RegExp(`(?:^|/)${cfg.command.split('/').pop()}(?:\\s|$)`);
-    const pattern = cfg.process_pattern
-        ? compileSafePattern(cfg.process_pattern, fallbackPattern, cfg.id)
-        : fallbackPattern;
-    const adapter = {
-        id: cfg.id,
-        label: cfg.label || cfg.id,
-        processPattern: pattern,
-        isInstalled() {
-            try {
-                if (cfg.command.startsWith('/'))
-                    return existsSync(cfg.command);
-                const out = execFileSync('which', [cfg.command], { encoding: 'utf-8', timeout: 2000 });
-                return out.trim().length > 0;
-            }
-            catch {
-                return false;
-            }
-        },
-        spawn(prompt, options) {
-            return spawnGeneric(cfg, prompt, options);
-        },
-        checkReadiness() {
-            const installed = adapter.isInstalled();
-            if (!installed) {
-                return {
-                    id: cfg.id,
-                    label: cfg.label || cfg.id,
-                    state: 'needs_install',
-                    installed: false,
-                    // Fall back gracefully: if no install_command is configured, keep the
-                    // button disabled (UI checks for a real command before enabling).
-                    installHint: cfg.install_command ? { command: cfg.install_command, url: cfg.install_url } : undefined,
-                };
-            }
-            // Generic adapters can't introspect auth — treat install as ready, let
-            // runtime error detection surface real auth failures to the user.
-            return { id: cfg.id, label: cfg.label || cfg.id, state: 'ready', installed: true };
-        },
-    };
-    return adapter;
-}
-//# sourceMappingURL=generic-cli-adapter.js.map