@geekbeer/minion 3.16.1 → 3.22.0

package/core/llm-plugins/claude/index.js

@@ -0,0 +1,151 @@
+/**
+ * Builtin plugin: Claude Code CLI
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const { config } = require('../../config')
+const { IS_WINDOWS, buildExtendedPath } = require('../../lib/platform')
+const { resolveBinary, spawnWithStdin } = require('../lib/spawn-helper')
+const { streamClaude } = require('./stream')
+
+const BINARY = 'claude'
+
+async function isAuthenticated() {
+  const candidates = [
+    path.join(config.HOME_DIR, '.claude', '.credentials.json'),
+    path.join(config.HOME_DIR, '.claude', 'credentials.json'),
+  ]
+  for (const p of candidates) {
+    try {
+      if (fs.existsSync(p)) {
+        const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'))
+        if (parsed && Object.keys(parsed).length > 0) return true
+      }
+    } catch {
+      // continue
+    }
+  }
+  try {
+    const bin = resolveBinary(BINARY, config.HOME_DIR)
+    execSync(`${bin} auth whoami`, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        HOME: config.HOME_DIR,
+        ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
+        PATH: buildExtendedPath(config.HOME_DIR),
+      },
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function buildArgs(input, { resume } = {}) {
+  const args = ['-p']
+  if (input.model) args.push('--model', input.model)
+  if (resume) args.push('--resume', resume)
+  return args
+}
+
+function parseFinalSessionId(stdout) {
+  // Claude prints session info on --verbose; in -p mode we don't force verbose.
+  // Leave sessionId undefined unless we parse it from known markers in future.
+  return undefined
+}
+
+async function invoke(input) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const args = buildArgs(input)
+  const { stdout, stderr, code, durationMs } = await spawnWithStdin({
+    binary: bin,
+    args,
+    prompt: input.prompt,
+    homeDir: config.HOME_DIR,
+    timeoutMs: input.timeoutMs,
+  })
+  if (code !== 0) {
+    return {
+      text: stdout,
+      files: [],
+      metadata: { durationMs },
+      error: { code: `exit_${code}`, message: stderr.slice(0, 2000) || 'claude exited non-zero' },
+    }
+  }
+  return {
+    text: stdout.trim(),
+    files: [],
+    metadata: { durationMs, sessionId: parseFinalSessionId(stdout) },
+  }
+}
+
+async function resume(sessionId, input) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const args = buildArgs(input, { resume: sessionId })
+  const { stdout, stderr, code, durationMs } = await spawnWithStdin({
+    binary: bin,
+    args,
+    prompt: input.prompt,
+    homeDir: config.HOME_DIR,
+    timeoutMs: input.timeoutMs,
+  })
+  if (code !== 0) {
+    return {
+      text: stdout,
+      files: [],
+      metadata: { durationMs, sessionId },
+      error: { code: `exit_${code}`, message: stderr.slice(0, 2000) || 'claude exited non-zero' },
+    }
+  }
+  return {
+    text: stdout.trim(),
+    files: [],
+    metadata: { durationMs, sessionId },
+  }
+}
+
+function stream(input, onEvent, ctx) {
+  return streamClaude(input, onEvent, ctx)
+}
+
+function buildShellInvocation({ promptFile, model }) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const modelArg = model ? ` --model ${model}` : ''
+  return `${bin} -p${modelArg} < ${promptFile}`
+}
+
+function getSkillsDir() {
+  return path.join(config.HOME_DIR, '.claude', 'skills')
+}
+
+function formatSkillInvocation(skillName, args = []) {
+  const argStr = args.length ? ' ' + args.join(' ') : ''
+  return `/${skillName}${argStr}`
+}
+
+/** @type {import('../types').LlmPlugin} */
+const plugin = {
+  name: 'claude',
+  displayName: 'Claude Code',
+  capabilities: {
+    toolUse: true,
+    streaming: true,
+    vision: true,
+    imageGeneration: false,
+    sessionResume: true,
+  },
+  isAuthenticated,
+  invoke,
+  stream,
+  resume,
+  buildShellInvocation,
+  getSkillsDir,
+  formatSkillInvocation,
+}
+
+module.exports = { plugin }

