@geekbeer/minion 3.17.0 → 3.22.0

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 }

package/core/llm-plugins/lib/mcp-registration.js

@@ -0,0 +1,132 @@
+/**
+ * MCP server registration helpers.
+ *
+ * Each LLM CLI stores MCP server configuration in a different file with a
+ * different format. This module hides that variation: callers ask a plugin to
+ * register a server, and the plugin (or a fallback here) writes to the
+ * appropriate location.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { config } = require('../../config')
+
+const DISPATCH_SERVER_NAME = 'minion-llm-dispatch'
+
+/**
+ * Build the spec for the dispatch MCP server used by Primary to reach children.
+ * Plugins register this via {@link registerDispatchServer}.
+ */
+function buildDispatchServerSpec() {
+  const serverScript = path.join(__dirname, '..', '..', 'llm-dispatch', 'mcp-server.js')
+  return {
+    command: 'node',
+    args: [serverScript],
+  }
+}
+
+/**
+ * JSON-config MCP registration (used by Claude Code, Gemini CLI).
+ * Reads the target file, merges in the server entry under `mcpServers`,
+ * and writes back atomically.
+ *
+ * @param {string} configPath
+ * @param {string} serverName
+ * @param {{ command: string, args: string[] }} spec
+ */
+function writeJsonMcpEntry(configPath, serverName, spec) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true })
+  let current = {}
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8')
+    current = JSON.parse(raw)
+  } catch {
+    // New file or unparseable — start fresh
+  }
+  if (!current.mcpServers || typeof current.mcpServers !== 'object') {
+    current.mcpServers = {}
+  }
+  current.mcpServers[serverName] = spec
+  const tmp = `${configPath}.tmp`
+  fs.writeFileSync(tmp, JSON.stringify(current, null, 2), 'utf-8')
+  fs.renameSync(tmp, configPath)
+}
+
+/**
+ * Remove a server entry from a JSON MCP config.
+ */
+function removeJsonMcpEntry(configPath, serverName) {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8')
+    const current = JSON.parse(raw)
+    if (current?.mcpServers && current.mcpServers[serverName]) {
+      delete current.mcpServers[serverName]
+      const tmp = `${configPath}.tmp`
+      fs.writeFileSync(tmp, JSON.stringify(current, null, 2), 'utf-8')
+      fs.renameSync(tmp, configPath)
+    }
+  } catch {
+    // File missing or unparseable — nothing to remove
+  }
+}
+
+/**
+ * Register the dispatch MCP server with the given Primary plugin.
+ * No-op if the plugin does not implement addMcpServer() or when we don't
+ * know its MCP config location.
+ *
+ * @param {import('../types').LlmPlugin} plugin
+ */
+function registerDispatchServer(plugin) {
+  const spec = buildDispatchServerSpec()
+  if (typeof plugin.addMcpServer === 'function') {
+    plugin.addMcpServer(DISPATCH_SERVER_NAME, spec)
+    return { registered: true, method: 'plugin' }
+  }
+  // Fallback: well-known locations by plugin name
+  const fallbackPath = defaultMcpConfigPath(plugin.name)
+  if (fallbackPath) {
+    writeJsonMcpEntry(fallbackPath, DISPATCH_SERVER_NAME, spec)
+    return { registered: true, method: 'fallback', path: fallbackPath }
+  }
+  return { registered: false }
+}
+
+/**
+ * Unregister the dispatch MCP server from all known plugin MCP configs.
+ * Used when Primary is cleared.
+ */
+function unregisterDispatchServerFromAll(plugins) {
+  for (const p of plugins) {
+    if (typeof p.removeMcpServer === 'function') {
+      try { p.removeMcpServer(DISPATCH_SERVER_NAME) } catch { /* ignore */ }
+      continue
+    }
+    const fallbackPath = defaultMcpConfigPath(p.name)
+    if (fallbackPath) removeJsonMcpEntry(fallbackPath, DISPATCH_SERVER_NAME)
+  }
+}
+
+/** Best-known MCP config path for a given plugin name. Returns null if unknown. */
+function defaultMcpConfigPath(pluginName) {
+  switch (pluginName) {
+    case 'claude':
+      // Claude Code reads ~/.mcp.json (global) and project-local .mcp.json
+      return path.join(config.HOME_DIR, '.mcp.json')
+    case 'gemini':
+      // Gemini CLI settings include mcpServers field
+      return path.join(config.HOME_DIR, '.gemini', 'settings.json')
+    default:
+      return null
+  }
+}
+
+module.exports = {
+  DISPATCH_SERVER_NAME,
+  buildDispatchServerSpec,
+  writeJsonMcpEntry,
+  removeJsonMcpEntry,
+  registerDispatchServer,
+  unregisterDispatchServerFromAll,
+  defaultMcpConfigPath,
+}

package/core/llm-plugins/lib/skill-dirs.js

@@ -0,0 +1,67 @@
+/**
+ * Resolve skill directory paths across enabled LLM plugins.
+ *
+ * Each LLM CLI loads skills from its own directory:
+ *   Claude → ~/.claude/skills/
+ *   Gemini → ~/.gemini/skills/
+ *   Codex  → ~/.codex/skills/
+ *
+ * To make skill deployment LLM-agnostic, we write each skill to all enabled
+ * plugins' skill directories. Reads/deletes operate on the union.
+ */
+
+const path = require('path')
+const { config } = require('../../config')
+const { readConfig, loadAllPlugins } = require('../registry')
+
+/**
+ * Return the canonical skill directory paths for all enabled plugins.
+ * Falls back to ~/.claude/skills/ when the plugin system is not configured
+ * (preserves backward compatibility with the LLM_COMMAND era).
+ *
+ * @returns {string[]} Absolute directory paths
+ */
+function getActiveSkillDirs() {
+  const cfg = readConfig()
+  const enabled = new Set(cfg.enabled)
+
+  if (enabled.size === 0) {
+    return [path.join(config.HOME_DIR, '.claude', 'skills')]
+  }
+
+  const plugins = loadAllPlugins()
+  const dirs = []
+  for (const name of enabled) {
+    const plugin = plugins.get(name)
+    if (plugin && typeof plugin.getSkillsDir === 'function') {
+      dirs.push(plugin.getSkillsDir())
+    }
+  }
+  // Safety: if no enabled plugin reported a dir, default to claude
+  if (dirs.length === 0) {
+    dirs.push(path.join(config.HOME_DIR, '.claude', 'skills'))
+  }
+  return dirs
+}
+
+/**
+ * Get the primary plugin's skill directory (used as the canonical
+ * read source when listing or pushing skills back to HQ).
+ *
+ * @returns {string} Absolute directory path
+ */
+function getPrimarySkillDir() {
+  const cfg = readConfig()
+  if (cfg.primary) {
+    const plugins = loadAllPlugins()
+    const plugin = plugins.get(cfg.primary)
+    if (plugin && typeof plugin.getSkillsDir === 'function') {
+      return plugin.getSkillsDir()
+    }
+  }
+  // Fallback: first enabled plugin's dir, else claude
+  const dirs = getActiveSkillDirs()
+  return dirs[0]
+}
+
+module.exports = { getActiveSkillDirs, getPrimarySkillDir }