codehere 1.0.1 → 1.0.3

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

@@ -1,689 +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 { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.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 [];
-}
-// Minimal generic failover fingerprints. Config-driven CLIs have no
-// per-provider error bank (we don't know the vendor), so detect only the two
-// signals every provider phrases recognizably: rate-limit and auth. Emits the
-// same `codehere:error` { code, message, recovery } shape the built-in adapters
-// emit — the session-manager's failover classifier consumes that shape and
-// treats 'rate_limit' as failover-eligible ('auth_invalid' is surfaced only).
-const ERROR_PATTERNS = [
-    {
-        code: 'rate_limit',
-        regex: /rate.?limit|429|quota/i,
-        message: 'The agent was rate-limited by its provider.',
-        recovery: 'Wait a minute and retry, or switch the task to a different agent.',
-    },
-    {
-        code: 'auth_invalid',
-        regex: /auth|401|403|api.?key|login/i,
-        message: "The agent's auth was rejected or missing.",
-        recovery: 'Check the API key / login for this CLI, re-authenticate, and retry.',
-    },
-];
-/** @internal — exported for tests; not part of the public API. */
-export 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;
-}
-/**
- * Normalize a Claude-Code-style stream-json event (cursor-agent et al.) into the
- * flat event shapes the spawn handler already understands. Returns null for
- * events that need no translation (the caller emits them verbatim).
- *
- * - `{ type:'tool_call', subtype:'started', tool_call:{ <kind>ToolCall:{ args } } }`
- *   → `{ type:'tool_use', data:{ name:<kind>, input:args } }` so the existing
- *   mirror lands the call in the audit chain (only 'started', so a call is
- *   counted once, not twice with 'completed').
- * - `{ type:'assistant', message:{ content:[{type:'text',text}] } }`
- *   → `{ type:'stdout', data:{ line:<text> } }` so the agent's findings feed
- *   textAccum + the Final Report (else a read-only review records no findings).
- *
- * @internal — exported for tests; not part of the public API.
- */
-export function normalizeStreamJson(data) {
-    if (data.type === 'tool_call' && data.subtype === 'started' && data.tool_call) {
-        const tc = data.tool_call;
-        const kind = Object.keys(tc).find((k) => k.endsWith('ToolCall'));
-        if (kind) {
-            const call = tc[kind];
-            return {
-                type: 'tool_use',
-                timestamp: Date.now(),
-                data: { name: kind.replace(/ToolCall$/, ''), input: call?.args ?? {} },
-            };
-        }
-    }
-    if (data.type === 'assistant') {
-        const content = data.message?.content ?? [];
-        const text = content
-            .filter((c) => c.type === 'text' && typeof c.text === 'string')
-            .map((c) => c.text)
-            .join('\n')
-            .trim();
-        if (text)
-            return { type: 'stdout', timestamp: Date.now(), data: { line: text } };
-    }
-    return null;
-}
-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 = '';
-    // Bounded recent-stdout tail for error scanning (same posture as aider):
-    // scanning the whole accumulated buffer lets distant benign prose combine
-    // into false matches; a single line misses wrapped error bodies.
-    let scanTail = '';
-    const SCAN_TAIL_CHARS = 600;
-    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);
-        }
-        if (event.type === 'stdout' && event.data?.line) {
-            textAccum += String(event.data.line) + '\n';
-        }
-        // Audit-trail parity: generic CLIs that stream jsonl tool_use events
-        // (gemini-style { tool_name, parameters } or claude-style { name, input })
-        // get the same post-hoc mirror the built-in adapters fire — their tool
-        // calls land in the hash-chained audit instead of vanishing.
-        if (event.type === 'tool_use') {
-            const data = event.data;
-            const toolName = String(data?.tool_name ?? data?.name ?? 'tool');
-            const params = data?.parameters ?? data?.input ?? {};
-            const input = (typeof params.command === 'string' && params.command) ||
-                (typeof params.file_path === 'string' && params.file_path) ||
-                (typeof params.path === 'string' && params.path) ||
-                (typeof params.query === 'string' && params.query) ||
-                JSON.stringify(params).slice(0, 500);
-            mirrorToolCallToAudit({ sessionId, agent: cfg.id, toolName, toolInput: String(input), 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') {
-                scanTail = (scanTail + '\n' + data.line).slice(-SCAN_TAIL_CHARS);
-                text = scanTail;
-            }
-            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, ...(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.
-        //
-        // Routed through the mock seam like every built-in adapter — under
-        // CODEHERE_MOCK=1 spawning the configured binary directly would execute
-        // the real CLI (the real-spend leak class).
-        const sp = resolveAgentSpawn(cfg.id, cfg.command, [...argv, ...(options.extraArgs ?? [])], finalPrompt);
-        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
-        child = spawn(sp.command, sp.args, {
-            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);
-                    // Claude-Code-style stream-json (cursor-agent, etc.) nests tool calls
-                    // and findings differently from the flat { tool_use } shape. Normalize
-                    // them into the events the handlers already understand, so a CLI agent's
-                    // reads land in the audit chain (attribution) and its findings feed the
-                    // Final Report — without that, a cross-vendor review reads "couldn't
-                    // attribute" and never earns the seal.
-                    const norm = normalizeStreamJson(data);
-                    if (norm) {
-                        emit(norm);
-                        continue;
-                    }
-                    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