package/core/llm-plugins/claude/stream.js

@@ -0,0 +1,166 @@
+/**
+ * Claude Code stream-json parser.
+ *
+ * Spawns `claude -p --verbose --output-format stream-json` and translates
+ * the CLI's event stream into normalized LlmEvent shapes consumed by
+ * chat routes. Extracted from linux/routes/chat.js streamLlmResponse().
+ */
+
+const { spawn } = require('child_process')
+const { config } = require('../../config')
+const { IS_WINDOWS, buildExtendedPath } = require('../../lib/platform')
+const { resolveBinary } = require('../lib/spawn-helper')
+
+/**
+ * @param {import('../types').LlmInput} input
+ * @param {(event: any) => void} onEvent
+ * @param {{ resumeSessionId?: string | null, activeChildRef?: { current: any } }} [ctx]
+ * @returns {Promise<import('../types').LlmOutput>}
+ */
+function streamClaude(input, onEvent, ctx = {}) {
+  return new Promise((resolve, reject) => {
+    const bin = resolveBinary('claude', config.HOME_DIR)
+    const started = Date.now()
+
+    const args = [
+      '-p',
+      '--verbose',
+      '--model', input.model || 'sonnet',
+      '--output-format', 'stream-json',
+    ]
+    if (ctx.resumeSessionId) args.push('--resume', ctx.resumeSessionId)
+
+    console.log(`[claude-plugin] spawn: ${bin} ${args.join(' ')} (resume=${ctx.resumeSessionId || 'new'})`)
+
+    const child = spawn(bin, args, {
+      cwd: config.HOME_DIR,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: input.timeoutMs || 600000,
+      env: {
+        ...process.env,
+        HOME: config.HOME_DIR,
+        ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
+        PATH: buildExtendedPath(config.HOME_DIR),
+      },
+    })
+
+    if (ctx.activeChildRef) ctx.activeChildRef.current = child
+
+    child.stdin.write(input.prompt)
+    child.stdin.end()
+
+    let fullText = ''
+    let stderrBuf = ''
+    let lineBuf = ''
+    let resolvedSessionId = ctx.resumeSessionId || null
+    let currentBlockType = null
+    let currentToolName = null
+    let toolInputBuffer = ''
+    let turnCount = 0
+
+    child.stdout.on('data', chunk => {
+      lineBuf += chunk.toString()
+      const parts = lineBuf.split('\n')
+      lineBuf = parts.pop() || ''
+      for (const line of parts) {
+        if (!line.trim()) continue
+        let parsed
+        try { parsed = JSON.parse(line) } catch { continue }
+
+        if (parsed.type === 'system' && parsed.session_id) {
+          resolvedSessionId = parsed.session_id
+          onEvent({ type: 'session', sessionId: resolvedSessionId })
+        }
+
+        if (parsed.type === 'content_block_start') {
+          const bt = parsed.content_block?.type
+          if (bt === 'tool_use') {
+            currentBlockType = 'tool_use'
+            currentToolName = parsed.content_block.name || 'unknown'
+            toolInputBuffer = ''
+            onEvent({ type: 'tool_start', tool: currentToolName })
+          } else if (bt === 'text') {
+            currentBlockType = 'text'
+          }
+        }
+
+        if (parsed.type === 'content_block_delta') {
+          const dt = parsed.delta?.type
+          if (dt === 'input_json_delta' && currentBlockType === 'tool_use') {
+            const partial = parsed.delta.partial_json || ''
+            if (partial) {
+              toolInputBuffer += partial
+              onEvent({ type: 'tool_input_delta', partial_json: partial })
+            }
+          } else {
+            const delta = parsed.delta?.text || ''
+            if (delta) {
+              fullText += delta
+              onEvent({ type: 'delta', content: delta })
+            }
+          }
+        }
+
+        if (parsed.type === 'content_block_stop') {
+          if (currentBlockType === 'tool_use') {
+            let parsedInput = null
+            try { if (toolInputBuffer) parsedInput = JSON.parse(toolInputBuffer) } catch { /* ignore */ }
+            onEvent({ type: 'tool_end', tool: currentToolName, input: parsedInput })
+          }
+          currentBlockType = null
+          currentToolName = null
+          toolInputBuffer = ''
+        }
+
+        if (parsed.type === 'assistant' && parsed.message) {
+          turnCount++
+          for (const block of (parsed.message.content || [])) {
+            if (block.type === 'text') {
+              fullText += block.text
+              onEvent({ type: 'text', content: block.text })
+            }
+          }
+        } else if (parsed.type === 'result') {
+          const resultText = parsed.result || ''
+          if (resultText) {
+            onEvent({ type: 'result', content: resultText })
+            if (!fullText) fullText = resultText
+          }
+        }
+      }
+    })
+
+    child.stderr.on('data', chunk => {
+      stderrBuf += chunk.toString()
+    })
+
+    child.on('error', err => {
+      if (ctx.activeChildRef) ctx.activeChildRef.current = null
+      onEvent({ type: 'error', message: err.message })
+      reject(err)
+    })
+
+    child.on('close', code => {
+      if (ctx.activeChildRef) ctx.activeChildRef.current = null
+      const durationMs = Date.now() - started
+      if (code !== 0 && !fullText) {
+        const msg = stderrBuf.trim() || `claude CLI exited with code ${code}`
+        onEvent({ type: 'error', message: msg })
+        resolve({
+          text: '',
+          files: [],
+          metadata: { sessionId: resolvedSessionId || undefined, durationMs },
+          error: { code: `exit_${code}`, message: msg },
+        })
+        return
+      }
+      resolve({
+        text: fullText,
+        files: [],
+        metadata: { sessionId: resolvedSessionId || undefined, durationMs },
+      })
+    })
+  })
+}
+
+module.exports = { streamClaude }

