@geekbeer/minion 2.53.3 → 2.56.1

package/core/lib/capability-checker.js

@@ -1,22 +1,19 @@
 /**
  * Capability checker
  *
- * Detects MCP servers configured in ~/.mcp.json and available CLI tools.
- * Results are cached in memory for 5 minutes to avoid excessive filesystem/process checks.
- * Follows the same caching pattern as llm-checker.js.
+ * Detects MCP servers, installed packages, and environment variables.
+ * Always returns fresh results — called on-demand, not on every heartbeat.
+ *
+ * - MCP servers: parsed from ~/.mcp.json
+ * - Packages: scanned from package managers (apt, npm, pip, etc.)
+ * - Env var keys: collected from minion-local variables/secrets stores
  */
 
 const fs = require('fs')
 const path = require('path')
-const { execSync } = require('child_process')
 const { config } = require('../config')
-const { IS_WINDOWS, buildExtendedPath } = require('./platform')
 const variableStore = require('../stores/variable-store')
-
-const CACHE_TTL_MS = 300000 // 5 minutes
-
-let cachedResult = null
-let cachedAt = 0
+const { scanAllPackages, checkPackages } = require('./package-scanner')
 
 /**
  * Detect MCP servers from ~/.mcp.json.
@@ -39,46 +36,6 @@ function getMcpServers() {
   }
 }
 
-/**
- * Check if a CLI tool is available and get its version.
- * @param {string} name - Tool name (e.g., 'git', 'node')
- * @returns {{ name: string, available: boolean, version?: string }}
- */
-function checkTool(name) {
-  const extendedPath = buildExtendedPath(config.HOME_DIR)
-  const env = {
-    ...process.env,
-    HOME: config.HOME_DIR,
-    ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
-    PATH: extendedPath,
-  }
-  const execOpts = { encoding: 'utf-8', timeout: 5000, stdio: 'pipe', env }
-
-  try {
-    // Check existence
-    const whichCmd = IS_WINDOWS ? 'where' : 'which'
-    execSync(`${whichCmd} ${name}`, execOpts)
-
-    // Get version
-    let version = null
-    try {
-      const out = execSync(`${name} --version`, execOpts).trim()
-      // Extract version number from output (e.g., "git version 2.43.0" → "2.43.0")
-      const match = out.match(/(\d+\.\d+[\.\d]*)/)
-      if (match) version = match[1]
-    } catch {
-      // Tool exists but --version failed, that's ok
-    }
-
-    return { name, available: true, ...(version && { version }) }
-  } catch {
-    return { name, available: false }
-  }
-}
-
-/** CLI tools to detect */
-const TOOL_NAMES = ['git', 'node', 'npx', 'claude', 'docker', 'tmux']
-
 /**
  * Get all available environment variable keys (variables + secrets).
  * Returns deduplicated key names without values (secrets stay hidden).
@@ -91,38 +48,51 @@ function getEnvVarKeys() {
 }
 
 /**
- * Get all capabilities (MCP servers + CLI tools + env var keys), cached for 5 minutes.
- * @returns {{ mcp_servers: { name: string, configured: boolean }[], cli_tools: { name: string, available: boolean, version?: string }[], env_var_keys: string[] }}
+ * Get all capabilities (MCP servers + installed packages + env var keys).
+ * Always returns fresh results.
+ * @returns {{ mcp_servers: { name: string, configured: boolean }[], packages: Record<string, { available: boolean, items: { name: string, version: string }[] }>, env_var_keys: string[] }}
  */
 function getCapabilities() {
-  const now = Date.now()
-  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
-    return cachedResult
-  }
-
   const mcp_servers = getMcpServers()
-  const cli_tools = TOOL_NAMES.map(name => checkTool(name))
+  const packages = scanAllPackages()
   const env_var_keys = getEnvVarKeys()
 
