@geekbeer/minion 3.43.0 → 3.49.0

package/mac/routes/chat.js

@@ -0,0 +1,7 @@
+/**
+ * macOS chat routes — re-exports the Linux implementation.
+ *
+ * Spawns the configured LLM CLI (Claude Code / Gemini / Codex) for SSE
+ * streaming. spawn() and PATH resolution work identically on macOS.
+ */
+module.exports = require('../../linux/routes/chat')

package/mac/routes/commands.js

@@ -0,0 +1,119 @@
+/**
+ * Command execution endpoints (macOS)
+ *
+ * Endpoints:
+ * - GET  /api/commands      - List available commands
+ * - POST /api/command       - Execute a whitelisted command
+ *
+ * Identical to linux/routes/commands.js apart from the process-manager source —
+ * macOS uses launchd, so we import from mac/lib/ (not linux/lib/).
+ */
+
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const execAsync = promisify(exec)
+
+const { verifyToken } = require('../../core/lib/auth')
+const { detectProcessManager, buildAllowedCommands } = require('../lib/process-manager')
+
+const PROC_MGR = detectProcessManager()
+const ALLOWED_COMMANDS = buildAllowedCommands(PROC_MGR)
+
+/**
+ * Register command routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function commandRoutes(fastify) {
+  fastify.get('/api/commands', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    return {
+      commands: Object.entries(ALLOWED_COMMANDS).map(([name, info]) => ({
+        name,
+        description: info.description,
+      })),
+    }
+  })
+
+  fastify.post('/api/command', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { command } = request.body || {}
+
+    if (!command) {
+      reply.code(400)
+      return { success: false, error: 'command is required' }
+    }
+
+    const allowedCommand = ALLOWED_COMMANDS[command]
+    if (!allowedCommand) {
+      reply.code(403)
+      return {
+        success: false,
+        error: `Command '${command}' is not allowed`,
+        allowed_commands: Object.keys(ALLOWED_COMMANDS),
+      }
+    }
+
+    console.log(`[Command] Executing: ${command}`)
+
+    // Deferred commands kill the current process, so respond first.
+    if (allowedCommand.deferred) {
+      console.log(`[Command] Scheduling deferred command: ${command}`)
+      setTimeout(() => {
+        exec(allowedCommand.command, { timeout: 60000 }, (err) => {
+          if (err) console.error(`[Command] Deferred command failed: ${command} - ${err.message}`)
+          else console.log(`[Command] Deferred command completed: ${command}`)
+        })
+      }, 1000)
+
+      return {
+        success: true,
+        command,
+        output: 'Command scheduled for execution',
+        deferred: true,
+      }
+    }
+
+    try {
+      const { stdout, stderr } = await execAsync(allowedCommand.command, { timeout: 60000 })
+      console.log(`[Command] Success: ${command}`)
+      return {
+        success: true,
+        command,
+        output: stdout,
+        stderr: stderr || undefined,
+      }
+    } catch (error) {
+      console.error(`[Command] Failed: ${command} - ${error.message}`)
+      reply.code(500)
+      return {
+        success: false,
+        command,
+        error: error.message,
+        stdout: error.stdout,
+        stderr: error.stderr,
+      }
+    }
+  })
+}
+
+function getProcessManager() {
+  return PROC_MGR
+}
+
+function getAllowedCommands() {
+  return ALLOWED_COMMANDS
+}
+
+module.exports = {
+  commandRoutes,
+  getProcessManager,
+  getAllowedCommands,
+}

package/mac/routes/config.js

@@ -0,0 +1,8 @@
+/**
+ * macOS config routes — re-exports the Linux implementation.
+ *
+ * Audited 2026-04: linux/routes/config.js has no Linux-specific paths
+ * (no /etc/cloudflared, no systemd). It uses ~/... paths expanded via
+ * process.env.HOME and BSD-compatible tar -czf / -xzf flags.
+ */
+module.exports = require('../../linux/routes/config')

package/mac/routes/directives.js

@@ -0,0 +1,6 @@
+/**
+ * macOS directives routes — re-exports the Linux implementation.
+ *
+ * One-shot skill execution via tmux session (works the same on macOS).
+ */
+module.exports = require('../../linux/routes/directives')

package/mac/routes/files.js

