@geekbeer/minion 2.5.0 → 2.6.0

package/routine-runner.js

@@ -0,0 +1,404 @@
+/**
+ * Routine Runner
+ * Manages cron-based routine execution using croner.
+ * Routines are minion-scoped autonomous tasks (e.g., morning-work, skill-reflection).
+ *
+ * Key design:
+ * - All skills in a routine run in ONE CLI session (context preserved)
+ * - /execution-report is automatically appended to report outcome
+ * - Marker file written before session start for skill-to-execution mapping
+ * - Same tmux execution model as workflow-runner
+ */
+
+const { Cron } = require('croner')
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const crypto = require('crypto')
+const os = require('os')
+const path = require('path')
+const fs = require('fs').promises
+const execAsync = promisify(exec)
+
+const executionStore = require('./execution-store')
+const routineStore = require('./routine-store')
+const logManager = require('./lib/log-manager')
+
+// Active cron jobs keyed by routine ID
+const activeJobs = new Map()
+
+// Currently running executions
+const runningExecutions = new Map()
+
+// Marker file directory (shared with workflow-runner)
+const MARKER_DIR = '/tmp/minion-executions'
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Generate tmux session name from routine ID and execution ID
+ * Format: rt-{routineId first 8}-{executionId first 4}
+ * @param {string} routineId - Routine UUID
+ * @param {string} executionId - Execution UUID (optional)
+ * @returns {string} Safe session name
+ */
+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}`
+}
+
+/**
+ * Write execution marker file for skill to read
+ * @param {string} sessionName - tmux session name
+ * @param {object} data - Execution metadata
+ */
+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}`)
+  }
+}
+
+/**
+ * Clean up marker file after execution
+ * @param {string} sessionName - tmux session name
+ */
+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 if file doesn't exist
+  }
+}
+
+/**
+ * Execute a routine in a single CLI session
+ * All skills run sequentially with context preserved.
+ * @param {object} routine - Routine configuration
+ * @param {string} executionId - Execution UUID
+ * @param {string[]} skillNames - Skills to execute
+ * @returns {Promise<{success: boolean, error?: string, sessionName?: string}>}
+ */
+async function executeRoutineSession(routine, executionId, skillNames) {
+  const homeDir = os.homedir()
+  const sessionName = generateSessionName(routine.id, executionId)
+
+  // Build prompt: run each skill in sequence, then execution-report
+  const skillCommands = skillNames.map(name => `/${name}`).join(', then ')
+  const prompt = `Run the following skills in order: ${skillCommands}. After completing all skills, run /execution-report to report the results.`
+
+  // Extend PATH to include common CLI installation locations
+  const additionalPaths = [
+    path.join(homeDir, 'bin'),
+    path.join(homeDir, '.npm-global', 'bin'),
+    path.join(homeDir, '.local', 'bin'),
+    path.join(homeDir, '.claude', 'bin'),
+    '/usr/local/bin',
+  ]
+  const currentPath = process.env.PATH || ''
+  const extendedPath = [...additionalPaths, currentPath].join(':')
+
+  // Exit code file to capture CLI result
+  const exitCodeFile = `/tmp/tmux-exit-${sessionName}`
+
+  // Set up log file for this execution
+  const logFile = logManager.getLogPath(executionId)
+
+  console.log(`[RoutineRunner] Executing routine: ${routine.name}`)
+  console.log(`[RoutineRunner] Skills: ${skillNames.join(' → ')} → execution-report`)
+  console.log(`[RoutineRunner] tmux session: ${sessionName}`)
+  console.log(`[RoutineRunner] Log file: ${logFile}`)
+
+  try {
+    // Ensure log directory exists and prune old logs
+    await logManager.ensureLogDir()
+    await logManager.pruneOldLogs()
+
+    // Kill existing session if any
+    await execAsync(`tmux kill-session -t "${sessionName}" 2>/dev/null || true`)
+
+    // Remove old exit code file
+    await execAsync(`rm -f "${exitCodeFile}"`)
+
+    // Write marker file BEFORE starting session
+    await writeMarkerFile(sessionName, {
+      execution_id: executionId,
+      routine_id: routine.id,
+      routine_name: routine.name,
+      skill_names: skillNames,
+      started_at: new Date().toISOString(),
+    })
+
+    // Build the command to run in tmux
+    const escapedPrompt = prompt.replace(/'/g, "'\\''")
+    const claudeCommand = `claude -p '${escapedPrompt}'; echo $? > ${exitCodeFile}`
+
+    // Create tmux session with extended environment
+    // Pass execution context as environment variables for /execution-report skill
+    const tmuxCommand = [
+      'tmux new-session -d',
+      `-s "${sessionName}"`,
+      '-x 200 -y 50',
+      `-e "DISPLAY=:99"`,
+      `-e "PATH=${extendedPath}"`,
+      `-e "HOME=${homeDir}"`,
+      `-e "MINION_EXECUTION_ID=${executionId}"`,
+      `-e "MINION_ROUTINE_ID=${routine.id}"`,
+      `-e "MINION_ROUTINE_NAME=${routine.name.replace(/"/g, '\\"')}"`,
+      `"${claudeCommand}"`,
+    ].join(' ')
+
+    await execAsync(tmuxCommand, {
+      cwd: homeDir,
+      env: { ...process.env, HOME: homeDir },
+    })
+
+    // Keep session alive after command completes (for debugging via terminal mirror)
+    await execAsync(`tmux set-option -t "${sessionName}" remain-on-exit on`)
+
+    // Set up pipe-pane to capture terminal output to log file
+    try {
+      await execAsync(`tmux pipe-pane -o -t "${sessionName}" "cat >> ${logFile}"`)
+      console.log(`[RoutineRunner] Enabled pipe-pane logging to: ${logFile}`)
+    } catch (err) {
+      console.error(`[RoutineRunner] Failed to set up pipe-pane: ${err.message}`)
+    }
+
+    console.log(`[RoutineRunner] Started tmux session: ${sessionName}`)
+
+    // Wait for session to complete (poll for exit code file)
+    const timeout = 60 * 60 * 1000 // 60 minutes
+    const pollInterval = 2000 // 2 seconds
+    const startTime = Date.now()
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        await execAsync(`tmux has-session -t "${sessionName}" 2>/dev/null`)
+        await sleep(pollInterval)
+      } catch {
+        // Session ended
+        break
+      }
+    }
+
+    // Check if we timed out
+    if (Date.now() - startTime >= timeout) {
+      console.error(`[RoutineRunner] Routine ${routine.name} timed out after 60 minutes`)
+      await execAsync(`tmux kill-session -t "${sessionName}" 2>/dev/null || true`)
+      return { success: false, error: 'Execution timeout (60 minutes)', sessionName }
+    }
+
+    // Read exit code
+    try {
+      const { stdout } = await execAsync(`cat "${exitCodeFile}"`)
+      const exitCode = parseInt(stdout.trim(), 10)
+      await execAsync(`rm -f "${exitCodeFile}"`)
+
+      if (exitCode === 0) {
+        console.log(`[RoutineRunner] Routine ${routine.name} completed successfully`)
+        return { success: true, sessionName }
+      } else {
+        console.error(`[RoutineRunner] Routine ${routine.name} failed with exit code: ${exitCode}`)
+        return { success: false, error: `Exit code: ${exitCode}`, sessionName }
+      }
+    } catch {
+      console.log(`[RoutineRunner] Routine ${routine.name} completed (exit code unknown)`)
+      return { success: true, sessionName }
+    }
+  } catch (error) {
+    console.error(`[RoutineRunner] Routine ${routine.name} failed: ${error.message}`)
+    return { success: false, error: error.message, sessionName }
+  } finally {
+    await cleanupMarkerFile(sessionName)
+  }
+}
+
+/**
+ * Run a routine: execute all pipeline skills in a single CLI session
+ * @param {object} routine - Routine configuration
+ * @returns {Promise<{execution_id: string, session_name: string}>}
+ */
+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)
+
+  // Save: routine running
+  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,
+  })
+
+  // Execute all skills in one session
+  const result = await executeRoutineSession(routine, executionId, pipelineSkillNames)
+
+  const completedAt = new Date().toISOString()
+
+  // Save: routine completed
+  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,
+  })
+
+  // Update last_run in local store
+  await routineStore.updateLastRun(routine.id)
+
+  runningExecutions.delete(executionId)
+  console.log(`[RoutineRunner] Completed routine: ${routine.name}`)
+
+  return { execution_id: executionId, session_name: sessionName }
+}
+
+/**
+ * Load routines and register cron jobs
+ * @param {Array} routines - Array of routine configurations
+ */
+function loadRoutines(routines) {
+  // Stop all existing jobs first
+  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`)
+}
+
+/**
+ * Stop all active cron jobs
+ */
+function stopAll() {
+  for (const [, { job, routine }] of activeJobs) {
+    if (job) job.stop()
+    console.log(`[RoutineRunner] Stopped: ${routine.name}`)
+  }
+  activeJobs.clear()
+}
+
+/**
+ * Get current routine runner status
+ * @returns {object} Status summary
+ */
+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,
+  }
+}
+
+/**
+ * Get a routine by ID from active jobs
+ * @param {string} routineId - Routine UUID
+ * @returns {object|null} Routine object or null
+ */
+function getRoutineById(routineId) {
+  const entry = activeJobs.get(routineId)
+  return entry?.routine || null
+}
+
+module.exports = {
+  loadRoutines,
+  stopAll,
+  getStatus,
+  runRoutine,
+  getRoutineById,
+  generateSessionName,
+  MARKER_DIR,
+}

package/routine-store.js

@@ -0,0 +1,116 @@
+/**
+ * Routine Store
+ * Persists routine configurations to local JSON file.
+ * Allows minion to continue operating when HQ is offline.
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+// Routine file location: /opt/minion-agent/routines.json (systemd/supervisord)
+// or ~/routines.json (standalone)
+function getRoutineFilePath() {
+  const optPath = '/opt/minion-agent/routines.json'
+  try {
+    require('fs').accessSync(path.dirname(optPath))
+    return optPath
+  } catch {
+    return path.join(os.homedir(), 'routines.json')
+  }
+}
+
+const ROUTINE_FILE = getRoutineFilePath()
+
+/**
+ * Load routines from local file
+ * @returns {Promise<Array>} Array of routine objects
+ */
+async function load() {
+  try {
+    const data = await fs.readFile(ROUTINE_FILE, 'utf-8')
+    return JSON.parse(data)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return []
+    }
+    console.error(`[RoutineStore] Failed to load routines: ${err.message}`)
+    return []
+  }
+}
+
+/**
+ * Save routines to local file
+ * @param {Array} routines - Array of routine objects
+ */
+async function save(routines) {
+  try {
+    await fs.writeFile(ROUTINE_FILE, JSON.stringify(routines, null, 2), 'utf-8')
+    console.log(`[RoutineStore] Saved ${routines.length} routines to ${ROUTINE_FILE}`)
+  } catch (err) {
+    console.error(`[RoutineStore] Failed to save routines: ${err.message}`)
+    throw err
+  }
+}
+
+/**
+ * Update last_run for a specific routine
+ * @param {string} routineId - Routine UUID
+ */
+async function updateLastRun(routineId) {
+  const routines = await load()
+  const routine = routines.find(r => r.id === routineId)
+  if (routine) {
+    routine.last_run = new Date().toISOString()
+    await save(routines)
+  }
+}
+
+/**
+ * Find a routine by name
+ * @param {string} name - Routine name
+ * @returns {Promise<object|null>} Routine object or null
+ */
+async function findByName(name) {
+  const routines = await load()
+  return routines.find(r => r.name === name) || null
+}
+
+/**
+ * Upsert a routine from HQ data.
+ * Upserts by ID (routines come from HQ with UUIDs).
+ * @param {object} routineData - { id, name, pipeline_skill_names, content, is_active, cron_expression, last_run, next_run }
+ * @returns {Promise<Array>} Updated routines array
+ */
+async function upsertFromHQ(routineData) {
+  const routines = await load()
+  const index = routines.findIndex(r => r.id === routineData.id)
+
+  if (index >= 0) {
+    // Update from HQ (preserve local-only fields if any)
+    routines[index] = {
+      ...routines[index],
+      name: routineData.name,
+      pipeline_skill_names: routineData.pipeline_skill_names,
+      content: routineData.content || '',
+      is_active: routineData.is_active,
+      cron_expression: routineData.cron_expression || '',
+    }
+  } else {
+    routines.push({
+      id: routineData.id,
+      name: routineData.name,
+      pipeline_skill_names: routineData.pipeline_skill_names || [],
+      content: routineData.content || '',
+      is_active: routineData.is_active ?? false,
+      cron_expression: routineData.cron_expression || '',
+      last_run: routineData.last_run || null,
+      next_run: routineData.next_run || null,
+    })
+  }
+
+  await save(routines)
+  return routines
+}
+
+module.exports = { load, save, updateLastRun, findByName, upsertFromHQ }