@geekbeer/minion 3.14.0 → 3.16.1

package/core/lib/dag-node-executor.js

@@ -0,0 +1,81 @@
+/**
+ * DAG Node Executor
+ *
+ * Handles the execution lifecycle of a single DAG node.
+ * Responsible for:
+ * - Extracting structured output_data from skill execution results
+ * - Reporting completion to HQ via /api/dag/minion/node-complete
+ *
+ * Called by the post-execution hook in skills.js when a DAG node skill completes.
+ */
+
+const { reportNodeComplete } = require('./dag-step-poller')
+
+/**
+ * Parse structured output_data from a skill's execution output.
+ *
+ * Convention: Skills produce structured output via a "## Output Data" section
+ * in their execution report, containing a JSON code block.
+ *
+ * Example:
+ * ```
+ * ## Output Data
+ * ```json
+ * { "results": [...], "count": 5 }
+ * ```
+ * ```
+ *
+ * If no structured output is found, wraps the raw summary as { _raw: "..." }
+ */
+function extractOutputData(summary, details) {
+  const fullText = [summary, details].filter(Boolean).join('\n\n')
+
+  // Try to find ## Output Data section with JSON
+  const outputDataMatch = fullText.match(
+    /##\s*Output\s*Data\s*\n+```(?:json)?\s*\n([\s\S]*?)\n```/i
+  )
+
+  if (outputDataMatch) {
+    try {
+      return JSON.parse(outputDataMatch[1].trim())
+    } catch {
+      console.warn('[DagNodeExecutor] Failed to parse Output Data JSON, using raw')
+    }
+  }
+
+  // Fallback: try to parse the entire summary as JSON
+  if (summary) {
+    try {
+      const parsed = JSON.parse(summary)
+      if (typeof parsed === 'object' && parsed !== null) {
+        return parsed
+      }
+    } catch {
+      // Not JSON, use raw
+    }
+  }
+
+  return { _raw: fullText || '' }
+}
+
+/**
+ * Report DAG node completion with extracted output_data.
+ *
+ * @param {string} nodeExecutionId - The dag_node_execution ID
+ * @param {string} status - 'completed' or 'failed'
+ * @param {string} summary - Execution summary text
+ * @param {string} details - Execution details text
+ */
+async function reportDagNodeComplete(nodeExecutionId, status, summary, details) {
+  const outputSummary = [summary, details].filter(Boolean).join('\n\n')
+  const outputData = status === 'completed'
+    ? extractOutputData(summary, details)
+    : {}
+
+  return reportNodeComplete(nodeExecutionId, status, outputData, outputSummary)
+}
+
+module.exports = {
+  extractOutputData,
+  reportDagNodeComplete,
+}

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