@@ -0,0 +1,6 @@
+/**
+ * macOS files routes — re-exports the Linux implementation.
+ *
+ * Pure filesystem operations under ~/files/ — no platform-specific code paths.
+ */
+module.exports = require('../../linux/routes/files')

package/mac/routes/terminal.js

@@ -0,0 +1,7 @@
+/**
+ * macOS terminal routes — re-exports the Linux implementation.
+ *
+ * Linux's terminal.js manages tmux sessions and ttyd processes; both tools
+ * are POSIX-compatible and work identically on macOS via Homebrew.
+ */
+module.exports = require('../../linux/routes/terminal')

package/mac/routine-runner.js

@@ -0,0 +1,4 @@
+/**
+ * macOS routine runner — re-exports the Linux implementation.
+ */
+module.exports = require('../linux/routine-runner')

package/mac/server.js

@@ -0,0 +1,413 @@
+/**
+ * Minion Agent HTTP Server (macOS)
+ *
+ * Entry point for the minion agent on macOS.
+ * Registers shared routes (from core/) and macOS-specific routes.
+ *
+ * Architecture notes (macOS):
+ * - Runs as a LaunchAgent under the dedicated `minion` user (~/Library/LaunchAgents/).
+ * - DATA_DIR is ~/.minion (resolved by core/lib/platform.js).
+ * - VNC: native macOS Screen Sharing on port 5900 + websockify front on port 6080.
+ * - Terminal: tmux + ttyd (same as Linux), via Homebrew.
+ *
+ * API surface is identical to the Linux build — most routes are re-exports
+ * of the Linux implementation; only commands.js / process-manager.js differ
+ * because launchctl replaces systemd/supervisord.
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+const fastify = require('fastify')({ logger: true })
+
+// Package root (one level up from mac/)
+const PACKAGE_ROOT = path.join(__dirname, '..')
+
+// Core shared modules
+const { config, validate, isHqConfigured } = require('../core/config')
+const { sendHeartbeat } = require('../core/api')
+const { version } = require('../package.json')
+
+const workflowStore = require('../core/stores/workflow-store')
+const routineStore = require('../core/stores/routine-store')
+
+// Heartbeat interval: fixed at 30s (not user-configurable)
+const HEARTBEAT_INTERVAL_MS = 30_000
+let heartbeatTimer = null
+let lastBeatAt = null
+
+// macOS-specific modules (most re-export the Linux implementation)
+const workflowRunner = require('./workflow-runner')
+const routineRunner = require('./routine-runner')
+const boardTaskRunner = require('./board-task-runner')
+const { cleanupTtyd, killStaleTtydProcesses } = require('./routes/terminal')
+const { startTerminalProxy, stopTerminalProxy } = require('./terminal-proxy')
+
+// Config warnings (included in heartbeat)
+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 boardTaskPoller = require('../core/lib/board-task-poller')
+const revisionWatcher = require('../core/lib/revision-watcher')
+const reflectionScheduler = require('../core/lib/reflection-scheduler')
+const threadWatcher = require('../core/lib/thread-watcher')
+const runningTasks = require('../core/lib/running-tasks')
+
+// Shared routes (from core/)
+const { healthRoutes, setOffline } = require('../core/routes/health')
+const { diagnoseRoutes } = require('../core/routes/diagnose')
+const { skillRoutes } = require('../core/routes/skills')
+const { workflowRoutes } = require('../core/routes/workflows')
+const { routineRoutes } = require('../core/routes/routines')
+const { authRoutes } = require('../core/routes/auth')
+const { variableRoutes } = require('../core/routes/variables')
+const { memoryRoutes } = require('../core/routes/memory')
+const { dailyLogRoutes } = require('../core/routes/daily-logs')
+const { sudoersRoutes } = require('../core/routes/sudoers')
+const { permissionRoutes } = require('../core/routes/permissions')
+const { threadRoutes } = require('../core/routes/threads')
+const { todoRoutes } = require('../core/routes/todos')
+const { emailRoutes } = require('../core/routes/emails')
+const { daemonRoutes } = require('../core/routes/daemons')
+const { llmRoutes } = require('../core/routes/llm')
+
+// macOS-specific routes
+const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
+const { terminalRoutes } = require('./routes/terminal')
+const { fileRoutes } = require('./routes/files')
+const { directiveRoutes } = require('./routes/directives')
+const { chatRoutes, runQuickLlmCall } = require('./routes/chat')
+const { configRoutes } = require('./routes/config')
+
+// Validate configuration before starting
+validate()
+const PROC_MGR = getProcessManager()
+const ALLOWED_COMMANDS = getAllowedCommands()
+console.log(`[Config] Process manager: ${PROC_MGR}`)
+console.log(`[Config] Available commands: ${Object.keys(ALLOWED_COMMANDS).join(', ')}`)
+
+// Graceful shutdown
+async function shutdown(signal) {
+  console.log(`[Server] Received ${signal}, shutting down...`)
+
+  setOffline()
+
+  // Stop heartbeat timer
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer)
+    heartbeatTimer = null
+  }
+
+  // Clear running tasks and send offline heartbeat to HQ (best-effort)
+  runningTasks.clear()
+  if (isHqConfigured()) {
+    try {
+      await Promise.race([
+        sendHeartbeat({ status: 'offline', running_tasks: [], version }),
+        new Promise(resolve => setTimeout(resolve, 3000)),
+      ])
+    } catch {
+      // Best-effort — don't block shutdown
+    }
+  }
+
+  // Stop pollers, runners, and scheduler
+  stepPoller.stop()
+  dagStepPoller.stop()
+  boardTaskPoller.stop()
+  revisionWatcher.stop()
+  reflectionScheduler.stop()
+  threadWatcher.stop()
+  workflowRunner.stopAll()
+  routineRunner.stopAll()
+
+  // Stop terminal proxy and all ttyd processes
+  stopTerminalProxy()
+  cleanupTtyd()
+
+  // Close database and server
+  const { closeDb } = require('../core/db')
+  closeDb()
+  await fastify.close()
+  process.exit(0)
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'))
+process.on('SIGINT', () => shutdown('SIGINT'))
+
+/**
+ * Sync bundled permissions into ~/.claude/settings.json.
+ */
+function syncPermissions() {
+  const bundledPath = path.join(PACKAGE_ROOT, 'settings', 'permissions.json')
+  const settingsDir = path.join(config.HOME_DIR, '.claude')
+  const settingsPath = path.join(settingsDir, 'settings.json')
+
+  try {
+    if (!fs.existsSync(bundledPath)) return
+
+    const bundled = JSON.parse(fs.readFileSync(bundledPath, 'utf-8'))
+
+    let settings = {}
+    if (fs.existsSync(settingsPath)) {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
+    }
+
+    settings.permissions = {
+      allow: bundled.allow || [],
+      deny: bundled.deny || [],
+    }
+
+    fs.mkdirSync(settingsDir, { recursive: true })
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+    console.log(`[Permissions] Synced: allow=${bundled.allow.length}, deny=${bundled.deny.length}`)
+  } catch (err) {
+    console.error(`[Permissions] Failed to sync permissions: ${err.message}`)
+  }
+}
+
+/**
+ * Sync bundled tmux.conf to ~/.tmux.conf.
+ */
+function syncTmuxConfig() {
+  const bundledPath = path.join(PACKAGE_ROOT, 'settings', 'tmux.conf')
+  const destPath = path.join(config.HOME_DIR, '.tmux.conf')
+
+  try {
+    if (!fs.existsSync(bundledPath)) return
+
+    fs.copyFileSync(bundledPath, destPath)
+    console.log('[Tmux] Synced tmux.conf')
+  } catch (err) {
+    console.error(`[Tmux] Failed to sync tmux.conf: ${err.message}`)
+  }
+}
+
+/**
+ * Sync bundled rules from the package to ~/.claude/rules/.
+ */
+function syncBundledRules() {
+  const bundledRulesDir = path.join(PACKAGE_ROOT, 'rules')
+  const targetRulesDir = path.join(config.HOME_DIR, '.claude', 'rules')
+
+  try {
+    if (!fs.existsSync(bundledRulesDir)) return
+
+    fs.mkdirSync(targetRulesDir, { recursive: true })
+
+    const coreSrc = path.join(bundledRulesDir, 'core.md')
+    if (fs.existsSync(coreSrc)) {
+      fs.copyFileSync(coreSrc, path.join(targetRulesDir, 'core.md'))
+      console.log('[Rules] Synced: core.md')
+    }
+
+    for (const legacy of ['minion.md', 'role-pm.md', 'role-engineer.md']) {
+      const legacyPath = path.join(targetRulesDir, legacy)
+      if (fs.existsSync(legacyPath)) {
+        fs.unlinkSync(legacyPath)
+        console.log(`[Rules] Removed legacy: ${legacy}`)
+      }
+    }
+  } catch (err) {
+    console.error(`[Rules] Failed to sync bundled rules: ${err.message}`)
+  }
+}
+
+/**
+ * Sync bundled role context files to ~/.minion/roles/.
+ */
+function syncBundledRoles() {
+  const bundledRolesDir = path.join(PACKAGE_ROOT, 'roles')
+  const targetRolesDir = path.join(config.HOME_DIR, '.minion', 'roles')
+
+  try {
+    if (!fs.existsSync(bundledRolesDir)) return
+
+    fs.mkdirSync(targetRolesDir, { recursive: true })
+
+    for (const file of fs.readdirSync(bundledRolesDir)) {
+      if (!file.endsWith('.md')) continue
+      const src = path.join(bundledRolesDir, file)
+      const dest = path.join(targetRolesDir, file)
+      fs.copyFileSync(src, dest)
+      console.log(`[Roles] Synced: ${file}`)
+    }
+  } catch (err) {
+    console.error(`[Roles] Failed to sync bundled roles: ${err.message}`)
+  }
+}
+
+/**
+ * Sync bundled documentation files to ~/.minion/docs/.
+ */
+function syncBundledDocs() {
+  const bundledDocsDir = path.join(PACKAGE_ROOT, 'docs')
+  const targetDocsDir = path.join(config.HOME_DIR, '.minion', 'docs')
+
+  try {
+    if (!fs.existsSync(bundledDocsDir)) return
+
+    fs.mkdirSync(targetDocsDir, { recursive: true })
+
+    for (const file of fs.readdirSync(bundledDocsDir)) {
+      if (!file.endsWith('.md')) continue
+      const src = path.join(bundledDocsDir, file)
+      const dest = path.join(targetDocsDir, file)
+      fs.copyFileSync(src, dest)
+      console.log(`[Docs] Synced: ${file}`)
+    }
+  } catch (err) {
+    console.error(`[Docs] Failed to sync bundled docs: ${err.message}`)
+  }
+}
+
+/**
+ * Register all routes (shared + macOS-specific)
+ */
+async function registerAllRoutes(app) {
+  // Shared routes (from core/) - inject runners via opts
+  await app.register(healthRoutes)
+  await app.register(diagnoseRoutes)
+  await app.register(skillRoutes, { workflowRunner })
+  await app.register(workflowRoutes, { workflowRunner })
+  await app.register(routineRoutes, { routineRunner })
+  await app.register(authRoutes)
+  await app.register(variableRoutes)
+  await app.register(memoryRoutes)
+  await app.register(dailyLogRoutes)
+  await app.register(sudoersRoutes)
+  await app.register(permissionRoutes)
+  await app.register(threadRoutes)
+  await app.register(todoRoutes)
+  await app.register(emailRoutes)
+  await app.register(daemonRoutes, { heartbeatStatus: () => ({ running: !!heartbeatTimer, last_beat_at: lastBeatAt }) })
+  await app.register(llmRoutes)
+
+  // macOS-specific routes
+  await app.register(commandRoutes)
+  await app.register(terminalRoutes)
+  await app.register(fileRoutes)
+  await app.register(directiveRoutes)
+  await app.register(chatRoutes)
+  await app.register(configRoutes)
+}
+
+// Start server
+async function start() {
+  try {
+    // Extend process.env so all child processes (tmux, spawn) inherit correct environment.
+    // This eliminates the need for per-invocation PATH building in runners/chat.
+    const { buildExtendedPath } = require('../core/lib/platform')
+    process.env.PATH = buildExtendedPath(config.HOME_DIR)
+    process.env.HOME = config.HOME_DIR
+    // No DISPLAY env var on macOS — native Screen Sharing uses WindowServer,
+    // not X11. Setting DISPLAY=:99 (Linux pattern) would break GUI child processes.
+
+    // Load minion secrets into process.env for child process inheritance.
+    // Variables are NOT loaded here — they use {{VAR}} template expansion in skill content.
+    const variableStore = require('../core/stores/variable-store')
+    const minionEnv = variableStore.buildEnv()
+    for (const [key, value] of Object.entries(minionEnv)) {
+      if (!(key in process.env)) process.env[key] = value
+    }
+    console.log(`[Server] Loaded ${Object.keys(minionEnv).length} minion secrets into process.env`)
+
+    // Sync bundled assets
+    syncBundledRules()
+    syncBundledRoles()
+    syncBundledDocs()
+    syncPermissions()
+    syncTmuxConfig()
+
+    // Register all routes
+    await registerAllRoutes(fastify)
+
+    // Listen on all interfaces
+    await fastify.listen({ port: config.AGENT_PORT, host: '0.0.0.0' })
+
+    console.log(`[Server] Minion agent listening on port ${config.AGENT_PORT}`)
+
+    // Kill any stale ttyd processes from a previous run, then start terminal proxy
+    await killStaleTtydProcesses()
+    try {
+      await startTerminalProxy()
+    } catch (err) {
+      console.error(`[Server] Terminal proxy failed to start: ${err.message}`)
+      console.error('[Server] Terminal WebSocket connections will not work')
+    }
+
+    // Load cached workflows and start workflow runner
+    try {
+      const cachedWorkflows = await workflowStore.load()
+      if (cachedWorkflows.length > 0) {
+        console.log(`[Server] Loading ${cachedWorkflows.length} cached workflows`)
+        workflowRunner.loadWorkflows(cachedWorkflows)
+      }
+    } catch (err) {
+      console.error('[Server] Failed to load cached workflows:', err.message)
+    }
+
+    // Load cached routines and start routine runner
+    try {
+      const cachedRoutines = await routineStore.load()
+      if (cachedRoutines.length > 0) {
+        console.log(`[Server] Loading ${cachedRoutines.length} cached routines`)
+        routineRunner.loadRoutines(cachedRoutines)
+      }
+    } catch (err) {
+      console.error('[Server] Failed to load cached routines:', err.message)
+    }
+
+    // Start reflection scheduler (self-reflection time)
+    reflectionScheduler.start(runQuickLlmCall)
+
+    if (isHqConfigured()) {
+      console.log(`[Server] HQ URL: ${config.HQ_URL}`)
+
+      // Send initial online heartbeat
+      const { getStatus } = require('../core/routes/health')
+      const { currentTask } = getStatus()
+      const todoStore = require('../core/stores/todo-store')
+      const getTodoSummary = () => { try { return todoStore.getSummary() } catch { return null } }
+      const workspaceStore = require('../core/stores/workspace-store')
+      const syncWorkspaces = (response) => {
+        if (response && Array.isArray(response.workspaces)) {
+          workspaceStore.upsertAll(response.workspaces)
+        }
+      }
+
+      sendHeartbeat({ status: 'online', current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), version }).then(syncWorkspaces).catch(err => {
+        console.error('[Heartbeat] Initial heartbeat failed:', err.message)
+      })
+
+      // Start periodic heartbeat
+      heartbeatTimer = setInterval(() => {
+        const { currentStatus, currentTask } = getStatus()
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), version }).then(response => {
+          lastBeatAt = new Date().toISOString()
+          syncWorkspaces(response)
+        }).catch(err => {
+          console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
+        })
+      }, HEARTBEAT_INTERVAL_MS)
+      console.log(`[Heartbeat] Sending every ${HEARTBEAT_INTERVAL_MS / 1000}s`)
+
+      // Start Pull-model daemons
+      stepPoller.start()
+      dagStepPoller.start()
+      boardTaskPoller.setRunner(boardTaskRunner)
+      boardTaskPoller.start()
+      revisionWatcher.start()
+      threadWatcher.start(runQuickLlmCall)
+    } else {
+      console.log('[Server] Running in standalone mode (no HQ connection)')
+    }
+  } catch (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+}
+
+start()

package/mac/terminal-proxy.js

@@ -0,0 +1,6 @@
+/**
+ * macOS terminal proxy — re-exports the Linux implementation.
+ *
+ * Pure Node.js http/net code; no platform-specific dependencies.
+ */
+module.exports = require('../linux/terminal-proxy')