package/core/llm-plugins/codex/index.js

@@ -0,0 +1,161 @@
+/**
+ * Builtin plugin: Codex CLI (OpenAI)
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { config } = require('../../config')
+const { resolveBinary, spawnWithStdin } = require('../lib/spawn-helper')
+
+const BINARY = 'codex'
+
+async function isAuthenticated() {
+  if (process.env.OPENAI_API_KEY) return true
+  const codexDir = path.join(config.HOME_DIR, '.codex')
+  try {
+    if (fs.existsSync(codexDir) && fs.statSync(codexDir).isDirectory()) {
+      if (fs.readdirSync(codexDir).length > 0) return true
+    }
+  } catch {
+    // continue
+  }
+  return false
+}
+
+function buildArgs(input) {
+  const args = []
+  if (input.model) args.push('--model', input.model)
+  return args
+}
+
+async function invoke(input) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const { stdout, stderr, code, durationMs } = await spawnWithStdin({
+    binary: bin,
+    args: buildArgs(input),
+    prompt: input.prompt,
+    homeDir: config.HOME_DIR,
+    timeoutMs: input.timeoutMs,
+  })
+  if (code !== 0) {
+    return {
+      text: stdout,
+      files: [],
+      metadata: { durationMs },
+      error: { code: `exit_${code}`, message: stderr.slice(0, 2000) || 'codex exited non-zero' },
+    }
+  }
+  return {
+    text: stdout.trim(),
+    files: [],
+    metadata: { durationMs },
+  }
+}
+
+function buildShellInvocation({ promptFile, model }) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const modelArg = model ? ` --model ${model}` : ''
+  return `${bin}${modelArg} < ${promptFile}`
+}
+
+function getSkillsDir() {
+  return path.join(config.HOME_DIR, '.codex', 'skills')
+}
+
+function formatSkillInvocation(skillName, args = []) {
+  const argStr = args.length ? ' ' + args.join(' ') : ''
+  return `/${skillName}${argStr}`
+}
+
+/**
+ * Codex stores MCP servers in ~/.codex/config.toml with the format:
+ *   [mcp_servers.<name>]
+ *   command = "..."
+ *   args = ["..."]
+ *
+ * To avoid pulling in a TOML library we do targeted block replacement:
+ * locate `[mcp_servers.<name>]` (and its body up to the next `[` table or EOF)
+ * and replace it. If absent, append.
+ */
+function configTomlPath() {
+  return path.join(config.HOME_DIR, '.codex', 'config.toml')
+}
+
+function renderTomlBlock(name, spec) {
+  const lines = [`[mcp_servers.${name}]`]
+  lines.push(`command = ${JSON.stringify(spec.command)}`)
+  if (Array.isArray(spec.args)) {
+    lines.push(`args = [${spec.args.map(a => JSON.stringify(a)).join(', ')}]`)
+  }
+  if (spec.env && typeof spec.env === 'object') {
+    for (const [k, v] of Object.entries(spec.env)) {
+      lines.push(`env.${k} = ${JSON.stringify(v)}`)
+    }
+  }
+  return lines.join('\n')
+}
+
+function addMcpServer(name, spec) {
+  const tomlPath = configTomlPath()
+  fs.mkdirSync(path.dirname(tomlPath), { recursive: true })
+
+  let content = ''
+  try { content = fs.readFileSync(tomlPath, 'utf-8') } catch { /* new file */ }
+
+  const block = renderTomlBlock(name, spec)
+  const headerRe = new RegExp(`^\\[mcp_servers\\.${name.replace(/[-]/g, '\\-')}\\]\\s*$`, 'm')
+  const match = content.match(headerRe)
+  let next
+  if (match) {
+    // Replace from the matched header through to the next [ at column 0 (or EOF)
+    const startIdx = match.index
+    const after = content.slice(startIdx + match[0].length)
+    const nextHeader = after.search(/\n\[[^\n]*\]\s*$/m)
+    const endIdx = nextHeader === -1 ? content.length : startIdx + match[0].length + nextHeader
+    next = content.slice(0, startIdx) + block + content.slice(endIdx)
+  } else {
+    const sep = content.length === 0 || content.endsWith('\n\n') ? '' : (content.endsWith('\n') ? '\n' : '\n\n')
+    next = content + sep + block + '\n'
+  }
+
+  const tmp = `${tomlPath}.tmp`
+  fs.writeFileSync(tmp, next, 'utf-8')
+  fs.renameSync(tmp, tomlPath)
+}
+
+function removeMcpServer(name) {
+  const tomlPath = configTomlPath()
+  let content
+  try { content = fs.readFileSync(tomlPath, 'utf-8') } catch { return }
+  const escaped = name.replace(/[-]/g, '\\-')
+  // Match the header and everything until the next [ table at column 0 or EOF
+  const headerRe = new RegExp(`(?:^|\\n)\\[mcp_servers\\.${escaped}\\][^\\n]*(?:\\n(?!\\[)[^\\n]*)*`, 'm')
+  const next = content.replace(headerRe, '').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '')
+  if (next !== content) {
+    const tmp = `${tomlPath}.tmp`
+    fs.writeFileSync(tmp, next, 'utf-8')
+    fs.renameSync(tmp, tomlPath)
+  }
+}
+
+/** @type {import('../types').LlmPlugin} */
+const plugin = {
+  name: 'codex',
+  displayName: 'Codex',
+  capabilities: {
+    toolUse: true,
+    streaming: false,
+    vision: false,
+    imageGeneration: false,
+    sessionResume: false,
+  },
+  isAuthenticated,
+  invoke,
+  buildShellInvocation,
+  getSkillsDir,
+  formatSkillInvocation,
+  addMcpServer,
+  removeMcpServer,
+}
+
+module.exports = { plugin }

