agentboss 0.1.2 → 0.1.4

package/server/llm/cli-runner.js

@@ -1,265 +1,316 @@
-/**
- * LLM judge runner — spawns a local AI CLI for evaluation tasks.
- *
- * Detection order (first one found wins):
- *   1. `opencode run -p "<prompt>"`
- *   2. `claude -p "<prompt>"`
- *
- * Returns parsed JSON.  Failures (CLI missing / timeout / non-JSON
- * output) resolve to `null` so callers can fall back to rule-based
- * heuristics.  Never throws.
- *
- * @author Felix
- */
-
-'use strict';
-
-const { spawn } = require('child_process');
-const { JUDGE_SENTINEL } = require('./judge-prompts');
-
-/**
- * Prepend the JUDGE_SENTINEL to the prompt if it isn't already the very
- * first line.  This is the last-line defence that guarantees *every*
- * LLM call originating from aboss is recognisable when its session
- * later gets re-imported by the ETL (see server/etl/judge-filter.js).
- *
- * Callers (e.g. buildE1Prompt / buildO1Prompt) already prepend the
- * sentinel, but enforcing it here means any future caller — or any
- * accidentally-omitted sentinel — still produces a tagged session
- * rather than polluting the user's own work.
- */
-function ensureSentinel(prompt) {
-  if (typeof prompt !== 'string') return prompt;
-  if (prompt.startsWith(JUDGE_SENTINEL)) return prompt;
-  return `${JUDGE_SENTINEL}（内部标记，忽略本行）\n${prompt}`;
-}
-
-// ---------------------------------------------------------------------------
-//  Detection
-// ---------------------------------------------------------------------------
-
-/**
- * CLI candidates.
- *
- * `argv` builds the command-line args.  When `stdinPrompt: true`, the
- * prompt is fed on STDIN instead of being inlined into argv — this is
- * essential on Windows where the command-line cap is ~8 KB and our
- * judge prompts run 10 KB+.
- */
-const CANDIDATES = [
-  // opencode reads stdin when no positional arg is given (after `run`)
-  { name: 'opencode', bin: 'opencode', argv: () => ['run'],   stdinPrompt: true },
-  // claude -p reads stdin when -p is used without an inline prompt
-  { name: 'claude',   bin: 'claude',   argv: () => ['-p'],    stdinPrompt: true },
-];
-
-let _cachedCli = undefined; // null = detected none; obj = found
-
-/**
- * Detect which CLI is available.  Tries `bin --version` for each candidate.
- * Caches the result for the process lifetime.
- *
- * @returns {Promise<{name:string, bin:string, argv:Function}|null>}
- */
-async function detectAvailableCli() {
-  if (_cachedCli !== undefined) return _cachedCli;
-  for (const c of CANDIDATES) {
-    if (await canSpawn(c.bin)) {
-      _cachedCli = c;
-      return c;
-    }
-  }
-  _cachedCli = null;
-  return null;
-}
-
-/** Reset the detection cache.  Mostly useful in tests / settings reload. */
-function _resetCache() { _cachedCli = undefined; }
-
-/**
- * Try to spawn `bin --version`.  Resolves true on exit code 0.  Cross-
- * platform: on Windows `bin` is resolved via PATH automatically by spawn.
- */
-function canSpawn(bin) {
-  return new Promise((resolve) => {
-    let resolved = false;
-    const settle = (v) => { if (!resolved) { resolved = true; resolve(v); } };
-
-    try {
-      const proc = spawn(bin, ['--version'], {
-        stdio: 'ignore',
-        shell: process.platform === 'win32',
-      });
-      proc.on('error', () => settle(false));
-      proc.on('exit', (code) => settle(code === 0));
-      // hard timeout
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} settle(false); }, 5000);
-    } catch {
-      settle(false);
-    }
-  });
-}
-
-// ---------------------------------------------------------------------------
-//  Runner
-// ---------------------------------------------------------------------------
-
-/**
- * Spawn the chosen CLI with the prompt, capture stdout, and try to parse
- * it as JSON.  The caller's prompt should *demand* JSON output.
- *
- * Options:
- *   timeoutMs (default 30_000)
- *   maxBytes  (default 256 KB) — guard against runaway output
- *
- * Resolves:
- *   { ok: true, data: any, raw: string, cli: 'opencode'|'claude' }
- *   { ok: false, reason: 'no-cli' | 'timeout' | 'exit-non-zero' | 'bad-json' | 'spawn-error', raw?: string, error?: string }
- *
- * @param {Object} opts
- * @returns {Promise<Object>}
- */
-async function runJudge(opts = {}) {
-  const { prompt: rawPrompt, timeoutMs = 30_000, maxBytes = 256 * 1024 } = opts;
-  if (!rawPrompt || typeof rawPrompt !== 'string') {
-    return { ok: false, reason: 'no-prompt' };
-  }
-  // Stamp the sentinel onto every outbound prompt so the ETL can later
-  // recognise and discard the session this CLI call will create.
-  const prompt = ensureSentinel(rawPrompt);
-
-  const cli = await detectAvailableCli();
-  if (!cli) return { ok: false, reason: 'no-cli' };
-
-  return new Promise((resolve) => {
-    let resolved = false;
-    const settle = (v) => { if (!resolved) { resolved = true; resolve(v); } };
-
-    let proc;
-    try {
-      const useStdin = cli.stdinPrompt === true;
-      proc = spawn(cli.bin, cli.argv(prompt), {
-        stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-        shell: process.platform === 'win32',
-        windowsHide: true,
-      });
-      if (useStdin && proc.stdin) {
-        proc.stdin.on('error', () => {}); // EPIPE if CLI exits early
-        proc.stdin.end(prompt, 'utf8');
-      }
-    } catch (err) {
-      return settle({ ok: false, reason: 'spawn-error', error: err.message });
-    }
-
-    let stdout = '';
-    let stderr = '';
-    let truncated = false;
-
-    proc.stdout.on('data', (chunk) => {
-      if (truncated) return;
-      stdout += chunk.toString('utf8');
-      if (stdout.length > maxBytes) {
-        stdout = stdout.slice(0, maxBytes);
-        truncated = true;
-        try { proc.kill('SIGKILL'); } catch {}
-      }
-    });
-    proc.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
-
-    proc.on('error', (err) => settle({ ok: false, reason: 'spawn-error', error: err.message }));
-
-    proc.on('exit', (code) => {
-      if (code !== 0 && !truncated) {
-        return settle({ ok: false, reason: 'exit-non-zero', raw: stdout, error: stderr.slice(0, 500) });
-      }
-      const parsed = extractJson(stdout);
-      if (parsed === undefined) {
-        // Include a snippet of stderr too — when claude / opencode
-        // print a warning ("not logged in", "rate-limited", "use
-        // --print"), the stdout JSON parse fails but the actual cause
-        // lives in stderr.
-        return settle({
-          ok: false,
-          reason: 'bad-json',
-          raw: stdout.slice(0, 500),
-          error: stderr ? stderr.slice(0, 500) : undefined,
-        });
-      }
-      settle({ ok: true, data: parsed, raw: stdout, cli: cli.name });
-    });
-
-    const t = setTimeout(() => {
-      try { proc.kill('SIGKILL'); } catch {}
-      // Surface stderr on timeout — usually has "waiting for input" or
-      // a prompt that explains why the CLI is hanging.
-      settle({
-        ok: false,
-        reason: 'timeout',
-        error: stderr ? stderr.slice(0, 500) : undefined,
-      });
-    }, timeoutMs);
-    proc.on('exit', () => clearTimeout(t));
-  });
-}
-
-/**
- * Try to find a JSON value in raw stdout.  Tolerates leading log lines
- * by scanning for the first { or [.  Returns the parsed value or
- * undefined on failure.
- */
-function extractJson(raw) {
-  if (!raw) return undefined;
-  // common case: stdout is pure JSON
-  const trimmed = raw.trim();
-  try { return JSON.parse(trimmed); } catch {}
-  // fall back: find first { or [
-  const i1 = trimmed.indexOf('{');
-  const i2 = trimmed.indexOf('[');
-  let start = -1;
-  if (i1 >= 0 && i2 >= 0) start = Math.min(i1, i2);
-  else if (i1 >= 0) start = i1;
-  else if (i2 >= 0) start = i2;
-  if (start < 0) return undefined;
-
-  // find matching last brace/bracket of the same kind
-  const open = trimmed[start];
-  const close = open === '{' ? '}' : ']';
-  const end = trimmed.lastIndexOf(close);
-  if (end < start) return undefined;
-  try { return JSON.parse(trimmed.slice(start, end + 1)); } catch {}
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-//  Concurrency guard
-// ---------------------------------------------------------------------------
-
-let _inFlight = 0;
-const _waiters = [];
-const MAX_CONCURRENT = 2;
-
-/** Run `fn` under a 2-wide semaphore so we don't fork-bomb the CLI. */
-function withSlot(fn) {
-  return new Promise((resolve) => {
-    const start = async () => {
-      _inFlight++;
-      try { resolve(await fn()); }
-      finally {
-        _inFlight--;
-        const next = _waiters.shift();
-        if (next) next();
-      }
-    };
-    if (_inFlight < MAX_CONCURRENT) start();
-    else _waiters.push(start);
-  });
-}
-
-module.exports = {
-  detectAvailableCli,
-  runJudge,
-  withSlot,
-  // exported for tests
-  _resetCache,
-  extractJson,
-};
+/**
+ * LLM judge runner — spawns a local AI CLI for evaluation tasks.
+ *
+ * Detection order (first one found wins):
+ *   1. `opencode run -p "<prompt>"`
+ *   2. `claude -p "<prompt>"`
+ *
+ * Returns parsed JSON.  Failures (CLI missing / timeout / non-JSON
+ * output) resolve to `null` so callers can fall back to rule-based
+ * heuristics.  Never throws.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const { spawn } = require('child_process');
+const { JUDGE_SENTINEL } = require('./judge-prompts');
+
+/**
+ * Prepend the JUDGE_SENTINEL to the prompt if it isn't already the very
+ * first line.  This is the last-line defence that guarantees *every*
+ * LLM call originating from aboss is recognisable when its session
+ * later gets re-imported by the ETL (see server/etl/judge-filter.js).
+ *
+ * Callers (e.g. buildE1Prompt / buildO1Prompt) already prepend the
+ * sentinel, but enforcing it here means any future caller — or any
+ * accidentally-omitted sentinel — still produces a tagged session
+ * rather than polluting the user's own work.
+ */
+function ensureSentinel(prompt) {
+  if (typeof prompt !== 'string') return prompt;
+  if (prompt.startsWith(JUDGE_SENTINEL)) return prompt;
+  return `${JUDGE_SENTINEL}（内部标记，忽略本行）\n${prompt}`;
+}
+
+// ---------------------------------------------------------------------------
+//  Detection
+// ---------------------------------------------------------------------------
+
+/**
+ * CLI candidates.
+ *
+ * `argv` builds the command-line args.  When `stdinPrompt: true`, the
+ * prompt is fed on STDIN instead of being inlined into argv — this is
+ * essential on Windows where the command-line cap is ~8 KB and our
+ * judge prompts run 10 KB+.
+ */
+const CANDIDATES = [
+  // opencode reads stdin when no positional arg is given (after `run`)
+  { name: 'opencode', bin: 'opencode', argv: () => ['run'],   stdinPrompt: true },
+  // claude -p reads stdin when -p is used without an inline prompt
+  { name: 'claude',   bin: 'claude',   argv: () => ['-p'],    stdinPrompt: true },
+];
+
+let _cachedCli = undefined;   // null = detected none; obj = found (default order)
+let _cachedAll = undefined;   // Array<{name, bin, available}> | undefined
+
+/**
+ * Detect which CLI to use.
+ *
+ * @param {string} [preferred]  one of 'auto' | 'opencode' | 'claude'.
+ *   - 'opencode' / 'claude': return that CLI iff it's available; otherwise
+ *     fall back to the first other available CLI (so a user pick never
+ *     silently disables LLM features when their preferred CLI vanishes).
+ *   - 'auto' (default): first available in CANDIDATES order.
+ *
+ * Caches the *default-order* result for the process lifetime; preferred
+ * picks are computed against `detectAllCli()` (also cached) so the result
+ * is consistent across calls without re-spawning.
+ *
+ * @returns {Promise<{name:string, bin:string, argv:Function}|null>}
+ */
+async function detectAvailableCli(preferred = 'auto') {
+  const pref = String(preferred || 'auto').toLowerCase();
+
+  if (pref === 'auto') {
+    if (_cachedCli !== undefined) return _cachedCli;
+    for (const c of CANDIDATES) {
+      if (await canSpawn(c.bin)) {
+        _cachedCli = c;
+        return c;
+      }
+    }
+    _cachedCli = null;
+    return null;
+  }
+
+  // Explicit preference: consult the full availability map and try the
+  // preferred one first, then fall back to any other available CLI.
+  const all = await detectAllCli();
+  const wanted = all.find((x) => x.name === pref && x.available);
+  if (wanted) return CANDIDATES.find((c) => c.name === wanted.name) || null;
+  // Preferred not installed — fall back to whatever IS available
+  for (const c of CANDIDATES) {
+    const entry = all.find((x) => x.name === c.name);
+    if (entry && entry.available) return c;
+  }
+  return null;
+}
+
+/**
+ * Detect every candidate CLI in parallel.  Used by the Settings page to
+ * show all options the user can pick from.
+ *
+ * @returns {Promise<Array<{name:string, bin:string, available:boolean}>>}
+ */
+async function detectAllCli() {
+  if (_cachedAll !== undefined) return _cachedAll;
+  const results = await Promise.all(
+    CANDIDATES.map(async (c) => ({
+      name: c.name,
+      bin: c.bin,
+      available: await canSpawn(c.bin),
+    }))
+  );
+  _cachedAll = results;
+  return results;
+}
+
+/** Reset detection caches.  Used by tests and after settings reload. */
+function _resetCache() { _cachedCli = undefined; _cachedAll = undefined; }
+
+/**
+ * Try to spawn `bin --version`.  Resolves true on exit code 0.  Cross-
+ * platform: on Windows `bin` is resolved via PATH automatically by spawn.
+ */
+function canSpawn(bin) {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const settle = (v) => { if (!resolved) { resolved = true; resolve(v); } };
+
+    try {
+      const proc = spawn(bin, ['--version'], {
+        stdio: 'ignore',
+        shell: process.platform === 'win32',
+      });
+      proc.on('error', () => settle(false));
+      proc.on('exit', (code) => settle(code === 0));
+      // hard timeout
+      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} settle(false); }, 5000);
+    } catch {
+      settle(false);
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+//  Runner
+// ---------------------------------------------------------------------------
+
+/**
+ * Spawn the chosen CLI with the prompt, capture stdout, and try to parse
+ * it as JSON.  The caller's prompt should *demand* JSON output.
+ *
+ * Options:
+ *   timeoutMs (default 30_000)
+ *   maxBytes  (default 256 KB) — guard against runaway output
+ *
+ * Resolves:
+ *   { ok: true, data: any, raw: string, cli: 'opencode'|'claude' }
+ *   { ok: false, reason: 'no-cli' | 'timeout' | 'exit-non-zero' | 'bad-json' | 'spawn-error', raw?: string, error?: string }
+ *
+ * @param {Object} opts
+ * @returns {Promise<Object>}
+ */
+async function runJudge(opts = {}) {
+  const {
+    prompt: rawPrompt,
+    timeoutMs = 30_000,
+    maxBytes = 256 * 1024,
+    preferredCli = 'auto',
+  } = opts;
+  if (!rawPrompt || typeof rawPrompt !== 'string') {
+    return { ok: false, reason: 'no-prompt' };
+  }
+  // Stamp the sentinel onto every outbound prompt so the ETL can later
+  // recognise and discard the session this CLI call will create.
+  const prompt = ensureSentinel(rawPrompt);
+
+  const cli = await detectAvailableCli(preferredCli);
+  if (!cli) return { ok: false, reason: 'no-cli' };
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    const settle = (v) => { if (!resolved) { resolved = true; resolve(v); } };
+
+    let proc;
+    try {
+      const useStdin = cli.stdinPrompt === true;
+      proc = spawn(cli.bin, cli.argv(prompt), {
+        stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+        windowsHide: true,
+      });
+      if (useStdin && proc.stdin) {
+        proc.stdin.on('error', () => {}); // EPIPE if CLI exits early
+        proc.stdin.end(prompt, 'utf8');
+      }
+    } catch (err) {
+      return settle({ ok: false, reason: 'spawn-error', error: err.message });
+    }
+
+    let stdout = '';
+    let stderr = '';
+    let truncated = false;
+
+    proc.stdout.on('data', (chunk) => {
+      if (truncated) return;
+      stdout += chunk.toString('utf8');
+      if (stdout.length > maxBytes) {
+        stdout = stdout.slice(0, maxBytes);
+        truncated = true;
+        try { proc.kill('SIGKILL'); } catch {}
+      }
+    });
+    proc.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+
+    proc.on('error', (err) => settle({ ok: false, reason: 'spawn-error', error: err.message }));
+
+    proc.on('exit', (code) => {
+      if (code !== 0 && !truncated) {
+        return settle({ ok: false, reason: 'exit-non-zero', raw: stdout, error: stderr.slice(0, 500) });
+      }
+      const parsed = extractJson(stdout);
+      if (parsed === undefined) {
+        // Include a snippet of stderr too — when claude / opencode
+        // print a warning ("not logged in", "rate-limited", "use
+        // --print"), the stdout JSON parse fails but the actual cause
+        // lives in stderr.
+        return settle({
+          ok: false,
+          reason: 'bad-json',
+          raw: stdout.slice(0, 500),
+          error: stderr ? stderr.slice(0, 500) : undefined,
+        });
+      }
+      settle({ ok: true, data: parsed, raw: stdout, cli: cli.name });
+    });
+
+    const t = setTimeout(() => {
+      try { proc.kill('SIGKILL'); } catch {}
+      // Surface stderr on timeout — usually has "waiting for input" or
+      // a prompt that explains why the CLI is hanging.
+      settle({
+        ok: false,
+        reason: 'timeout',
+        error: stderr ? stderr.slice(0, 500) : undefined,
+      });
+    }, timeoutMs);
+    proc.on('exit', () => clearTimeout(t));
+  });
+}
+
+/**
+ * Try to find a JSON value in raw stdout.  Tolerates leading log lines
+ * by scanning for the first { or [.  Returns the parsed value or
+ * undefined on failure.
+ */
+function extractJson(raw) {
+  if (!raw) return undefined;
+  // common case: stdout is pure JSON
+  const trimmed = raw.trim();
+  try { return JSON.parse(trimmed); } catch {}
+  // fall back: find first { or [
+  const i1 = trimmed.indexOf('{');
+  const i2 = trimmed.indexOf('[');
+  let start = -1;
+  if (i1 >= 0 && i2 >= 0) start = Math.min(i1, i2);
+  else if (i1 >= 0) start = i1;
+  else if (i2 >= 0) start = i2;
+  if (start < 0) return undefined;
+
+  // find matching last brace/bracket of the same kind
+  const open = trimmed[start];
+  const close = open === '{' ? '}' : ']';
+  const end = trimmed.lastIndexOf(close);
+  if (end < start) return undefined;
+  try { return JSON.parse(trimmed.slice(start, end + 1)); } catch {}
+  return undefined;
+}
+
+// ---------------------------------------------------------------------------
+//  Concurrency guard
+// ---------------------------------------------------------------------------
+
+let _inFlight = 0;
+const _waiters = [];
+const MAX_CONCURRENT = 2;
+
+/** Run `fn` under a 2-wide semaphore so we don't fork-bomb the CLI. */
+function withSlot(fn) {
+  return new Promise((resolve) => {
+    const start = async () => {
+      _inFlight++;
+      try { resolve(await fn()); }
+      finally {
+        _inFlight--;
+        const next = _waiters.shift();
+        if (next) next();
+      }
+    };
+    if (_inFlight < MAX_CONCURRENT) start();
+    else _waiters.push(start);
+  });
+}
+
+module.exports = {
+  detectAvailableCli,
+  detectAllCli,
+  runJudge,
+  withSlot,
+  // exported for tests
+  _resetCache,
+  extractJson,
+};