@geekbeer/minion 2.32.0 → 2.42.3

package/core/routes/diagnose.js

@@ -0,0 +1,296 @@
+/**
+ * Diagnostic endpoint for checking all essential services
+ *
+ * Endpoints:
+ * - GET /api/diagnose - Run full diagnostic check
+ *
+ * Checks:
+ * - Minion Server (Fastify) status
+ * - HQ connectivity (heartbeat reachability)
+ * - Cloudflare Tunnel process
+ * - VNC / websockify (display server)
+ * - Terminal proxy (ttyd / terminal-server)
+ * - LLM CLI availability (Claude, Gemini, Codex)
+ * - Environment variable configuration
+ */
+
+const { execSync } = require('child_process')
+const { config, isHqConfigured } = require('../config')
+const { version } = require('../../package.json')
+const { getLlmServices, isLlmCommandConfigured } = require('../lib/llm-checker')
+const { IS_WINDOWS } = require('../lib/platform')
+const { getStatus } = require('./health')
+
+/**
+ * Check if a process is running by name.
+ * @param {string} name - Process name to search for
+ * @returns {boolean}
+ */
+function isProcessRunning(name) {
+  try {
+    if (IS_WINDOWS) {
+      const out = execSync(`tasklist /FI "IMAGENAME eq ${name}" /NH`, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return out.toLowerCase().includes(name.toLowerCase())
+    } else {
+      execSync(`pgrep -f "${name}"`, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if a local TCP port is listening.
+ * @param {number} port
+ * @returns {boolean}
+ */
+function isPortListening(port) {
+  try {
+    if (IS_WINDOWS) {
+      const out = execSync(`netstat -an | findstr ":${port} "`, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return out.includes('LISTENING')
+    } else {
+      const out = execSync(`ss -tlnp 2>/dev/null | grep ":${port} " || netstat -tlnp 2>/dev/null | grep ":${port} "`, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return out.trim().length > 0
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check HQ connectivity by sending a test heartbeat.
+ * @returns {Promise<{ ok: boolean, latency_ms?: number, error?: string }>}
+ */
+async function checkHqConnectivity() {
+  if (!isHqConfigured()) {
+    return { ok: false, error: 'HQ not configured (standalone mode)' }
+  }
+
+  const url = `${config.HQ_URL}/api/minion/heartbeat`
+  const { currentStatus, currentTask } = getStatus()
+  const start = Date.now()
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.API_TOKEN}`,
+      },
+      body: JSON.stringify({ status: currentStatus, current_task: currentTask, version }),
+      signal: AbortSignal.timeout(10000),
+    })
+    const latency = Date.now() - start
+
+    if (!response.ok) {
+      const data = await response.json().catch(() => ({}))
+      return { ok: false, latency_ms: latency, error: `HTTP ${response.status}: ${data.error || response.statusText}` }
+    }
+
+    return { ok: true, latency_ms: latency }
+  } catch (err) {
+    const latency = Date.now() - start
+    return { ok: false, latency_ms: latency, error: err.message }
+  }
+}
+
+/**
+ * Check Cloudflare Tunnel status.
+ * @returns {{ running: boolean, details?: string }}
+ */
+function checkTunnel() {
+  if (IS_WINDOWS) {
+    const running = isProcessRunning('cloudflared.exe')
+    return { running, details: running ? 'cloudflared.exe process found' : 'cloudflared.exe not running' }
+  }
+
+  // Linux: check for cloudflared process
+  const running = isProcessRunning('cloudflared')
+  if (!running) {
+    return { running: false, details: 'cloudflared not running' }
+  }
+
+  // Check if it's a tunnel connector (not just any cloudflared)
+  try {
+    const out = execSync('pgrep -af "cloudflared.*tunnel"', {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: 'pipe',
+    }).trim()
+    return { running: true, details: out.split('\n')[0] || 'cloudflared tunnel running' }
+  } catch {
+    return { running: true, details: 'cloudflared running (tunnel mode unconfirmed)' }
+  }
+}
+
+/**
+ * Check VNC / display server status.
+ * @returns {{ running: boolean, port?: number, details?: string }}
+ */
+function checkVnc() {
+  if (IS_WINDOWS) {
+    // TightVNC on Windows
+    const running = isProcessRunning('tvnserver.exe')
+    const websockify = isPortListening(6080)
+    return {
+      running: running && websockify,
+      details: [
+        `TightVNC: ${running ? 'running' : 'not running'}`,
+        `websockify (:6080): ${websockify ? 'listening' : 'not listening'}`,
+      ].join(', '),
+    }
+  }
+
+  // Linux: Xvfb + x11vnc + websockify (noVNC)
+  const xvfb = isProcessRunning('Xvfb')
+  const vnc = isProcessRunning('x11vnc')
+  const websockify = isPortListening(6080)
+  return {
+    running: xvfb && websockify,
+    details: [
+      `Xvfb: ${xvfb ? 'running' : 'not running'}`,
+      `x11vnc: ${vnc ? 'running' : 'not running'}`,
+      `websockify (:6080): ${websockify ? 'listening' : 'not listening'}`,
+    ].join(', '),
+  }
+}
+
+/**
+ * Check terminal proxy status.
+ * @returns {{ running: boolean, port?: number, details?: string }}
+ */
+function checkTerminal() {
+  if (IS_WINDOWS) {
+    // Windows terminal server runs on port 7681
+    const listening = isPortListening(7681)
+    return {
+      running: listening,
+      details: `terminal-server (:7681): ${listening ? 'listening' : 'not listening'}`,
+    }
+  }
+
+  // Linux: ttyd on port 7681
+  const ttyd = isProcessRunning('ttyd')
+  const listening = isPortListening(7681)
+  return {
+    running: ttyd || listening,
+    details: [
+      `ttyd: ${ttyd ? 'running' : 'not running'}`,
+      `port 7681: ${listening ? 'listening' : 'not listening'}`,
+    ].join(', '),
+  }
+}
+
+/**
+ * Check LLM service availability.
+ * @returns {{ services: object[], llm_command: { configured: boolean, value: string } }}
+ */
+function checkLlm() {
+  return {
+    services: getLlmServices(),
+    llm_command: {
+      configured: isLlmCommandConfigured(),
+      value: config.LLM_COMMAND || '(not set)',
+    },
+  }
+}
+
+/**
+ * Check environment variable configuration.
+ * @returns {{ configured: string[], missing: string[] }}
+ */
+function checkEnv() {
+  const required = ['HQ_URL', 'API_TOKEN', 'MINION_ID']
+  const optional = ['AGENT_PORT', 'LLM_COMMAND', 'HEARTBEAT_INTERVAL', 'MINION_USER']
+
+  const configured = []
+  const missing = []
+
+  for (const key of required) {
+    if (config[key] || process.env[key]) {
+      configured.push(key)
+    } else {
+      missing.push(key)
+    }
+  }
+  for (const key of optional) {
+    if (config[key] || process.env[key]) {
+      configured.push(key)
+    }
+  }
+
+  return { configured, missing }
+}
+
+/**
+ * Register diagnose routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function diagnoseRoutes(fastify) {
+  fastify.get('/api/diagnose', async () => {
+    const { currentStatus, currentTask } = getStatus()
+
+    // Run HQ check (async) in parallel with sync checks
+    const [hq, tunnel, vnc, terminal, llm, env] = await Promise.all([
+      checkHqConnectivity(),
+      Promise.resolve(checkTunnel()),
+      Promise.resolve(checkVnc()),
+      Promise.resolve(checkTerminal()),
+      Promise.resolve(checkLlm()),
+      Promise.resolve(checkEnv()),
+    ])
+
+    // Build summary: count ok/warn/fail
+    const checks = {
+      agent: { ok: true, details: `status=${currentStatus}, uptime=${Math.floor(process.uptime())}s` },
+      hq: { ok: hq.ok, details: hq.error || `latency=${hq.latency_ms}ms` },
+      tunnel: { ok: tunnel.running, details: tunnel.details },
+      vnc: { ok: vnc.running, details: vnc.details },
+      terminal: { ok: terminal.running, details: terminal.details },
+      llm: {
+        ok: llm.services.some(s => s.authenticated) && llm.llm_command.configured,
+        details: llm.services.map(s => `${s.name}:${s.authenticated ? 'ok' : 'ng'}`).join(', ')
+          + ` | llm_command:${llm.llm_command.configured ? 'ok' : 'ng'}`,
+      },
+      env: {
+        ok: env.missing.length === 0,
+        details: env.missing.length === 0
+          ? `all configured (${env.configured.join(', ')})`
+          : `missing: ${env.missing.join(', ')}`,
+      },
+    }
+
+    const okCount = Object.values(checks).filter(c => c.ok).length
+    const totalCount = Object.keys(checks).length
+    const allOk = okCount === totalCount
+
+    return {
+      summary: allOk ? 'ALL OK' : `${okCount}/${totalCount} checks passed`,
+      version,
+      platform: IS_WINDOWS ? 'windows' : 'linux',
+      timestamp: new Date().toISOString(),
+      current_task: currentTask,
+      checks,
+    }
+  })
+}
+
+module.exports = { diagnoseRoutes }

package/core/routes/health.js

@@ -8,8 +8,15 @@
  */
 
 const { version } = require('../../package.json')
+const { config, isHqConfigured } = require('../config')
+const { sendHeartbeat } = require('../api')
 const { getLlmServices, isLlmCommandConfigured } = require('../lib/llm-checker')
 
+function maskToken(token) {
+  if (!token || token.length < 8) return token ? '***' : ''
+  return token.slice(0, 3) + '...' + token.slice(-3)
+}
+
 // Shared status state
 let currentStatus = 'online'
 let currentTask = null
@@ -51,6 +58,15 @@ async function healthRoutes(fastify) {
       timestamp: new Date().toISOString(),
       llm_services: getLlmServices(),
       llm_command_configured: isLlmCommandConfigured(),
+      env: {
+        HQ_URL: config.HQ_URL || '',
+        MINION_ID: config.MINION_ID || '',
+        MINION_USER: process.env.MINION_USER || '',
+        AGENT_PORT: config.AGENT_PORT,
+        API_TOKEN: maskToken(config.API_TOKEN),
+        LLM_COMMAND: config.LLM_COMMAND || '',
+        HEARTBEAT_INTERVAL: process.env.HEARTBEAT_INTERVAL || '',
+      },
     }
   })
 
@@ -58,18 +74,29 @@ async function healthRoutes(fastify) {
   fastify.post('/api/status', async (request, reply) => {
     const { status, current_task } = request.body || {}
 
+    let changed = false
+
     if (status) {
       if (!['online', 'offline', 'busy'].includes(status)) {
         reply.code(400)
         return { success: false, error: `Invalid status: ${status}` }
       }
+      if (currentStatus !== status) changed = true
       currentStatus = status
     }
 
     if (current_task !== undefined) {
+      if (currentTask !== (current_task || null)) changed = true
       currentTask = current_task || null
     }
 
+    // Push status change to HQ immediately via heartbeat
+    if (changed && isHqConfigured()) {
+      sendHeartbeat({ status: currentStatus, current_task: currentTask, version }).catch(err => {
+        console.error('[Heartbeat] Status-change heartbeat failed:', err.message)
+      })
+    }
+
     return { success: true }
   })
 }

package/core/routes/routines.js

@@ -81,7 +81,7 @@ async function routineRoutes(fastify, opts) {
 
     // Merge routine data with runtime status
     const result = routines.map(r => {
-      const runtimeInfo = status.routines.find(rr => rr.id === r.id)
+      const runtimeInfo = status.routines.find(rr => String(rr.id) === String(r.id))
       return {
         ...r,
         next_run: runtimeInfo?.next_run || null,
@@ -149,13 +149,15 @@ async function routineRoutes(fastify, opts) {
     const { id } = request.params
     const updates = request.body || {}
 
-    console.log(`[Routines] Updating routine schedule: ${id}`)
+    console.log(`[Routines] Updating routine schedule: ${id} (type: ${typeof id})`)
 
     try {
       const routines = await routineStore.load()
-      const index = routines.findIndex(r => r.id === id)
+      const index = routines.findIndex(r => String(r.id) === String(id))
 
       if (index < 0) {
+        const storedIds = routines.map(r => `${r.name}(id=${r.id}, type=${typeof r.id})`).join(', ')
+        console.error(`[Routines] Schedule update: routine not found. Requested id=${id}. Stored: [${storedIds}]`)
         reply.code(404)
         return { success: false, error: 'Routine not found' }
       }
@@ -195,7 +197,7 @@ async function routineRoutes(fastify, opts) {
 
     try {
       const routines = await routineStore.load()
-      const index = routines.findIndex(r => r.id === id)
+      const index = routines.findIndex(r => String(r.id) === String(id))
 
       if (index < 0) {
         reply.code(404)
@@ -265,20 +267,23 @@ async function routineRoutes(fastify, opts) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { routine_id } = request.body || {}
+    const { routine_id, routine_name } = request.body || {}
 
-    if (!routine_id) {
+    if (!routine_id && !routine_name) {
       reply.code(400)
-      return { success: false, error: 'routine_id is required' }
+      return { success: false, error: 'routine_id or routine_name is required' }
     }
 
-    // Find the routine in local store
+    // Find the routine in local store (try id first, then name fallback)
     const routines = await routineStore.load()
-    const routine = routines.find(r => r.id === routine_id)
+    const routine = routines.find(r => routine_id != null && String(r.id) === String(routine_id))
+      || (routine_name && routines.find(r => r.name === routine_name))
 
     if (!routine) {
+      const storedIds = routines.map(r => `${r.name}(${r.id || 'no-id'})`).join(', ')
+      console.error(`[Routines] Trigger: routine not found. Requested id=${routine_id}, name=${routine_name}. Stored: [${storedIds}]`)
       reply.code(404)
-      return { success: false, error: 'Routine not found' }
+      return { success: false, error: `Routine not found (id=${routine_id}). Available: [${storedIds}]` }
     }
 
     console.log(`[Routines] Manual trigger for: ${routine.name}`)

package/core/routes/skills.js

@@ -51,7 +51,7 @@ function parseFrontmatter(content) {
  * @param {Array<{filename: string, content: string}>} [opts.references] - Reference files
  * @returns {Promise<{path: string, references_count: number}>}
  */
-async function writeSkillToLocal(name, { content, description, display_name, references = [] }) {
+async function writeSkillToLocal(name, { content, description, display_name, type, references = [] }) {
   const skillDir = path.join(config.HOME_DIR, '.claude', 'skills', name)
   const referencesDir = path.join(skillDir, 'references')
 
@@ -62,6 +62,7 @@ async function writeSkillToLocal(name, { content, description, display_name, ref
   const frontmatterLines = [
     `name: ${name}`,
     display_name ? `display_name: ${display_name}` : null,
+    type ? `type: ${type}` : null,
     `description: ${description || ''}`,
   ].filter(Boolean).join('\n')
 
@@ -118,6 +119,7 @@ async function pushSkillToHQ(name) {
       display_name: metadata.display_name || metadata.name || name,
       description: metadata.description || '',
       content: body,
+      type: metadata.type || 'workflow',
       references,
     }),
   })
@@ -240,6 +242,7 @@ async function skillRoutes(fastify, opts) {
         content: skill.content,
         description: skill.description,
         display_name: skill.display_name,
+        type: skill.type,
         references: skill.references || [],
       })
 

package/core/routes/workflows.js

@@ -14,10 +14,12 @@
  * - GET  /api/executions/:id         - Get single execution details
  * - GET  /api/executions/:id/log     - Get execution log file content
  * - POST /api/executions/:id/outcome - Update execution outcome (no auth, local)
+ * - POST /api/workflows/orchestrate  - Start multi-minion orchestration (from HQ)
  */
 
 const fs = require('fs').promises
 const path = require('path')
+const { orchestrate } = require('../lib/workflow-orchestrator')
 
 const { verifyToken } = require('../lib/auth')
 const workflowStore = require('../stores/workflow-store')
@@ -493,8 +495,53 @@ async function workflowRoutes(fastify, opts) {
     }
   })
 
-  // Update execution outcome (called by /execution-report skill)
-  // This endpoint does NOT require auth - skills run in the same environment
+  // Orchestrate a multi-minion workflow execution (called by HQ)
+  fastify.post('/api/workflows/orchestrate', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { execution_id, steps, hq_url } = request.body || {}
+
+    if (!execution_id || !Array.isArray(steps)) {
+      reply.code(400)
+      return { success: false, error: 'execution_id and steps[] are required' }
+    }
+
+    console.log(`[Workflows] Starting orchestration for execution: ${execution_id} (${steps.length} steps)`)
+
+    // Load optional PM revision policy
+    let revisionPolicy = ''
+    try {
+      const policyPath = path.join(config.HOME_DIR, '.minion', 'revision-policy.md')
+      revisionPolicy = await fs.readFile(policyPath, 'utf-8')
+    } catch {
+      // No custom policy — use defaults
+    }
+
+    // Run orchestration asynchronously
+    orchestrate({ executionId: execution_id, steps, hqUrl: hq_url, revisionPolicy })
+      .then((result) => {
+        if (result.success) {
+          console.log(`[Workflows] Orchestration completed: ${execution_id}`)
+        } else {
+          console.error(`[Workflows] Orchestration failed: ${execution_id} — ${result.error}`)
+        }
+      })
+      .catch((err) => {
+        console.error(`[Workflows] Orchestration error: ${execution_id} — ${err.message}`)
+      })
+
+    return {
+      success: true,
+      message: 'Orchestration started',
+      execution_id,
+    }
+  })
+
+  // Update execution outcome (called by workflow runner after completion)
+  // This endpoint does NOT require auth - runs in the same environment
   fastify.post('/api/executions/:id/outcome', async (request, reply) => {
     const { id } = request.params
     const { outcome, summary, details } = request.body || {}

package/core/stores/chat-store.js

@@ -8,18 +8,18 @@ const fs = require('fs').promises
 const path = require('path')
 
 const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
 
 const MAX_MESSAGES = 100
 
 /**
  * Get chat session file path
- * Uses /opt/minion-agent/ if available, otherwise home dir
+ * Uses DATA_DIR if available (platform-aware), otherwise home dir
  */
 function getFilePath() {
-  const optPath = '/opt/minion-agent/chat-session.json'
   try {
-    require('fs').accessSync(path.dirname(optPath))
-    return optPath
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'chat-session.json')
   } catch {
     return path.join(config.HOME_DIR, 'chat-session.json')
   }
@@ -61,8 +61,9 @@ async function save(session) {
  * Creates a new session if none exists
  * @param {string} sessionId - Claude CLI session ID
  * @param {{ role: string, content: string }} msg - Message to add
+ * @param {number} [turnCount] - Optional turn count to update session with
  */
-async function addMessage(sessionId, msg) {
+async function addMessage(sessionId, msg, turnCount) {
   let session = await load()
 
   // If session_id changed, start a new session
@@ -70,6 +71,7 @@ async function addMessage(sessionId, msg) {
     session = {
       session_id: sessionId,
       messages: [],
+      turn_count: 0,
       created_at: Date.now(),
       updated_at: Date.now(),
     }
@@ -82,6 +84,11 @@ async function addMessage(sessionId, msg) {
   })
   session.updated_at = Date.now()
 
+  // Update turn count if provided
+  if (typeof turnCount === 'number' && turnCount > 0) {
+    session.turn_count = (session.turn_count || 0) + turnCount
+  }
+
   // Prune old messages
   if (session.messages.length > MAX_MESSAGES) {
     session.messages = session.messages.slice(-MAX_MESSAGES)

package/core/stores/execution-store.js

@@ -8,19 +8,19 @@ const fs = require('fs').promises
 const path = require('path')
 
 const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
 
 // Max executions to keep (older ones are pruned)
 const MAX_EXECUTIONS = 200
 
 /**
  * Get execution file path
- * Uses /opt/minion-agent/ if available, otherwise home dir
+ * Uses DATA_DIR if available (platform-aware), otherwise home dir
  */
 function getExecutionFilePath() {
-  const optPath = '/opt/minion-agent/executions.json'
   try {
-    require('fs').accessSync(path.dirname(optPath))
-    return optPath
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'executions.json')
   } catch {
     return path.join(config.HOME_DIR, 'executions.json')
   }

package/core/stores/routine-store.js

@@ -8,14 +8,14 @@ const fs = require('fs').promises
 const path = require('path')
 
 const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
 
-// Routine file location: /opt/minion-agent/routines.json (systemd/supervisord)
-// or ~/routines.json (standalone)
+// Routine file location: DATA_DIR/routines.json (platform-aware)
+// or ~/routines.json (fallback)
 function getRoutineFilePath() {
-  const optPath = '/opt/minion-agent/routines.json'
   try {
-    require('fs').accessSync(path.dirname(optPath))
-    return optPath
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'routines.json')
   } catch {
     return path.join(config.HOME_DIR, 'routines.json')
   }
@@ -60,7 +60,7 @@ async function save(routines) {
  */
 async function updateLastRun(routineId) {
   const routines = await load()
-  const routine = routines.find(r => r.id === routineId)
+  const routine = routines.find(r => String(r.id) === String(routineId))
   if (routine) {
     routine.last_run = new Date().toISOString()
     await save(routines)
@@ -85,7 +85,7 @@ async function findByName(name) {
  */
 async function upsertFromHQ(routineData) {
   const routines = await load()
-  const index = routines.findIndex(r => r.id === routineData.id)
+  const index = routines.findIndex(r => String(r.id) === String(routineData.id))
 
   if (index >= 0) {
     // Update from HQ (preserve local-only fields if any)

package/core/stores/workflow-store.js

@@ -8,15 +8,14 @@ const fs = require('fs').promises
 const path = require('path')
 
 const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
 
-// Workflow file location: /opt/minion-agent/workflows.json (systemd/supervisord)
-// or ~/workflows.json (standalone)
+// Workflow file location: DATA_DIR/workflows.json (platform-aware)
+// or ~/workflows.json (fallback)
 function getWorkflowFilePath() {
-  const optPath = '/opt/minion-agent/workflows.json'
-  // Use /opt path if it exists (production), otherwise home dir
   try {
-    require('fs').accessSync(path.dirname(optPath))
-    return optPath
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'workflows.json')
   } catch {
     return path.join(config.HOME_DIR, 'workflows.json')
   }