package/core/llm-plugins/gemini/index.js

@@ -0,0 +1,104 @@
+/**
+ * Builtin plugin: Gemini CLI
+ *
+ * Note: Gemini CLI flag set is fluid; this plugin targets the common
+ * invocation pattern (prompt via stdin, `-p -` to signal stdin input on some
+ * builds, or plain stdin on others). The prompt is always passed on stdin to
+ * avoid shell quoting issues.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { config } = require('../../config')
+const { IS_WINDOWS } = require('../../lib/platform')
+const { resolveBinary, spawnWithStdin } = require('../lib/spawn-helper')
+
+const BINARY = 'gemini'
+
+async function isAuthenticated() {
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) return true
+
+  // Official @google/gemini-cli stores OAuth credentials at ~/.gemini/oauth_creds.json
+  // after `gemini` login. Fall back to ADC locations for gcloud-based setups.
+  const candidates = [
+    path.join(config.HOME_DIR, '.gemini', 'oauth_creds.json'),
+    path.join(config.HOME_DIR, '.config', 'gcloud', 'application_default_credentials.json'),
+    ...(IS_WINDOWS ? [
+      path.join(config.HOME_DIR, 'AppData', 'Roaming', 'gcloud', 'application_default_credentials.json'),
+    ] : []),
+  ]
+  for (const p of candidates) {
+    try {
+      if (!fs.existsSync(p)) continue
+      if (fs.readFileSync(p, 'utf-8').trim().length > 0) return true
+    } catch {
+      // continue
+    }
+  }
+  return false
+}
+
+function buildArgs(input) {
+  const args = []
+  if (input.model) args.push('--model', input.model)
+  return args
+}
+
+async function invoke(input) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const { stdout, stderr, code, durationMs } = await spawnWithStdin({
+    binary: bin,
+    args: buildArgs(input),
+    prompt: input.prompt,
+    homeDir: config.HOME_DIR,
+    timeoutMs: input.timeoutMs,
+  })
+  if (code !== 0) {
+    return {
+      text: stdout,
+      files: [],
+      metadata: { durationMs },
+      error: { code: `exit_${code}`, message: stderr.slice(0, 2000) || 'gemini exited non-zero' },
+    }
+  }
+  return {
+    text: stdout.trim(),
+    files: [],
+    metadata: { durationMs },
+  }
+}
+
+function buildShellInvocation({ promptFile, model }) {
+  const bin = resolveBinary(BINARY, config.HOME_DIR)
+  const modelArg = model ? ` --model ${model}` : ''
+  return `${bin}${modelArg} < ${promptFile}`
+}
+
+function getSkillsDir() {
+  return path.join(config.HOME_DIR, '.gemini', 'skills')
+}
+
+function formatSkillInvocation(skillName, args = []) {
+  const argStr = args.length ? ` with arguments: ${args.join(' ')}` : ''
+  return `Please use the "${skillName}" skill${argStr}.`
+}
+
+/** @type {import('../types').LlmPlugin} */
+const plugin = {
+  name: 'gemini',
+  displayName: 'Gemini CLI',
+  capabilities: {
+    toolUse: true,
+    streaming: false,
+    vision: true,
+    imageGeneration: true,
+    sessionResume: false,
+  },
+  isAuthenticated,
+  invoke,
+  buildShellInvocation,
+  getSkillsDir,
+  formatSkillInvocation,
+}
+
+module.exports = { plugin }

package/core/llm-plugins/lib/active.js

@@ -0,0 +1,23 @@
+/**
+ * Runtime helpers for resolving the currently active plugin.
+ *
+ * These helpers centralize the "plugin enabled vs legacy LLM_COMMAND" branch
+ * so callers (chat route, workflow-runner, routine-runner) share the same
+ * resolution rule.
+ */
+
+const { readConfig, getPlugin } = require('../registry')
+
+/**
+ * Resolve the Primary plugin if the plugin system is enabled, otherwise null.
+ * Caller can branch to LLM_COMMAND-legacy path when this returns null.
+ *
+ * @returns {import('../types').LlmPlugin | null}
+ */
+function getActivePrimary() {
+  const cfg = readConfig()
+  if (!cfg.primary) return null
+  return getPlugin(cfg.primary)
+}
+
+module.exports = { getActivePrimary }