@geekbeer/minion 2.23.0 → 2.32.0

package/win/workflow-runner.js

@@ -0,0 +1,380 @@
+/**
+ * Windows Workflow Runner
+ *
+ * Manages cron-based workflow execution using node-pty instead of tmux.
+ * Drop-in replacement for workflow-runner.js on Windows.
+ *
+ * Key differences from Linux version:
+ * - Uses node-pty to spawn CLI sessions (replaces tmux)
+ * - Exit codes captured via onExit callback (no file polling)
+ * - Output logged via onData handler (replaces tmux pipe-pane)
+ * - Sessions tracked in-memory via activeSessions Map
+ */
+
+const { Cron } = require('croner')
+const crypto = require('crypto')
+const path = require('path')
+const fs = require('fs').promises
+const fsSync = require('fs')
+
+const { config } = require('../core/config')
+const executionStore = require('../core/stores/execution-store')
+const workflowStore = require('../core/stores/workflow-store')
+const logManager = require('./lib/log-manager')
+const { MARKER_DIR, buildExtendedPath } = require('../core/lib/platform')
+
+// Active cron jobs keyed by workflow ID
+const activeJobs = new Map()
+
+// Currently running executions
+const runningExecutions = new Map()
+
+/**
+ * Active pty sessions keyed by session name.
+ * Shared with terminal-routes.js for session listing/capture.
+ * @type {Map<string, {pty: object, buffer: string, logStream: object|null, completed: boolean, exitCode: number|null}>}
+ */
+const activeSessions = new Map()
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function generateSessionName(workflowId, executionId) {
+  const workflowShort = workflowId ? workflowId.substring(0, 8) : 'manual'
+  const execShort = executionId ? executionId.substring(0, 4) : ''
+  return execShort ? `wf-${workflowShort}-${execShort}` : `wf-${workflowShort}`
+}
+
+async function writeMarkerFile(sessionName, data) {
+  try {
+    await fs.mkdir(MARKER_DIR, { recursive: true })
+    const filePath = path.join(MARKER_DIR, `${sessionName}.json`)
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+    console.log(`[WorkflowRunner] Wrote marker file: ${filePath}`)
+  } catch (err) {
+    console.error(`[WorkflowRunner] Failed to write marker file: ${err.message}`)
+  }
+}
+
+async function cleanupMarkerFile(sessionName) {
+  try {
+    const filePath = path.join(MARKER_DIR, `${sessionName}.json`)
+    await fs.unlink(filePath)
+    console.log(`[WorkflowRunner] Cleaned up marker file: ${filePath}`)
+  } catch { /* ignore */ }
+}
+
+/**
+ * Load node-pty dynamically (it's an optionalDependency).
+ * @returns {object} The node-pty module
+ */
+function loadNodePty() {
+  // Prefer prebuilt binaries (no Build Tools required)
+  try { return require('node-pty-prebuilt-multiarch') } catch {}
+  // Fallback: source-compiled version
+  try { return require('node-pty') } catch {}
+  throw new Error(
+    'node-pty is required for Windows workflow execution. ' +
+    'Install with: npm install node-pty-prebuilt-multiarch'
+  )
+}
+
+/**
+ * Execute a workflow in a single node-pty session.
+ * All skills run sequentially with context preserved.
+ */
+async function executeWorkflowSession(workflow, executionId, skillNames, options = {}) {
+  const pty = loadNodePty()
+  const homeDir = config.HOME_DIR
+  const sessionName = generateSessionName(workflow.id, executionId)
+
+  // Build prompt
+  const skillCommands = skillNames.map(name => `/${name}`).join(', then ')
+
+  const rolePrefix = options.role
+    ? `You are acting as the "${options.role}" role in this session. Read ~/.minion/roles/${options.role}.md for your role guidelines before proceeding.\n\n`
+    : ''
+
+  const revisionContext = options.revisionFeedback
+    ? `## Revision Feedback\nThe reviewer requested changes to your previous output. Address the following feedback:\n${options.revisionFeedback}\n\n`
+    : ''
+
+  const prompt = options.skipExecutionReport
+    ? `${rolePrefix}${revisionContext}Run the following skills in order: ${skillCommands}.`
+    : `${rolePrefix}${revisionContext}Run the following skills in order: ${skillCommands}. After completing all skills, run /execution-report to report the results.`
+
+  const extendedPath = buildExtendedPath(homeDir)
+  const logFile = logManager.getLogPath(executionId)
+
+  console.log(`[WorkflowRunner] Executing workflow: ${workflow.name}`)
+  console.log(`[WorkflowRunner] Skills: ${skillNames.join(' -> ')} -> execution-report`)
+  console.log(`[WorkflowRunner] Session: ${sessionName}`)
+  console.log(`[WorkflowRunner] Log file: ${logFile}`)
+  console.log(`[WorkflowRunner] HOME: ${homeDir}`)
+
+  try {
+    await logManager.ensureLogDir()
+    await logManager.pruneOldLogs()
+
+    // Kill existing session if any
+    const existing = activeSessions.get(sessionName)
+    if (existing && existing.pty) {
+      try { existing.pty.kill() } catch { /* ignore */ }
+      activeSessions.delete(sessionName)
+    }
+
+    // Write marker file BEFORE starting session
+    await writeMarkerFile(sessionName, {
+      execution_id: executionId,
+      workflow_id: workflow.id,
+      workflow_name: workflow.name,
+      skill_names: skillNames,
+      started_at: new Date().toISOString(),
+    })
+
+    // Build the LLM command
+    if (!config.LLM_COMMAND) {
+      throw new Error('LLM_COMMAND is not configured. Set LLM_COMMAND in minion.env')
+    }
+    const escapedPrompt = prompt.replace(/'/g, "''")
+    const llmCommand = config.LLM_COMMAND.replace(/\{prompt\}/g, escapedPrompt)
+
+    // Build environment
+    const env = {
+      ...process.env,
+      HOME: homeDir,
+      USERPROFILE: homeDir,
+      PATH: extendedPath,
+      MINION_EXECUTION_ID: executionId,
+      MINION_WORKFLOW_ID: workflow.id,
+      MINION_WORKFLOW_NAME: workflow.name,
+    }
+
+    // Open log file for streaming writes
+    const logDir = path.dirname(logFile)
+    await fs.mkdir(logDir, { recursive: true })
+    const logStream = fsSync.createWriteStream(logFile, { flags: 'a' })
+
+    // Spawn pty process
+    const shell = process.env.COMSPEC || 'cmd.exe'
+    const shellArgs = shell.toLowerCase().includes('cmd') ? ['/c', llmCommand] : ['-Command', llmCommand]
+
+    const ptyProcess = pty.spawn(shell, shellArgs, {
+      name: 'xterm-256color',
+      cols: 200,
+      rows: 50,
+      cwd: homeDir,
+      env,
+    })
+
+    // Track session
+    let outputBuffer = ''
+    const session = {
+      pty: ptyProcess,
+      buffer: '',
+      logStream,
+      completed: false,
+      exitCode: null,
+      startedAt: new Date().toISOString(),
+    }
+    activeSessions.set(sessionName, session)
+
+    console.log(`[WorkflowRunner] Started pty session: ${sessionName} (PID: ${ptyProcess.pid})`)
+
+    // Wait for completion
+    return await new Promise((resolve) => {
+      const timeout = 60 * 60 * 1000 // 60 minutes
+      const timer = setTimeout(() => {
+        console.error(`[WorkflowRunner] Workflow ${workflow.name} timed out after 60 minutes`)
+        try { ptyProcess.kill() } catch { /* ignore */ }
+        resolve({ success: false, error: 'Execution timeout (60 minutes)', sessionName })
+      }, timeout)
+
+      ptyProcess.onData((data) => {
+        outputBuffer += data
+        session.buffer += data
+        // Cap buffer at 1MB to prevent memory issues
+        if (session.buffer.length > 1024 * 1024) {
+          session.buffer = session.buffer.slice(-512 * 1024)
+        }
+        // Write to log file
+        try { logStream.write(data) } catch { /* ignore */ }
+      })
+
+      ptyProcess.onExit(({ exitCode }) => {
+        clearTimeout(timer)
+        session.completed = true
+        session.exitCode = exitCode
+
+        // Close log stream
+        try { logStream.end() } catch { /* ignore */ }
+
+        if (exitCode === 0) {
+          console.log(`[WorkflowRunner] Workflow ${workflow.name} completed successfully`)
+          resolve({ success: true, sessionName })
+        } else {
+          console.error(`[WorkflowRunner] Workflow ${workflow.name} failed with exit code: ${exitCode}`)
+          resolve({ success: false, error: `Exit code: ${exitCode}`, sessionName })
+        }
+      })
+    })
+  } catch (error) {
+    console.error(`[WorkflowRunner] Workflow ${workflow.name} failed: ${error.message}`)
+    return { success: false, error: error.message, sessionName }
+  } finally {
+    await cleanupMarkerFile(sessionName)
+  }
+}
+
+async function saveExecution(executionData) {
+  try {
+    await executionStore.save(executionData)
+  } catch (err) {
+    console.error(`[WorkflowRunner] Failed to save execution: ${err.message}`)
+  }
+}
+
+async function runWorkflow(workflow, options = {}) {
+  const pipelineSkillNames = workflow.pipeline_skill_names || []
+  if (pipelineSkillNames.length === 0) {
+    console.log(`[WorkflowRunner] Workflow "${workflow.name}" has empty pipeline, skipping`)
+    return { execution_id: null, session_name: null }
+  }
+
+  const executionId = options.executionId || crypto.randomUUID()
+  const startedAt = new Date().toISOString()
+  const sessionName = generateSessionName(workflow.id, executionId)
+
+  console.log(`[WorkflowRunner] Starting workflow: ${workflow.name} (execution: ${executionId})`)
+
+  runningExecutions.set(executionId, {
+    workflow_name: workflow.name,
+    skill_names: pipelineSkillNames,
+    started_at: startedAt,
+    session_name: sessionName,
+  })
+
+  const logFile = logManager.getLogPath(executionId)
+
+  await saveExecution({
+    id: executionId,
+    skill_name: pipelineSkillNames.join(' -> '),
+    workflow_id: workflow.id,
+    workflow_name: workflow.name,
+    status: 'running',
+    outcome: null,
+    started_at: startedAt,
+    completed_at: null,
+    parent_execution_id: null,
+    error_message: null,
+    log_file: logFile,
+  })
+
+  const result = await executeWorkflowSession(workflow, executionId, pipelineSkillNames, options)
+  const completedAt = new Date().toISOString()
+
+  await saveExecution({
+    id: executionId,
+    skill_name: pipelineSkillNames.join(' -> '),
+    workflow_id: workflow.id,
+    workflow_name: workflow.name,
+    status: result.success ? 'completed' : 'failed',
+    outcome: result.success ? null : 'failure',
+    started_at: startedAt,
+    completed_at: completedAt,
+    parent_execution_id: null,
+    error_message: result.error || null,
+    log_file: logFile,
+  })
+
+  await workflowStore.updateLastRun(workflow.id)
+
+  runningExecutions.delete(executionId)
+  console.log(`[WorkflowRunner] Completed workflow: ${workflow.name}`)
+
+  return { execution_id: executionId, session_name: sessionName }
+}
+
+function loadWorkflows(workflows) {
+  stopAll()
+  let activeCount = 0
+
+  for (const workflow of workflows) {
+    if (!workflow.is_active) {
+      console.log(`[WorkflowRunner] Skipping inactive workflow: ${workflow.name}`)
+      continue
+    }
+    if (!workflow.cron_expression) {
+      console.log(`[WorkflowRunner] Workflow "${workflow.name}" has no schedule (manual trigger only)`)
+      activeJobs.set(workflow.id, { job: null, workflow })
+      continue
+    }
+    try {
+      const job = new Cron(workflow.cron_expression, () => {
+        runWorkflow(workflow).catch(err => {
+          console.error(`[WorkflowRunner] Unhandled error in ${workflow.name}: ${err.message}`)
+        })
+      })
+      activeJobs.set(workflow.id, { job, workflow })
+      activeCount++
+      console.log(`[WorkflowRunner] Registered: ${workflow.name} (${workflow.cron_expression})`)
+    } catch (err) {
+      console.error(`[WorkflowRunner] Failed to register ${workflow.name}: ${err.message}`)
+    }
+  }
+
+  console.log(`[WorkflowRunner] Loaded ${workflows.length} workflows, ${activeCount} with cron schedule`)
+}
+
+function stopAll() {
+  for (const [, { job, workflow }] of activeJobs) {
+    if (job) job.stop()
+    console.log(`[WorkflowRunner] Stopped: ${workflow.name}`)
+  }
+  activeJobs.clear()
+}
+
+function getStatus() {
+  const workflows = []
+  for (const [id, { job, workflow }] of activeJobs) {
+    workflows.push({
+      id,
+      name: workflow.name,
+      cron_expression: workflow.cron_expression,
+      next_run: job?.nextRun()?.toISOString() || null,
+    })
+  }
+  const running = []
+  for (const [id, info] of runningExecutions) {
+    running.push({
+      execution_id: id,
+      workflow_name: info.workflow_name,
+      skill_names: info.skill_names,
+      session_name: info.session_name,
+      started_at: info.started_at,
+    })
+  }
+  return {
+    active_workflows: activeJobs.size,
+    running_executions: runningExecutions.size,
+    workflows,
+    running,
+  }
+}
+
+function getWorkflowById(workflowId) {
+  const entry = activeJobs.get(workflowId)
+  return entry?.workflow || null
+}
+
+module.exports = {
+  loadWorkflows,
+  stopAll,
+  getStatus,
+  runWorkflow,
+  getWorkflowById,
+  generateSessionName,
+  activeSessions,
+  MARKER_DIR,
+}

package/routes/index.js

@@ -1,106 +0,0 @@
-/**
- * Route aggregator for minion agent
- *
- * Registers all route plugins with Fastify.
- *
- * API Overview:
- * ─────────────────────────────────────────────────────────────────────────────
- * Health & Status (routes/health.js)
- *   GET  /api/health              - Health check (no auth)
- *   GET  /api/status              - Get current status (no auth)
- *   POST /api/status              - Update status (no auth)
- *
- * Commands (routes/commands.js)
- *   GET  /api/commands            - List available commands (auth required)
- *   POST /api/command             - Execute a whitelisted command (auth required)
- *
- * Skills (routes/skills.js)
- *   GET  /api/list-skills         - List deployed skills (auth required)
- *   POST /api/deploy-skill        - Deploy a skill (auth required)
- *
- * Workflows (routes/workflows.js)
- *   GET    /api/workflows           - List all workflows with status (auth required)
- *   POST   /api/workflows           - Receive workflows from HQ (auth required)
- *   PUT    /api/workflows/:id       - Update workflow schedule/status (auth required)
- *   DELETE /api/workflows/:id       - Remove a workflow (auth required)
- *   POST   /api/workflows/trigger   - Manual trigger for a workflow (auth required)
- *   GET    /api/executions          - List execution history (auth required)
- *   GET    /api/executions/:id      - Get single execution details (auth required)
- *   GET    /api/executions/:id/log  - Get execution log file content (auth required)
- *   POST   /api/executions/:id/outcome - Update execution outcome (no auth, local only)
- *
- * Terminal (routes/terminal.js)
- *   GET  /api/terminal/sessions     - List tmux sessions (auth required)
- *   GET  /api/terminal/capture      - Capture pane content (auth required)
- *   POST /api/terminal/send         - Send keys to session (auth required)
- *   POST /api/terminal/kill         - Kill a session (auth required)
- *
- * Routines (routes/routines.js)
- *   GET    /api/routines              - List all routines with status (auth required)
- *   POST   /api/routines              - Receive routines from HQ (auth required)
- *   POST   /api/routines/sync         - Pull routines from HQ (auth required)
- *   PUT    /api/routines/:id/schedule - Update routine schedule (auth required)
- *   DELETE /api/routines/:id          - Remove a routine (auth required)
- *   POST   /api/routines/trigger      - Manual trigger for a routine (auth required)
- *
- * Files (routes/files.js)
- *   GET    /api/files               - List files in directory (auth required)
- *   GET    /api/files/*             - Download a file (auth required)
- *   POST   /api/files/*             - Upload a file (auth required)
- *   DELETE /api/files/*             - Delete a file (auth required)
- *
- * Directives (routes/directives.js)
- *   POST /api/directive             - Receive and execute a temp skill directive (auth required)
- *
- * Auth (routes/auth.js)
- *   GET  /api/auth/status           - Get LLM authentication status (auth required)
- *
- * Chat (routes/chat.js)
- *   POST   /api/chat                  - Send message, get SSE stream (auth required)
- *   GET    /api/chat/session           - Get active session (auth required)
- *   POST   /api/chat/clear             - Clear session (auth required)
- *
- * Config (routes/config.js)
- *   GET  /api/config/backup           - Download config files as tar.gz (auth required)
- *   GET  /api/config/env/:key         - Get environment variable value (auth required)
- *   PUT  /api/config/env              - Update an environment variable (auth required, whitelisted keys only)
- * ─────────────────────────────────────────────────────────────────────────────
- */
-
-const { healthRoutes, setOffline } = require('./health')
-const { commandRoutes, getProcessManager, getAllowedCommands } = require('./commands')
-const { skillRoutes } = require('./skills')
-const { workflowRoutes } = require('./workflows')
-const { routineRoutes } = require('./routines')
-const { terminalRoutes } = require('./terminal')
-const { fileRoutes } = require('./files')
-const { directiveRoutes } = require('./directives')
-const { authRoutes } = require('./auth')
-const { chatRoutes } = require('./chat')
-const { configRoutes } = require('./config')
-
-/**
- * Register all routes with Fastify instance
- * @param {import('fastify').FastifyInstance} fastify
- */
-async function registerRoutes(fastify) {
-  await fastify.register(healthRoutes)
-  await fastify.register(commandRoutes)
-  await fastify.register(skillRoutes)
-  await fastify.register(workflowRoutes)
-  await fastify.register(routineRoutes)
-  await fastify.register(terminalRoutes)
-  await fastify.register(fileRoutes)
-  await fastify.register(directiveRoutes)
-  await fastify.register(authRoutes)
-  await fastify.register(chatRoutes)
-  await fastify.register(configRoutes)
-}
-
-module.exports = {
-  registerRoutes,
-  // Re-export utilities used by server.js
-  setOffline,
-  getProcessManager,
-  getAllowedCommands,
-}