@geekbeer/minion 2.23.0 → 2.32.0

package/win/routes/terminal.js

@@ -0,0 +1,316 @@
+/**
+ * Windows Terminal management endpoints
+ *
+ * Uses node-pty sessions instead of tmux.
+ * Shares activeSessions Map with workflow-runner.js and routine-runner.js.
+ *
+ * Same API surface as routes/terminal.js for HQ compatibility.
+ */
+
+const path = require('path')
+const { verifyToken } = require('../../core/lib/auth')
+const { config } = require('../../core/config')
+const { activeSessions } = require('../workflow-runner')
+
+const homeDir = config.HOME_DIR
+
+/**
+ * Load node-pty dynamically.
+ */
+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 {}
+  return null
+}
+
+/**
+ * Create a new pty session.
+ * @param {string} sessionName - Session name
+ * @param {string} [command] - Optional command to run
+ * @returns {object} Session entry
+ */
+function createPtySession(sessionName, command) {
+  const pty = loadNodePty()
+  if (!pty) throw new Error('node-pty is not installed')
+
+  const shell = process.env.COMSPEC || 'cmd.exe'
+  let shellArgs
+  if (command) {
+    shellArgs = shell.toLowerCase().includes('cmd') ? ['/c', command] : ['-Command', command]
+  } else {
+    shellArgs = []
+  }
+
+  const ptyProcess = pty.spawn(shell, shellArgs, {
+    name: 'xterm-256color',
+    cols: 120,
+    rows: 30,
+    cwd: homeDir,
+    env: { ...process.env, HOME: homeDir, USERPROFILE: homeDir },
+  })
+
+  const session = {
+    pty: ptyProcess,
+    buffer: '',
+    logStream: null,
+    completed: false,
+    exitCode: null,
+    startedAt: new Date().toISOString(),
+  }
+
+  ptyProcess.onData((data) => {
+    session.buffer += data
+    if (session.buffer.length > 1024 * 1024) {
+      session.buffer = session.buffer.slice(-512 * 1024)
+    }
+  })
+
+  ptyProcess.onExit(({ exitCode }) => {
+    session.completed = true
+    session.exitCode = exitCode
+  })
+
+  activeSessions.set(sessionName, session)
+  return session
+}
+
+/**
+ * Register terminal routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function terminalRoutes(fastify) {
+  // List sessions
+  fastify.get('/api/terminal/sessions', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const sessions = []
+    for (const [name, session] of activeSessions) {
+      sessions.push({
+        name,
+        attached: false,
+        completed: session.completed,
+        exit_code: session.exitCode,
+        started_at: session.startedAt,
+      })
+    }
+
+    console.log(`[Terminal] Found ${sessions.length} session(s): ${sessions.map(s => s.name).join(', ') || '(none)'}`)
+    return { success: true, sessions }
+  })
+
+  // Capture pane content
+  fastify.get('/api/terminal/capture', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { session: sessionName, lines = '100' } = request.query || {}
+    if (!sessionName) {
+      reply.code(400)
+      return { success: false, error: 'session parameter is required' }
+    }
+    if (!/^[\w-]+$/.test(sessionName)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid session name' }
+    }
+
+    const session = activeSessions.get(sessionName)
+    if (!session) {
+      reply.code(404)
+      return { success: false, error: `Session '${sessionName}' not found` }
+    }
+
+    const lineCount = Math.min(Math.max(parseInt(lines) || 100, 1), 1000)
+    const allLines = session.buffer.split('\n')
+    const content = allLines.slice(-lineCount).join('\n')
+
+    return {
+      success: true,
+      session: sessionName,
+      content,
+      lines: lineCount,
+      timestamp: Date.now(),
+    }
+  })
+
+  // Send keys to session
+  fastify.post('/api/terminal/send', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { session: sessionName, input, enter = false, special } = request.body || {}
+    if (!sessionName) {
+      reply.code(400)
+      return { success: false, error: 'session is required' }
+    }
+    if (!/^[\w-]+$/.test(sessionName)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid session name' }
+    }
+    if (!input && !special) {
+      reply.code(400)
+      return { success: false, error: 'input or special key is required' }
+    }
+
+    const session = activeSessions.get(sessionName)
+    if (!session || !session.pty) {
+      reply.code(404)
+      return { success: false, error: `Session '${sessionName}' not found` }
+    }
+    if (session.completed) {
+      reply.code(400)
+      return { success: false, error: `Session '${sessionName}' has already exited` }
+    }
+
+    const specialKeyMap = {
+      'Enter': '\r',
+      'Escape': '\x1b',
+      'Tab': '\t',
+      'C-c': '\x03',
+      'C-d': '\x04',
+      'C-z': '\x1a',
+      'Up': '\x1b[A',
+      'Down': '\x1b[B',
+      'Left': '\x1b[D',
+      'Right': '\x1b[C',
+    }
+
+    try {
+      if (special) {
+        const key = specialKeyMap[special]
+        if (!key) {
+          reply.code(400)
+          return { success: false, error: `Invalid special key. Allowed: ${Object.keys(specialKeyMap).join(', ')}` }
+        }
+        session.pty.write(key)
+      } else {
+        session.pty.write(input)
+        if (enter) session.pty.write('\r')
+      }
+
+      console.log(`[Terminal] Sent keys to session '${sessionName}'`)
+      return { success: true, session: sessionName }
+    } catch (error) {
+      console.error(`[Terminal] Failed to send keys: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Create a new session
+  fastify.post('/api/terminal/create', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { name, command } = request.body || {}
+    const sessionName = name || `session-${Date.now()}`
+
+    if (!/^[\w-]+$/.test(sessionName)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid session name' }
+    }
+
+    if (activeSessions.has(sessionName)) {
+      reply.code(409)
+      return { success: false, error: `Session '${sessionName}' already exists` }
+    }
+
+    try {
+      createPtySession(sessionName, command)
+      console.log(`[Terminal] Created session '${sessionName}'`)
+      return { success: true, session: sessionName, message: `Session '${sessionName}' created` }
+    } catch (error) {
+      console.error(`[Terminal] Failed to create session: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Kill a session
+  fastify.post('/api/terminal/kill', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { session: sessionName } = request.body || {}
+    if (!sessionName) {
+      reply.code(400)
+      return { success: false, error: 'session is required' }
+    }
+    if (!/^[\w-]+$/.test(sessionName)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid session name' }
+    }
+
+    const session = activeSessions.get(sessionName)
+    if (!session) {
+      reply.code(404)
+      return { success: false, error: `Session '${sessionName}' not found` }
+    }
+
+    try {
+      if (session.pty && !session.completed) {
+        session.pty.kill()
+      }
+      activeSessions.delete(sessionName)
+      console.log(`[Terminal] Killed session '${sessionName}'`)
+      return { success: true, session: sessionName, message: `Session '${sessionName}' terminated` }
+    } catch (error) {
+      console.error(`[Terminal] Failed to kill session: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // ttyd status endpoint (compatibility — reports node-pty sessions instead)
+  fastify.get('/api/terminal/ttyd/status', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const sessions = []
+    for (const [name, session] of activeSessions) {
+      sessions.push({
+        session: name,
+        port: null, // No per-session port; WebSocket server handles all
+        startedAt: session.startedAt,
+        running: !session.completed,
+      })
+    }
+
+    return {
+      success: true,
+      ttyd_installed: !!loadNodePty(),
+      active_sessions: sessions,
+    }
+  })
+}
+
+function cleanupSessions() {
+  for (const [name, session] of activeSessions) {
+    try {
+      if (session.pty && !session.completed) session.pty.kill()
+      console.log(`[Terminal] Cleanup: killed session '${name}'`)
+    } catch { /* ignore */ }
+  }
+  activeSessions.clear()
+}
+
+module.exports = {
+  terminalRoutes,
+  cleanupSessions,
+  activeSessions,
+  createPtySession,
+}