@@ -0,0 +1,282 @@
+/**
+ * DAG Step Poller
+ *
+ * Polling daemon for DAG workflow execution.
+ * Similar to step-poller.js but with key differences:
+ * - Polls /api/dag/minion/pending-nodes instead of /api/minion/pending-steps
+ * - 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')
+const api = require('../api')
+const variableStore = require('../stores/variable-store')
+
+// Polling interval: 30 seconds (matches step-poller)
+const POLL_INTERVAL_MS = 30_000
+
+// Maximum concurrent DAG nodes this minion can execute
+const MAX_CONCURRENT = 2
+
+// Prevent concurrent poll cycles
+let polling = false
+let pollTimer = null
+let lastPollAt = null
+
+// Track active node executions: nodeExecId -> Promise
+const activeNodes = new Map()
+
+/**
+ * Send request to HQ's DAG API endpoints.
+ */
+async function dagRequest(endpoint, options = {}) {
+  if (!isHqConfigured()) {
+    return { skipped: true, reason: 'HQ not configured' }
+  }
+
+  const url = `${config.HQ_URL}/api/dag/minion${endpoint}`
+  const resp = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${config.API_TOKEN}`,
+      ...(options.headers || {}),
+    },
+  })
+
+  if (!resp.ok) {
+    const err = new Error(`DAG API ${endpoint} failed: ${resp.status}`)
+    err.statusCode = resp.status
+    throw err
+  }
+
+  return resp.json()
+}
+
+/**
+ * Poll HQ for pending DAG nodes and execute them.
+ */
+async function pollOnce() {
+  if (!isHqConfigured()) return
+  if (polling) return
+
+  polling = true
+  try {
+    const data = await dagRequest('/pending-nodes')
+
+    if (!data.nodes || data.nodes.length === 0) return
+
+    console.log(`[DagPoller] Found ${data.nodes.length} pending node(s), active: ${activeNodes.size}/${MAX_CONCURRENT}`)
+
+    for (const node of data.nodes) {
+      if (activeNodes.size >= MAX_CONCURRENT) break
+      if (activeNodes.has(node.node_execution_id)) continue
+
+      const promise = executeNode(node)
+        .catch(err => {
+          console.error(`[DagPoller] Node ${node.node_id} execution error: ${err.message}`)
+        })
+        .finally(() => {
+          activeNodes.delete(node.node_execution_id)
+        })
+
+      activeNodes.set(node.node_execution_id, promise)
+    }
+  } catch (err) {
+    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+      console.log('[DagPoller] HQ unreachable, will retry next cycle')
+    } else {
+      console.error(`[DagPoller] Poll error: ${err.message}`)
+    }
+  } finally {
+    polling = false
+    lastPollAt = new Date().toISOString()
+  }
+}
+
+/**
+ * Execute a single pending DAG node:
+ * 1. Claim the node
+ * 2. Fetch the skill from HQ
+ * 3. Run the skill locally (with input_data injected)
+ * 4. Report completion with output_data
+ */
+async function executeNode(node) {
+  const {
+    node_execution_id,
+    execution_id,
+    dag_workflow_name,
+    node_id,
+    scope_path,
+    skill_version_id,
+    skill_name: resolvedSkillName,
+    assigned_role,
+    input_data,
+    revision_feedback,
+  } = node
+
+  console.log(
+    `[DagPoller] Executing node "${node_id}" of DAG "${dag_workflow_name}" ` +
+    `(skill: ${resolvedSkillName || skill_version_id}, scope: "${scope_path || 'root'}", role: ${assigned_role})`
+  )
+
+  try {
+    // 1. Claim the node
+    try {
+      await dagRequest('/claim-node', {
+        method: 'POST',
+        body: JSON.stringify({ node_execution_id }),
+      })
+    } catch (claimErr) {
+      if (claimErr.statusCode === 409) {
+        console.log(`[DagPoller] Node ${node_id} already claimed, skipping`)
+        return
+      }
+      throw claimErr
+    }
+
+    // 2. Resolve skill name (prefer pre-resolved from pending-nodes, fall back to API)
+    const skillName = resolvedSkillName || await resolveSkillName(skill_version_id)
+    if (!skillName) {
+      console.error(`[DagPoller] Could not resolve skill name for version ${skill_version_id}`)
+      await reportNodeComplete(node_execution_id, 'failed', null, 'Could not resolve skill name')
+      return
+    }
+
+    // 3. Fetch the skill
+    if (skillName) {
+      try {
+        const minionVars = variableStore.getAll('variables')
+        const mergedVars = { ...minionVars }
+        const varsParam = Object.keys(mergedVars).length > 0
+          ? `?vars=${Buffer.from(JSON.stringify(mergedVars)).toString('base64')}`
+          : ''
+        const fetchUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/fetch/${encodeURIComponent(skillName)}${varsParam}`
+        await fetch(fetchUrl, {
+          method: 'POST',
+          headers: { 'Authorization': `Bearer ${config.API_TOKEN}` },
+        })
+      } catch (fetchErr) {
+        console.error(`[DagPoller] Skill fetch error: ${fetchErr.message}`)
+      }
+    }
+
+    // 4. Run the skill with input_data context
+    const runPayload = {
+      skill_name: skillName,
+      execution_id,
+      workflow_name: dag_workflow_name,
+      role: assigned_role,
+      // DAG-specific: inject input_data as context
+      dag_node_id: node_id,
+      dag_input_data: input_data,
+      dag_node_execution_id: node_execution_id,
+    }
+    if (revision_feedback) {
+      runPayload.revision_feedback = revision_feedback
+    }
+
+    const runUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/run`
+    const runResp = await fetch(runUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.API_TOKEN}`,
+      },
+      body: JSON.stringify(runPayload),
+    })
+
+    if (!runResp.ok) {
+      const errData = await runResp.json().catch(() => ({}))
+      console.error(`[DagPoller] Skill run failed: ${errData.error || runResp.status}`)
+      await reportNodeComplete(
+        node_execution_id,
+        'failed',
+        null,
+        `Failed to start skill: ${errData.error || 'unknown error'}`
+      )
+      return
+    }
+
+    const runData = await runResp.json()
+    console.log(
+      `[DagPoller] Skill "${skillName}" started for node "${node_id}" ` +
+      `(session: ${runData.session_name}). Completion reported by post-execution hook.`
+    )
+
+    // Note: The post-execution hook in skills.js needs to be extended to handle DAG nodes.
+    // For now, we wait for the skill to complete and then report via the session monitor.
+    // This will be handled by dag-node-executor.js which watches the session.
+
+  } catch (err) {
+    console.error(`[DagPoller] Failed to execute node ${node_id}: ${err.message}`)
+    try {
+      await reportNodeComplete(node_execution_id, 'failed', null, err.message)
+    } catch {
+      // best-effort
+    }
+  }
+}
+
+/**
+ * Resolve skill_version_id to skill name via HQ API.
+ */
+async function resolveSkillName(skillVersionId) {
+  if (!skillVersionId) return null
+  try {
+    // Use existing skill fetch pattern — the skill name is returned by pending-nodes
+    // But if not available, we need to resolve it
+    const data = await api.request(`/skill-version/${skillVersionId}`)
+    return data?.skill_name || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Report node completion to HQ.
+ */
+async function reportNodeComplete(nodeExecutionId, status, outputData, outputSummary) {
+  return dagRequest('/node-complete', {
+    method: 'POST',
+    body: JSON.stringify({
+      node_execution_id: nodeExecutionId,
+      status,
+      output_data: outputData || {},
+      output_summary: outputSummary || null,
+    }),
+  })
+}
+
+function start() {
+  if (!isHqConfigured()) {
+    console.log('[DagPoller] HQ not configured, DAG poller disabled')
+    return
+  }
+
+  setTimeout(() => pollOnce(), 7000) // Slightly delayed after step-poller
+  pollTimer = setInterval(() => pollOnce(), POLL_INTERVAL_MS)
+  console.log(`[DagPoller] Started (polling every ${POLL_INTERVAL_MS / 1000}s, max concurrent: ${MAX_CONCURRENT})`)
+}
+
+function stop() {
+  if (pollTimer) {
+    clearInterval(pollTimer)
+    pollTimer = null
+    console.log('[DagPoller] Stopped')
+  }
+}
+
+function getStatus() {
+  return {
+    running: pollTimer !== null,
+    last_poll_at: lastPollAt,
+    active_nodes: activeNodes.size,
+    max_concurrent: MAX_CONCURRENT,
+  }
+}
+
+module.exports = { start, stop, pollOnce, getStatus, reportNodeComplete }

package/docs/api-reference.md

@@ -568,7 +568,7 @@ Note: 既読メールは受信後90日で自動削除される。未読メール
 | GET | `/api/commands` | List available whitelisted commands |
 | POST | `/api/command` | Execute command. Body: `{command}` |
 
-Available commands: `restart-agent`, `update-agent`, `restart-display`, `status-services`
+Available commands: `restart-agent`, `update-agent`, `restart-display`, `restart-all`, `status-services`
 
 ---
 

package/linux/lib/process-manager.js

@@ -63,6 +63,11 @@ function buildAllowedCommands(procMgr) {
       description: 'Restart Xvfb, Fluxbox, x11vnc and noVNC services',
       command: `${SUDO}systemctl restart xvfb fluxbox x11vnc novnc`,
     }
+    commands['restart-all'] = {
+      description: 'Restart all services (display stack + agent)',
+      command: `${SUDO}systemctl restart xvfb fluxbox x11vnc novnc && ${SUDO}systemctl restart minion-agent`,
+      deferred: true,
+    }
     commands['status-services'] = {
       description: 'Check status of all services',
       command: 'systemctl status minion-agent xvfb fluxbox x11vnc novnc --no-pager',
@@ -87,6 +92,11 @@ function buildAllowedCommands(procMgr) {
       description: 'Restart Xvfb, x11vnc and noVNC services',
       command: `${SUDO}supervisorctl restart xvfb fluxbox x11vnc novnc`,
     }
+    commands['restart-all'] = {
+      description: 'Restart all services (display stack + agent)',
+      command: `${SUDO}supervisorctl restart xvfb fluxbox x11vnc novnc && ${SUDO}supervisorctl restart minion-agent`,
+      deferred: true,
+    }
     commands['status-services'] = {
       description: 'Check status of all services',
       command: `${SUDO}supervisorctl status`,

package/linux/server.js

@@ -58,6 +58,7 @@ const { getConfigWarnings } = require('../core/lib/config-warnings')
 
 // Pull-model daemons (from core/)
 const stepPoller = require('../core/lib/step-poller')
+const dagStepPoller = require('../core/lib/dag-step-poller')
 const revisionWatcher = require('../core/lib/revision-watcher')
 const reflectionScheduler = require('../core/lib/reflection-scheduler')
 const threadWatcher = require('../core/lib/thread-watcher')
@@ -122,6 +123,7 @@ async function shutdown(signal) {
 
   // Stop pollers, runners, and scheduler
   stepPoller.stop()
+  dagStepPoller.stop()
   revisionWatcher.stop()
   reflectionScheduler.stop()
   threadWatcher.stop()
@@ -391,6 +393,7 @@ async function start() {
 
       // Start Pull-model daemons
       stepPoller.start()
+      dagStepPoller.start()
       revisionWatcher.start()
       threadWatcher.start(runQuickLlmCall)
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "3.14.0",
+  "version": "3.16.1",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {

package/win/lib/process-manager.js

@@ -220,6 +220,62 @@ function buildRestartScript(_nssmPath, agentPort, apiToken) {
   return scriptPath
 }
 
+/**
+ * Generate a temporary PowerShell script for restarting ALL services:
+ * 1. Restart display services (VNC + websockify)
+ * 2. Graceful shutdown of agent via HTTP API
+ * 3. Restart agent service via NSSM
+ * 4. Remove the temporary updater service (self-cleanup)
+ *
+ * @param {string} _nssmPath - Absolute path to nssm.exe
+ * @param {number} agentPort - The agent's HTTP port
+ * @param {string} apiToken - The agent's API token
+ * @returns {string} - Path to the generated restart script (.ps1)
+ */
+function buildRestartAllScript(_nssmPath, agentPort, apiToken) {
+  const dataDir = path.join(os.homedir(), '.minion')
+  const homeDir = os.homedir()
+  const scriptPath = path.join(dataDir, 'restart-all.ps1')
+  const logDir = path.join(dataDir, 'logs')
+  const logPath = path.join(logDir, 'restart-all.log')
+
+  const gracefulStop = buildGracefulStopBlock(agentPort, apiToken)
+
+  const ps1 = [
+    `$env:USERPROFILE = '${homeDir}'`,
+    `$env:HOME = '${homeDir}'`,
+    `$ErrorActionPreference = 'Stop'`,
+    `$nssm = '${path.join(dataDir, 'nssm.exe')}'`,
+    `$logFile = '${logPath}'`,
+    `function Log($msg) { "$(Get-Date -Format o) $msg" | Out-File -Append $logFile }`,
+    `Log 'Restart-all started'`,
+    `try {`,
+    `  Log 'Restarting display services...'`,
+    `  try { & $nssm restart minion-vnc 2>&1 | ForEach-Object { Log "minion-vnc: $_" } } catch { Log "minion-vnc restart failed: $_" }`,
+    `  try { & $nssm restart minion-websockify 2>&1 | ForEach-Object { Log "minion-websockify: $_" } } catch { Log "minion-websockify restart failed: $_" }`,
+    `  Log 'Display services restarted'`,
+    `  Log 'Requesting graceful shutdown of agent...'`,
+    gracefulStop,
+    `  Log 'Restarting agent service via NSSM...'`,
+    `  & $nssm restart minion-agent`,
+    `  Log 'Restart-all completed successfully'`,
+    `} catch {`,
+    `  Log "Restart-all failed: $_"`,
+    `  Log 'Attempting to start agent service anyway...'`,
+    `  & $nssm start minion-agent`,
+    `} finally {`,
+    `  Log 'Cleaning up updater service...'`,
+    `  & $nssm stop minion-update confirm 2>$null`,
+    `  & $nssm remove minion-update confirm 2>$null`,
+    `}`,
+  ].join('\n')
+
+  try { fs.mkdirSync(dataDir, { recursive: true }) } catch { /* exists */ }
+  fs.writeFileSync(scriptPath, ps1, 'utf-8')
+
+  return scriptPath
+}
+
 /**
  * Build allowed commands for NSSM-based service management.
  *
@@ -271,6 +327,12 @@ function buildAllowedCommands(_procMgr, agentConfig = {}) {
     command: `"${nssmPath}" restart minion-vnc & "${nssmPath}" restart minion-websockify`,
   }
 
+  commands['restart-all'] = {
+    description: 'Restart all services (display + agent)',
+    nssmService: { scriptPath: buildRestartAllScript(nssmPath, agentPort, apiToken) },
+    deferred: true,
+  }
+
   commands['restart-tunnel'] = {
     description: 'Restart Cloudflare tunnel service',
     command: `"${nssmPath}" restart minion-cloudflared`,

package/win/server.js

@@ -34,6 +34,7 @@ const { getConfigWarnings } = require('../core/lib/config-warnings')
 
 // Pull-model daemons (from core/)
 const stepPoller = require('../core/lib/step-poller')
+const dagStepPoller = require('../core/lib/dag-step-poller')
 const revisionWatcher = require('../core/lib/revision-watcher')
 const reflectionScheduler = require('../core/lib/reflection-scheduler')
 const threadWatcher = require('../core/lib/thread-watcher')
@@ -94,6 +95,7 @@ async function shutdown(signal) {
   }
 
   stepPoller.stop()
+  dagStepPoller.stop()
   revisionWatcher.stop()
   reflectionScheduler.stop()
   threadWatcher.stop()
@@ -358,6 +360,7 @@ async function start() {
 
       // Start Pull-model daemons
       stepPoller.start()
+      dagStepPoller.start()
       revisionWatcher.start()
       threadWatcher.start(runQuickLlmCall)
     } else {