-  cachedResult = { mcp_servers, cli_tools, env_var_keys }
-  cachedAt = now
-  return cachedResult
-}
-
-/** Clear the cached capability status */
-function clearCapabilityCache() {
-  cachedResult = null
-  cachedAt = 0
+  return { mcp_servers, packages, env_var_keys }
 }
 
 /**
- * Check arbitrary tool names on-demand (not cached).
- * Used by readiness checks to verify skill-declared cli_tools.
- * @param {string[]} names - Tool names to check
- * @returns {{ name: string, available: boolean, version?: string }[]}
+ * Check requirements against current capabilities.
+ * @param {{ mcp_servers?: string[], packages?: Record<string, string[]>, env_vars?: string[] }} requires
+ * @returns {{ satisfied: boolean, missing: { mcp_servers: string[], packages: Record<string, string[]>, env_vars: string[] } }}
  */
-function checkTools(names) {
-  return names.map(name => checkTool(name))
+function checkRequirements(requires) {
+  const missing = { mcp_servers: [], packages: {}, env_vars: [] }
+  let satisfied = true
+
+  // Check MCP servers
+  if (requires.mcp_servers && requires.mcp_servers.length > 0) {
+    const configuredServers = getMcpServers()
+    const configuredNames = new Set(configuredServers.map(s => s.name))
+    missing.mcp_servers = requires.mcp_servers.filter(s => !configuredNames.has(s))
+    if (missing.mcp_servers.length > 0) satisfied = false
+  }
+
+  // Check packages
+  if (requires.packages && Object.keys(requires.packages).length > 0) {
+    const installed = scanAllPackages()
+    const result = checkPackages(requires.packages, installed)
+    missing.packages = result.missing
+    if (!result.satisfied) satisfied = false
+  }
+
+  // Check env vars
+  if (requires.env_vars && requires.env_vars.length > 0) {
+    const envVarKeys = new Set(getEnvVarKeys())
+    missing.env_vars = requires.env_vars.filter(v => !envVarKeys.has(v))
+    if (missing.env_vars.length > 0) satisfied = false
+  }
+
+  return { satisfied, missing }
 }
 
-module.exports = { getCapabilities, clearCapabilityCache, checkTools }
+module.exports = { getCapabilities, checkRequirements }

package/core/lib/package-scanner.js

@@ -0,0 +1,370 @@
+/**
+ * Package scanner
+ *
+ * Scans installed packages from various package managers.
+ * Each scanner checks if the package manager is available, then lists installed packages.
+ * Returns results grouped by package manager with availability status.
+ *
+ * Supported package managers:
+ *   Linux:   apt, npm, pnpm, bun, pip, uv, pipx, cargo
+ *   macOS:   brew, npm, pnpm, bun, pip, uv, pipx, cargo
+ *   Windows: winget, scoop, npm, pnpm, bun, pip, uv, pipx, cargo
+ */
+
+const { execSync } = require('child_process')
+const { IS_WINDOWS, buildExtendedPath } = require('./platform')
+const { config } = require('../config')
+
+/**
+ * Build exec options with extended PATH.
+ * @returns {object}
+ */
+function execOpts() {
+  const extendedPath = buildExtendedPath(config.HOME_DIR)
+  return {
+    encoding: 'utf-8',
+    timeout: 30000,
+    stdio: 'pipe',
+    env: {
+      ...process.env,
+      HOME: config.HOME_DIR,
+      ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
+      PATH: extendedPath,
+    },
+  }
+}
+
+/**
+ * Check if a command exists.
+ * @param {string} cmd
+ * @returns {boolean}
+ */
+function commandExists(cmd) {
+  try {
+    const whichCmd = IS_WINDOWS ? 'where' : 'which'
+    execSync(`${whichCmd} ${cmd}`, execOpts())
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Run a command and return stdout, or null on failure.
+ * @param {string} cmd
+ * @returns {string | null}
+ */
+function run(cmd) {
+  try {
+    return execSync(cmd, execOpts()).trim()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @typedef {{ name: string, version: string }} PackageItem
+ * @typedef {{ available: boolean, items: PackageItem[] }} ScanResult
+ */
+
+// --- Individual scanners ---
+
+/** @returns {ScanResult} */
+function scanApt() {
+  if (IS_WINDOWS || process.platform === 'darwin') return { available: false, items: [] }
+  if (!commandExists('dpkg-query')) return { available: false, items: [] }
+
+  const out = run("dpkg-query -W -f '${Package}\\t${Version}\\n'")
+  if (!out) return { available: true, items: [] }
+
+  const items = out.split('\n').filter(Boolean).map(line => {
+    const [name, version] = line.split('\t')
+    return { name: name || '', version: version || '' }
+  }).filter(i => i.name)
+
+  return { available: true, items }
+}
+
+/** @returns {ScanResult} */
+function scanBrew() {
+  if (process.platform !== 'darwin') return { available: false, items: [] }
+  if (!commandExists('brew')) return { available: false, items: [] }
+
+  const out = run('brew list --versions')
+  if (!out) return { available: true, items: [] }
+
+  const items = out.split('\n').filter(Boolean).map(line => {
+    const parts = line.split(/\s+/)
+    return { name: parts[0] || '', version: parts.slice(1).join(' ') || '' }
+  }).filter(i => i.name)
+
+  return { available: true, items }
+}
+
+/** @returns {ScanResult} */
+function scanWinget() {
+  if (!IS_WINDOWS) return { available: false, items: [] }
+  if (!commandExists('winget')) return { available: false, items: [] }
+
+  const out = run('winget list --disable-interactivity --accept-source-agreements 2>nul')
+  if (!out) return { available: true, items: [] }
+
+  // winget list output is table-formatted; parse lines after the header separator
+  const lines = out.split('\n')
+  const sepIndex = lines.findIndex(l => /^-{2,}/.test(l.trim()))
+  if (sepIndex < 0) return { available: true, items: [] }
+
+  const items = []
+  for (let i = sepIndex + 1; i < lines.length; i++) {
+    const line = lines[i].trim()
+    if (!line) continue
+    // Columns are variable-width; extract name and version heuristically
+    const parts = line.split(/\s{2,}/)
+    if (parts.length >= 2) {
+      items.push({ name: parts[0], version: parts[1] || '' })
+    }
+  }
+
+  return { available: true, items }
+}
+
+/** @returns {ScanResult} */
+function scanScoop() {
+  if (!IS_WINDOWS) return { available: false, items: [] }
+  if (!commandExists('scoop')) return { available: false, items: [] }
+
+  const out = run('scoop list 2>nul')
+  if (!out) return { available: true, items: [] }
+
+  // scoop list output: "  name  version  source  ..."
+  const lines = out.split('\n')
+  const sepIndex = lines.findIndex(l => /^-{2,}/.test(l.trim()))
+
+  const items = []
+  const startIdx = sepIndex >= 0 ? sepIndex + 1 : 0
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i].trim()
+    if (!line || line.startsWith('-')) continue
+    const parts = line.split(/\s+/)
+    if (parts.length >= 2) {
+      items.push({ name: parts[0], version: parts[1] || '' })
+    }
+  }
+
+  return { available: true, items }
+}
+
+/** @returns {ScanResult} */
+function scanNpm() {
+  if (!commandExists('npm')) return { available: false, items: [] }
+
+  const out = run('npm list -g --depth=0 --json')
+  if (!out) return { available: true, items: [] }
+
+  try {
+    const data = JSON.parse(out)
+    const deps = data.dependencies || {}
+    const items = Object.entries(deps).map(([name, info]) => ({
+      name,
+      version: (typeof info === 'object' && info !== null ? info.version : '') || '',
+    }))
+    return { available: true, items }
+  } catch {
+    return { available: true, items: [] }
+  }
+}
+
+/** @returns {ScanResult} */
+function scanPnpm() {
+  if (!commandExists('pnpm')) return { available: false, items: [] }
+
+  const out = run('pnpm list -g --json')
+  if (!out) return { available: true, items: [] }
+
+  try {
+    const data = JSON.parse(out)
+    // pnpm list -g --json returns an array
+    const list = Array.isArray(data) ? data : [data]
+    const items = []
+    for (const entry of list) {
+      const deps = { ...(entry.dependencies || {}), ...(entry.devDependencies || {}) }
+      for (const [name, info] of Object.entries(deps)) {
+        items.push({
+          name,
+          version: (typeof info === 'object' && info !== null ? info.version : '') || '',
+        })
+      }
+    }
+    return { available: true, items }
+  } catch {
+    return { available: true, items: [] }
+  }
+}
+
+/** @returns {ScanResult} */
+function scanBun() {
+  if (!commandExists('bun')) return { available: false, items: [] }
+
+  // bun pm ls -g outputs text format
+  const out = run('bun pm ls -g 2>/dev/null || bun pm ls -g 2>nul')
+  if (!out) return { available: true, items: [] }
+
+  const items = []
+  for (const line of out.split('\n')) {
+    // Lines like: "├── package-name@1.0.0"
+    const match = line.match(/[├└─│\s]*(.+?)@(\S+)/)
+    if (match) {
+      items.push({ name: match[1], version: match[2] })
+    }
+  }
+
+  return { available: true, items }
+}
+
+/** @returns {ScanResult} */
+function scanPip() {
+  // Try pip3 first, then pip
+  const pipCmd = commandExists('pip3') ? 'pip3' : commandExists('pip') ? 'pip' : null
+  if (!pipCmd) return { available: false, items: [] }
+
+  const out = run(`${pipCmd} list --format=json`)
+  if (!out) return { available: true, items: [] }
+
+  try {
+    const data = JSON.parse(out)
+    const items = data.map(pkg => ({
+      name: pkg.name || '',
+      version: pkg.version || '',
+    })).filter(i => i.name)
+    return { available: true, items }
+  } catch {
+    return { available: true, items: [] }
+  }
+}
+
+/** @returns {ScanResult} */
+function scanUv() {
+  if (!commandExists('uv')) return { available: false, items: [] }
+
+  const out = run('uv pip list --format=json 2>/dev/null || uv pip list --format=json 2>nul')
+  if (!out) return { available: true, items: [] }
+
+  try {
+    const data = JSON.parse(out)
+    const items = data.map(pkg => ({
+      name: pkg.name || '',
+      version: pkg.version || '',
+    })).filter(i => i.name)
+    return { available: true, items }
+  } catch {
+    return { available: true, items: [] }
+  }
+}
+
+/** @returns {ScanResult} */
+function scanPipx() {
+  if (!commandExists('pipx')) return { available: false, items: [] }
+
+  const out = run('pipx list --json')
+  if (!out) return { available: true, items: [] }
+
+  try {
+    const data = JSON.parse(out)
+    const venvs = data.venvs || {}
+    const items = Object.entries(venvs).map(([name, info]) => ({
+      name,
+      version: (info && info.metadata && info.metadata.main_package && info.metadata.main_package.package_version) || '',
+    }))
+    return { available: true, items }
+  } catch {
+    return { available: true, items: [] }
+  }
+}
+
+/** @returns {ScanResult} */
+function scanCargo() {
+  if (!commandExists('cargo')) return { available: false, items: [] }
+
+  const out = run('cargo install --list')
+  if (!out) return { available: true, items: [] }
+
+  // Lines like: "ripgrep v14.1.0:" (top-level, no indent = package name)
+  const items = []
+  for (const line of out.split('\n')) {
+    if (line.startsWith(' ') || line.startsWith('\t') || !line.trim()) continue
+    const match = line.match(/^(\S+)\s+v?(\S+):?/)
+    if (match) {
+      items.push({ name: match[1], version: match[2].replace(/:$/, '') })
+    }
+  }
+
+  return { available: true, items }
+}
+
+// --- Scanner registry ---
+
+/**
+ * All supported package manager scanners.
+ * Each scanner handles its own platform check internally.
+ * @type {Record<string, () => ScanResult>}
+ */
+const SCANNERS = {
+  apt: scanApt,
+  brew: scanBrew,
+  winget: scanWinget,
+  scoop: scanScoop,
+  npm: scanNpm,
+  pnpm: scanPnpm,
+  bun: scanBun,
+  pip: scanPip,
+  uv: scanUv,
+  pipx: scanPipx,
+  cargo: scanCargo,
+}
+
+/**
+ * Scan all package managers and return installed packages.
+ * Skips package managers not available on the current platform.
+ * @returns {Record<string, ScanResult>}
+ */
+function scanAllPackages() {
+  const results = {}
+  for (const [name, scanner] of Object.entries(SCANNERS)) {
+    results[name] = scanner()
+  }
+  return results
+}
+
+/**
+ * Check if specific packages are installed for given package managers.
+ * @param {Record<string, string[]>} required - e.g. { apt: ['ffmpeg'], npm: ['@anthropic-ai/claude-code'] }
+ * @param {Record<string, ScanResult>} installed - result from scanAllPackages()
+ * @returns {{ satisfied: boolean, missing: Record<string, string[]> }}
+ */
+function checkPackages(required, installed) {
+  const missing = {}
+  let satisfied = true
+
+  for (const [manager, packages] of Object.entries(required)) {
+    const scan = installed[manager]
+    if (!scan || !scan.available) {
+      // Package manager not available — all packages are missing
+      if (packages.length > 0) {
+        missing[manager] = [...packages]
+        satisfied = false
+      }
+      continue
+    }
+
+    const installedNames = new Set(scan.items.map(i => i.name))
+    const missingPkgs = packages.filter(p => !installedNames.has(p))
+    if (missingPkgs.length > 0) {
+      missing[manager] = missingPkgs
+      satisfied = false
+    }
+  }
+
+  return { satisfied, missing }
+}
+
+module.exports = { scanAllPackages, checkPackages, SCANNERS }

package/core/lib/platform.js

@@ -31,7 +31,6 @@ function resolveDataDir() {
 
 const DATA_DIR = resolveDataDir()
 const LOG_DIR = path.join(DATA_DIR, 'logs')
-const MARKER_DIR = path.join(TEMP_DIR, 'minion-executions')
 
 /**
  * Build extended PATH including common CLI installation locations.
@@ -104,7 +103,6 @@ module.exports = {
   TEMP_DIR,
   DATA_DIR,
   LOG_DIR,
-  MARKER_DIR,
   buildExtendedPath,
   getExitCodePath,
   getDefaultShell,

package/core/lib/running-tasks.js

@@ -0,0 +1,125 @@
+/**
+ * Running Tasks Store
+ *
+ * In-memory store that tracks what tmux sessions are currently running
+ * on this minion. Reported to HQ via heartbeat so the dashboard can
+ * show the minion's actual state (the "body" of the minion).
+ *
+ * Mutations trigger an immediate heartbeat (debounced to 2s) so the
+ * dashboard receives near-real-time updates.
+ */
+
+const { isHqConfigured } = require('../config')
+
+/** @type {Array<import('../../src/lib/supabase/types').RunningTask>} */
+let tasks = []
+
+// Debounce timer for immediate heartbeat on mutation
+let debounceTimer = null
+const DEBOUNCE_MS = 2000
+
+// Lazy reference — resolved on first use to avoid circular require
+let _sendHeartbeat = null
+let _getStatus = null
+let _version = null
+
+function getSendHeartbeat() {
+  if (!_sendHeartbeat) {
+    _sendHeartbeat = require('../api').sendHeartbeat
+  }
+  return _sendHeartbeat
+}
+
+function getStatusFn() {
+  if (!_getStatus) {
+    _getStatus = require('../routes/health').getStatus
+  }
+  return _getStatus
+}
+
+function getVersion() {
+  if (!_version) {
+    _version = require('../../package.json').version
+  }
+  return _version
+}
+
+/**
+ * Push a status change to HQ immediately (debounced).
+ */
+function pushToHQ() {
+  if (!isHqConfigured()) return
+
+  if (debounceTimer) clearTimeout(debounceTimer)
+  debounceTimer = setTimeout(() => {
+    debounceTimer = null
+    try {
+      const { currentStatus, currentTask } = getStatusFn()
+      getSendHeartbeat()({
+        status: currentStatus,
+        current_task: currentTask,
+        running_tasks: tasks,
+        version: getVersion(),
+      }).catch(err => {
+        console.error('[RunningTasks] Heartbeat push failed:', err.message)
+      })
+    } catch (err) {
+      console.error('[RunningTasks] Failed to push heartbeat:', err.message)
+    }
+  }, DEBOUNCE_MS)
+}
+
+/**
+ * Add a running task.
+ * @param {object} entry
+ * @param {'workflow'|'routine'|'directive'} entry.type
+ * @param {string} [entry.workflow_execution_id]
+ * @param {number} [entry.step_index]
+ * @param {string} [entry.routine_id]
+ * @param {string} entry.session_name
+ * @param {string} [entry.started_at] - ISO timestamp, defaults to now
+ */
+function add(entry) {
+  const task = {
+    type: entry.type,
+    session_name: entry.session_name,
+    started_at: entry.started_at || new Date().toISOString(),
+  }
+  if (entry.workflow_execution_id) task.workflow_execution_id = entry.workflow_execution_id
+  if (entry.step_index != null) task.step_index = entry.step_index
+  if (entry.routine_id) task.routine_id = entry.routine_id
+
+  tasks.push(task)
+  console.log(`[RunningTasks] Added: ${task.type} session=${task.session_name}`)
+  pushToHQ()
+}
+
+/**
+ * Remove a running task by session name.
+ * @param {string} sessionName
+ */
+function remove(sessionName) {
+  const before = tasks.length
+  tasks = tasks.filter(t => t.session_name !== sessionName)
+  if (tasks.length < before) {
+    console.log(`[RunningTasks] Removed: session=${sessionName}`)
+    pushToHQ()
+  }
+}
+
+/**
+ * Get all currently running tasks.
+ * @returns {Array}
+ */
+function getAll() {
+  return [...tasks]
+}
+
+/**
+ * Clear all tasks (used on shutdown).
+ */
+function clear() {
+  tasks = []
+}
+
+module.exports = { add, remove, getAll, clear }

package/core/lib/step-poller.js

@@ -94,7 +94,7 @@ async function executeStep(step) {
     assigned_role,
     skill_name,
     revision_feedback,
-    extra_env,
+    template_vars,
   } = step
 
   console.log(
@@ -125,9 +125,13 @@ async function executeStep(step) {
     }
 
     // 2. Fetch the skill from HQ to ensure it's deployed locally
+    //    Pass template_vars as ?vars= so HQ expands {{VAR_NAME}} in SKILL.md
     if (skill_name) {
       try {
-        const fetchUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/fetch/${encodeURIComponent(skill_name)}`
+        const varsParam = template_vars
+          ? `?vars=${Buffer.from(JSON.stringify(template_vars)).toString('base64')}`
+          : ''
+        const fetchUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/fetch/${encodeURIComponent(skill_name)}${varsParam}`
         const fetchResp = await fetch(fetchUrl, {
           method: 'POST',
           headers: { 'Authorization': `Bearer ${config.API_TOKEN}` },
@@ -152,9 +156,6 @@ async function executeStep(step) {
     if (revision_feedback) {
       runPayload.revision_feedback = revision_feedback
     }
-    if (extra_env && typeof extra_env === 'object') {
-      runPayload.extra_env = extra_env
-    }
 
     const runUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/run`
     const runResp = await fetch(runUrl, {