codehere 0.2.2 → 0.3.0-rc.10

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

@@ -0,0 +1,553 @@
+/**
+ * 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';
+const CONFIG_PATH = join(homedir(), '.codehere', 'agents.yaml');
+const CONFIG_PATH_JSON = join(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();
+    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, prompt];
+    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(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: 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,
+        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) {
+        // eslint-disable-next-line no-console
+        console.warn(`[codehere] Regex for "${agentId}" rejected (${danger}) — using fallback`);
+        return fallback;
+    }
+    let candidate;
+    try {
+        candidate = new RegExp(source);
+    }
+    catch {
+        // eslint-disable-next-line no-console
+        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) {
+            // eslint-disable-next-line no-console
+            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