@geekbeer/minion 3.17.0 → 3.22.0

package/core/lib/dag-step-poller.js

@@ -7,8 +7,6 @@
  * - Supports concurrent node execution (up to MAX_CONCURRENT)
  * - Reports completion to /api/dag/minion/node-complete
  * - Injects input_data into skill context
- *
- * Feature flag: only starts when DAG_ENGINE_ENABLED=true
  */
 
 const { config, isHqConfigured } = require('../config')
@@ -259,7 +257,12 @@ async function executeTransformNode(node) {
   const ephemeralName = `_dag_transform_${node_execution_id.substring(0, 8)}`
   const fs = require('fs').promises
   const path = require('path')
-  const skillDir = path.join(config.HOME_DIR || process.env.HOME, '.claude', 'skills', ephemeralName)
+  const { getActiveSkillDirs } = require('../llm-plugins/lib/skill-dirs')
+  const skillRoots = getActiveSkillDirs()
+  // Write the ephemeral skill to every active plugin's dir so any Primary
+  // can find it. Cleanup at the end sweeps the same set.
+  const ephemeralSkillDirs = skillRoots.map(root => path.join(root, ephemeralName))
+  const skillDir = ephemeralSkillDirs[0] // canonical for downstream paths
 
   try {
     // 1. Claim the node
@@ -276,10 +279,13 @@ async function executeTransformNode(node) {
       throw claimErr
     }
 
-    // 2. Create ephemeral skill from transform_instruction
+    // 2. Create ephemeral skill from transform_instruction.
+    // Write to every active plugin's skill dir so any Primary can find it.
     const skillContent = buildTransformSkillContent(transform_instruction, input_data)
-    await fs.mkdir(skillDir, { recursive: true })
-    await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf-8')
+    for (const dir of ephemeralSkillDirs) {
+      await fs.mkdir(dir, { recursive: true })
+      await fs.writeFile(path.join(dir, 'SKILL.md'), skillContent, 'utf-8')
+    }
 
     // 3. Run the ephemeral skill
     const runPayload = {
@@ -322,18 +328,21 @@ async function executeTransformNode(node) {
 
   } catch (err) {
     console.error(`[DagPoller] Failed to execute transform node ${node_id}: ${err.message}`)
+    // Best-effort cleanup on synchronous failure (before skill hand-off).
+    // On the success path, cleanup is performed by the post-execution hook
+    // in skills.js once the session actually finishes.
+    for (const dir of ephemeralSkillDirs) {
+      try {
+        await fs.rm(dir, { recursive: true, force: true })
+      } catch {
+        // best-effort
+      }
+    }
     try {
       await reportNodeComplete(node_execution_id, 'failed', null, err.message)
     } catch {
       // best-effort
     }
-  } finally {
-    // 4. Clean up ephemeral skill directory
-    try {
-      await fs.rm(skillDir, { recursive: true, force: true })
-    } catch {
-      // best-effort cleanup
-    }
   }
 }
 

package/core/lib/llm-checker.js

@@ -69,8 +69,10 @@ function isClaudeAuthenticated() {
 function isGeminiAuthenticated() {
   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 possiblePaths = [
-    path.join(config.HOME_DIR, '.config', 'gemini'),
+    path.join(config.HOME_DIR, '.gemini', 'oauth_creds.json'),
     path.join(config.HOME_DIR, '.config', 'gcloud', 'application_default_credentials.json'),
     // Windows-specific locations
     ...(IS_WINDOWS ? [
@@ -80,12 +82,7 @@ function isGeminiAuthenticated() {
   for (const p of possiblePaths) {
     try {
       if (!fs.existsSync(p)) continue
-      const stat = fs.statSync(p)
-      if (stat.isDirectory()) {
-        if (fs.readdirSync(p).length > 0) return true
-      } else {
-        if (fs.readFileSync(p, 'utf-8').trim().length > 0) return true
-      }
+      if (fs.readFileSync(p, 'utf-8').trim().length > 0) return true
     } catch {
       // Ignore
     }

package/core/lib/template-expander.js

@@ -44,21 +44,26 @@ async function expandSkillTemplates(skillNames) {
   // If no variables defined, skip
   if (Object.keys(minionVars).length === 0) return new Map()
 
+  // originals key: `${root}::${name}` so we restore the right copy in each
+  // plugin's skill dir (multi-plugin distribution).
   const originals = new Map()
-  const skillsDir = path.join(config.HOME_DIR, '.claude', 'skills')
+  const { getActiveSkillDirs } = require('../llm-plugins/lib/skill-dirs')
+  const roots = getActiveSkillDirs()
 
-  for (const name of skillNames) {
-    const skillMdPath = path.join(skillsDir, name, 'SKILL.md')
-    try {
-      const original = await fs.readFile(skillMdPath, 'utf-8')
-      const expanded = expandTemplateVars(original, minionVars)
-      if (expanded !== original) {
-        originals.set(name, original)
-        await fs.writeFile(skillMdPath, expanded, 'utf-8')
-        console.log(`[TemplateExpander] Expanded {{VAR}} in skill: ${name}`)
+  for (const root of roots) {
+    for (const name of skillNames) {
+      const skillMdPath = path.join(root, name, 'SKILL.md')
+      try {
+        const original = await fs.readFile(skillMdPath, 'utf-8')
+        const expanded = expandTemplateVars(original, minionVars)
+        if (expanded !== original) {
+          originals.set(`${root}::${name}`, { skillMdPath, original })
+          await fs.writeFile(skillMdPath, expanded, 'utf-8')
+          console.log(`[TemplateExpander] Expanded {{VAR}} in skill: ${name} (${root})`)
+        }
+      } catch {
+        // Skill missing in this dir — skip
       }
-    } catch (err) {
-      console.error(`[TemplateExpander] Failed to expand ${name}: ${err.message}`)
     }
   }
 
@@ -68,16 +73,14 @@ async function expandSkillTemplates(skillNames) {
 /**
  * Restore original SKILL.md contents after execution.
  *
- * @param {Map<string, string>} originals - Map from expandSkillTemplates
+ * @param {Map<string, {skillMdPath: string, original: string}>} originals - Map from expandSkillTemplates
  */
 async function restoreSkillTemplates(originals) {
-  const skillsDir = path.join(config.HOME_DIR, '.claude', 'skills')
-  for (const [name, content] of originals) {
-    const skillMdPath = path.join(skillsDir, name, 'SKILL.md')
+  for (const { skillMdPath, original } of originals.values()) {
     try {
-      await fs.writeFile(skillMdPath, content, 'utf-8')
+      await fs.writeFile(skillMdPath, original, 'utf-8')
     } catch (err) {
-      console.error(`[TemplateExpander] Failed to restore ${name}: ${err.message}`)
+      console.error(`[TemplateExpander] Failed to restore ${skillMdPath}: ${err.message}`)
     }
   }
 }

package/core/llm-dispatch/mcp-server.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Dispatch MCP server (stdio).
+ *
+ * Primary LLM clients (Claude Code, Codex, etc.) launch this as a child
+ * process via ~/.mcp.json. It exposes one MCP tool per enabled child plugin:
+ *
+ *   dispatch_to_<plugin>(prompt, opts)
+ *
+ * When invoked, the server acquires a slot from the child session pool,
+ * calls plugin.invoke() (or plugin.resume() when a prior slot is reused),
+ * and returns the standardized LlmOutput as an MCP tool result.
+ *
+ * Parallel tool calls from the Primary are supported: each concurrent call
+ * gets its own slot. The server's lifetime equals the Primary's lifetime
+ * (when the Primary exits, the MCP transport closes and this process dies,
+ * disposing the pool).
+ *
+ * A parent_session_id is generated on startup (random UUID). It represents
+ * "this Primary session" and scopes the pool.
+ *
+ * Protocol: JSON-RPC 2.0 over stdio, one message per line.
+ */
+
+const readline = require('readline')
+const crypto = require('crypto')
+const { loadAllPlugins, readConfig } = require('../llm-plugins/registry')
+const { SessionPool } = require('./session-pool')
+
+const PARENT_SESSION_ID = crypto.randomUUID()
+const pool = new SessionPool()
+
+const plugins = loadAllPlugins()
+const cfg = readConfig()
+
+/** Enabled child plugins (exclude the primary itself to avoid self-dispatch loops). */
+function enabledChildren() {
+  const enabled = new Set(cfg.enabled)
+  const out = []
+  for (const p of plugins.values()) {
+    if (!enabled.has(p.name)) continue
+    if (p.name === cfg.primary) continue
+    out.push(p)
+  }
+  return out
+}
+
+function toolNameFor(pluginName) {
+  return `dispatch_to_${pluginName}`
+}
+
+function toolsList() {
+  return enabledChildren().map(p => ({
+    name: toolNameFor(p.name),
+    description: `Dispatch a prompt to ${p.displayName}. Returns standardized LlmOutput { text, files, metadata }.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Prompt text to send to the child LLM.' },
+        systemPrompt: { type: 'string', description: 'Optional system prompt.' },
+        model: { type: 'string', description: 'Optional model identifier.' },
+        continue: {
+          type: 'boolean',
+          description: 'Reuse the existing child session if one exists. Default true.',
+          default: true,
+        },
+      },
+      required: ['prompt'],
+    },
+  }))
+}
+
+async function handleToolCall(name, args) {
+  const children = enabledChildren()
+  const plugin = children.find(p => toolNameFor(p.name) === name)
+  if (!plugin) throw new Error(`Unknown tool: ${name}`)
+
+  const input = {
+    prompt: String(args.prompt || ''),
+    systemPrompt: args.systemPrompt,
+    model: args.model,
+  }
+  const continueSession = args.continue !== false
+
+  const forceFresh = !continueSession || !plugin.capabilities.sessionResume
+  const { slot } = pool.acquire(PARENT_SESSION_ID, plugin.name, { forceFresh })
+
+  let output
+  try {
+    if (slot.sessionId && continueSession && typeof plugin.resume === 'function') {
+      output = await plugin.resume(slot.sessionId, input)
+    } else {
+      output = await plugin.invoke(input)
+    }
+  } catch (err) {
+    pool.drop(PARENT_SESSION_ID, slot)
+    throw err
+  }
+
+  pool.release(slot, output?.metadata?.sessionId)
+  return output
+}
+
+// --- JSON-RPC transport ------------------------------------------------------
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+function sendResult(id, result) {
+  send({ jsonrpc: '2.0', id, result })
+}
+
+function sendError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } })
+}
+
+async function dispatch(msg) {
+  const { id, method, params } = msg
+  try {
+    switch (method) {
+      case 'initialize':
+        sendResult(id, {
+          protocolVersion: '2024-11-05',
+          serverInfo: { name: 'minion-llm-dispatch', version: '1.0.0' },
+          capabilities: { tools: {} },
+        })
+        return
+
+      case 'notifications/initialized':
+        // Notification: no response
+        return
+
+      case 'tools/list':
+        sendResult(id, { tools: toolsList() })
+        return
+
+      case 'tools/call': {
+        const { name, arguments: args } = params || {}
+        const output = await handleToolCall(name, args || {})
+        sendResult(id, {
+          content: [{ type: 'text', text: JSON.stringify(output) }],
+          isError: !!output?.error,
+        })
+        return
+      }
+
+      case 'ping':
+        sendResult(id, {})
+        return
+
+      default:
+        if (id !== undefined) sendError(id, -32601, `Method not found: ${method}`)
+        return
+    }
+  } catch (err) {
+    if (id !== undefined) sendError(id, -32000, err.message || String(err))
+  }
+}
+
+function start() {
+  const rl = readline.createInterface({ input: process.stdin, terminal: false })
+  rl.on('line', line => {
+    const trimmed = line.trim()
+    if (!trimmed) return
+    let msg
+    try {
+      msg = JSON.parse(trimmed)
+    } catch {
+      // Ignore malformed lines
+      return
+    }
+    dispatch(msg)
+  })
+  rl.on('close', () => {
+    pool.disposeParent(PARENT_SESSION_ID)
+    process.exit(0)
+  })
+}
+
+if (require.main === module) {
+  start()
+}
+
+module.exports = { start, toolsList, handleToolCall, pool, PARENT_SESSION_ID }

package/core/llm-dispatch/session-pool.js

@@ -0,0 +1,97 @@
+/**
+ * Child session pool for dispatch.
+ *
+ * Keyed by (parentSessionId, pluginName). When a dispatch arrives while the
+ * existing pool entry is in-flight (parallel dispatch), a new slot is created
+ * so that the concurrent calls use independent child sessions.
+ *
+ * Parent termination disposes all slots at once.
+ */
+
+/**
+ * @typedef {Object} Slot
+ * @property {string} pluginName
+ * @property {string|null} sessionId     plugin-reported sessionId (for resume)
+ * @property {boolean} inFlight
+ */
+
+class SessionPool {
+  constructor() {
+    /** @type {Map<string, Slot[]>} parentSessionId -> slots */
+    this._slots = new Map()
+  }
+
+  _key(parentSessionId) {
+    return String(parentSessionId)
+  }
+
+  /**
+   * Acquire a slot for (parent, plugin). Reuses an idle slot if available,
+   * otherwise creates a new slot. Marks the slot in-flight.
+   * @param {string} parentSessionId
+   * @param {string} pluginName
+   * @param {{ forceFresh?: boolean }} [opts]
+   * @returns {{ slot: Slot, slotIndex: number, slots: Slot[] }}
+   */
+  acquire(parentSessionId, pluginName, opts = {}) {
+    const key = this._key(parentSessionId)
+    let slots = this._slots.get(key)
+    if (!slots) {
+      slots = []
+      this._slots.set(key, slots)
+    }
+
+    if (!opts.forceFresh) {
+      const idle = slots.find(s => s.pluginName === pluginName && !s.inFlight)
+      if (idle) {
+        idle.inFlight = true
+        return { slot: idle, slotIndex: slots.indexOf(idle), slots }
+      }
+    }
+
+    const slot = { pluginName, sessionId: null, inFlight: true }
+    slots.push(slot)
+    return { slot, slotIndex: slots.length - 1, slots }
+  }
+
+  /**
+   * Release a slot after a dispatch completes. Stores sessionId (if returned
+   * by the plugin) for subsequent reuse.
+   */
+  release(slot, sessionId) {
+    slot.inFlight = false
+    if (sessionId) slot.sessionId = sessionId
+  }
+
+  /**
+   * Drop a slot entirely (e.g. plugin reported hard failure or caller asked
+   * to reset the session).
+   */
+  drop(parentSessionId, slot) {
+    const key = this._key(parentSessionId)
+    const slots = this._slots.get(key)
+    if (!slots) return
+    const idx = slots.indexOf(slot)
+    if (idx >= 0) slots.splice(idx, 1)
+  }
+
+  /** Dispose all slots for a parent session (call on parent termination). */
+  disposeParent(parentSessionId) {
+    this._slots.delete(this._key(parentSessionId))
+  }
+
+  /** Inspection helper (for diagnostics). */
+  snapshot() {
+    const out = {}
+    for (const [parent, slots] of this._slots.entries()) {
+      out[parent] = slots.map(s => ({
+        pluginName: s.pluginName,
+        sessionId: s.sessionId,
+        inFlight: s.inFlight,
+      }))
+    }
+    return out
+  }
+}
+
+module.exports = { SessionPool }

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 }