package/win/routine-runner.js

@@ -0,0 +1,324 @@
+/**
+ * Windows Routine Runner
+ *
+ * Manages cron-based routine execution using node-pty instead of tmux.
+ * Same architecture as win/workflow-runner.js with routine-specific naming.
+ */
+
+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 routineStore = require('../core/stores/routine-store')
+const logManager = require('./lib/log-manager')
+const { MARKER_DIR, buildExtendedPath } = require('../core/lib/platform')
+const { activeSessions } = require('./workflow-runner')
+
+const activeJobs = new Map()
+const runningExecutions = new Map()
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function generateSessionName(routineId, executionId) {
+  const routineShort = routineId ? routineId.substring(0, 8) : 'manual'
+  const execShort = executionId ? executionId.substring(0, 4) : ''
+  return execShort ? `rt-${routineShort}-${execShort}` : `rt-${routineShort}`
+}
+
+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(`[RoutineRunner] Wrote marker file: ${filePath}`)
+  } catch (err) {
+    console.error(`[RoutineRunner] 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(`[RoutineRunner] Cleaned up marker file: ${filePath}`)
+  } catch { /* ignore */ }
+}
+
+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 routine execution. ' +
+    'Install with: npm install node-pty-prebuilt-multiarch'
+  )
+}
+
+async function executeRoutineSession(routine, executionId, skillNames) {
+  const pty = loadNodePty()
+  const homeDir = config.HOME_DIR
+  const sessionName = generateSessionName(routine.id, executionId)
+
+  const skillCommands = skillNames.map(name => `/${name}`).join(', then ')
+  const contextPrefix = routine.context
+    ? `## Context\n\n${routine.context}\n\n---\n\n`
+    : ''
+  const prompt = `${contextPrefix}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(`[RoutineRunner] Executing routine: ${routine.name}`)
+  console.log(`[RoutineRunner] Skills: ${skillNames.join(' -> ')} -> execution-report`)
+  console.log(`[RoutineRunner] Session: ${sessionName}`)
+  console.log(`[RoutineRunner] Log file: ${logFile}`)
+
+  try {
+    await logManager.ensureLogDir()
+    await logManager.pruneOldLogs()
+
+    const existing = activeSessions.get(sessionName)
+    if (existing && existing.pty) {
+      try { existing.pty.kill() } catch { /* ignore */ }
+      activeSessions.delete(sessionName)
+    }
+
+    await writeMarkerFile(sessionName, {
+      execution_id: executionId,
+      routine_id: routine.id,
+      routine_name: routine.name,
+      skill_names: skillNames,
+      started_at: new Date().toISOString(),
+    })
+
+    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)
+
+    const env = {
+      ...process.env,
+      HOME: homeDir,
+      USERPROFILE: homeDir,
+      PATH: extendedPath,
+      MINION_EXECUTION_ID: executionId,
+      MINION_ROUTINE_ID: routine.id,
+      MINION_ROUTINE_NAME: routine.name,
+    }
+
+    const logDir = path.dirname(logFile)
+    await fs.mkdir(logDir, { recursive: true })
+    const logStream = fsSync.createWriteStream(logFile, { flags: 'a' })
+
+    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,
+    })
+
+    const session = {
+      pty: ptyProcess,
+      buffer: '',
+      logStream,
+      completed: false,
+      exitCode: null,
+      startedAt: new Date().toISOString(),
+    }
+    activeSessions.set(sessionName, session)
+
+    console.log(`[RoutineRunner] Started pty session: ${sessionName} (PID: ${ptyProcess.pid})`)
+
+    return await new Promise((resolve) => {
+      const timeout = 60 * 60 * 1000
+      const timer = setTimeout(() => {
+        console.error(`[RoutineRunner] Routine ${routine.name} timed out after 60 minutes`)
+        try { ptyProcess.kill() } catch { /* ignore */ }
+        resolve({ success: false, error: 'Execution timeout (60 minutes)', sessionName })
+      }, timeout)
+
+      ptyProcess.onData((data) => {
+        session.buffer += data
+        if (session.buffer.length > 1024 * 1024) {
+          session.buffer = session.buffer.slice(-512 * 1024)
+        }
+        try { logStream.write(data) } catch { /* ignore */ }
+      })
+
+      ptyProcess.onExit(({ exitCode }) => {
+        clearTimeout(timer)
+        session.completed = true
+        session.exitCode = exitCode
+        try { logStream.end() } catch { /* ignore */ }
+
+        if (exitCode === 0) {
+          console.log(`[RoutineRunner] Routine ${routine.name} completed successfully`)
+          resolve({ success: true, sessionName })
+        } else {
+          console.error(`[RoutineRunner] Routine ${routine.name} failed with exit code: ${exitCode}`)
+          resolve({ success: false, error: `Exit code: ${exitCode}`, sessionName })
+        }
+      })
+    })
+  } catch (error) {
+    console.error(`[RoutineRunner] Routine ${routine.name} failed: ${error.message}`)
+    return { success: false, error: error.message, sessionName }
+  } finally {
+    await cleanupMarkerFile(sessionName)
+  }
+}
+
+async function runRoutine(routine) {
+  const pipelineSkillNames = routine.pipeline_skill_names || []
+  if (pipelineSkillNames.length === 0) {
+    console.log(`[RoutineRunner] Routine "${routine.name}" has empty pipeline, skipping`)
+    return { execution_id: null, session_name: null }
+  }
+
+  const executionId = crypto.randomUUID()
+  const startedAt = new Date().toISOString()
+  const sessionName = generateSessionName(routine.id, executionId)
+
+  console.log(`[RoutineRunner] Starting routine: ${routine.name} (execution: ${executionId})`)
+
+  runningExecutions.set(executionId, {
+    routine_name: routine.name,
+    skill_names: pipelineSkillNames,
+    started_at: startedAt,
+    session_name: sessionName,
+  })
+
+  const logFile = logManager.getLogPath(executionId)
+
+  await executionStore.save({
+    id: executionId,
+    skill_name: pipelineSkillNames.join(' -> '),
+    routine_id: routine.id,
+    routine_name: routine.name,
+    status: 'running',
+    outcome: null,
+    started_at: startedAt,
+    completed_at: null,
+    parent_execution_id: null,
+    error_message: null,
+    log_file: logFile,
+  })
+
+  const result = await executeRoutineSession(routine, executionId, pipelineSkillNames)
+  const completedAt = new Date().toISOString()
+
+  await executionStore.save({
+    id: executionId,
+    skill_name: pipelineSkillNames.join(' -> '),
+    routine_id: routine.id,
+    routine_name: routine.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 routineStore.updateLastRun(routine.id)
+
+  runningExecutions.delete(executionId)
+  console.log(`[RoutineRunner] Completed routine: ${routine.name}`)
+
+  return { execution_id: executionId, session_name: sessionName }
+}
+
+function loadRoutines(routines) {
+  stopAll()
+  let activeCount = 0
+
+  for (const routine of routines) {
+    if (!routine.is_active) {
+      console.log(`[RoutineRunner] Skipping inactive routine: ${routine.name}`)
+      continue
+    }
+    if (!routine.cron_expression) {
+      console.log(`[RoutineRunner] Routine "${routine.name}" has no schedule (manual trigger only)`)
+      activeJobs.set(routine.id, { job: null, routine })
+      continue
+    }
+    try {
+      const job = new Cron(routine.cron_expression, () => {
+        runRoutine(routine).catch(err => {
+          console.error(`[RoutineRunner] Unhandled error in ${routine.name}: ${err.message}`)
+        })
+      })
+      activeJobs.set(routine.id, { job, routine })
+      activeCount++
+      console.log(`[RoutineRunner] Registered: ${routine.name} (${routine.cron_expression})`)
+    } catch (err) {
+      console.error(`[RoutineRunner] Failed to register ${routine.name}: ${err.message}`)
+    }
+  }
+
+  console.log(`[RoutineRunner] Loaded ${routines.length} routines, ${activeCount} with cron schedule`)
+}
+
+function stopAll() {
+  for (const [, { job, routine }] of activeJobs) {
+    if (job) job.stop()
+    console.log(`[RoutineRunner] Stopped: ${routine.name}`)
+  }
+  activeJobs.clear()
+}
+
+function getStatus() {
+  const routines = []
+  for (const [id, { job, routine }] of activeJobs) {
+    routines.push({
+      id,
+      name: routine.name,
+      cron_expression: routine.cron_expression,
+      next_run: job?.nextRun()?.toISOString() || null,
+    })
+  }
+  const running = []
+  for (const [id, info] of runningExecutions) {
+    running.push({
+      execution_id: id,
+      routine_name: info.routine_name,
+      skill_names: info.skill_names,
+      session_name: info.session_name,
+      started_at: info.started_at,
+    })
+  }
+  return {
+    active_routines: activeJobs.size,
+    running_executions: runningExecutions.size,
+    routines,
+    running,
+  }
+}
+
+function getRoutineById(routineId) {
+  const entry = activeJobs.get(routineId)
+  return entry?.routine || null
+}
+
+module.exports = {
+  loadRoutines,
+  stopAll,
+  getStatus,
+  runRoutine,
+  getRoutineById,
+  generateSessionName,
+  MARKER_DIR,
+}