@geekbeer/minion 2.5.0 → 2.6.0

package/minion-cli.sh

@@ -286,11 +286,11 @@ do_setup() {
     case "$PROC_MGR" in
       systemd)
         SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/systemctl restart minion-agent"
-        SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/systemctl restart xvfb fluxbox x11vnc novnc"
+        SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/systemctl restart xvfb fluxbox autocutsel vnc novnc"
         ;;
       supervisord)
         SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/supervisorctl restart minion-agent"
-        SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/supervisorctl restart xvfb fluxbox x11vnc novnc"
+        SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/supervisorctl restart xvfb fluxbox autocutsel vnc novnc"
         SUDOERS_CONTENT+="\n${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/supervisorctl status"
         ;;
     esac
@@ -354,6 +354,135 @@ Environment=MINION_USER=${TARGET_USER}
 WantedBy=multi-user.target
 SVCEOF
       echo "  -> /etc/systemd/system/minion-agent.service created"
+
+      # VNC stack services (only if Xvfb is installed)
+      if command -v Xvfb &>/dev/null; then
+        echo "  Creating VNC stack services..."
+
+        # xvfb: virtual display (-ac disables access control so any user can connect)
+        $SUDO tee /etc/systemd/system/xvfb.service > /dev/null <<XVFBEOF
+[Unit]
+Description=Xvfb virtual framebuffer
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/Xvfb :99 -screen 0 1920x1080x24 -ac
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+XVFBEOF
+        echo "  -> /etc/systemd/system/xvfb.service created"
+
+        # fluxbox: window manager (runs as TARGET_USER so terminals open as that user)
+        $SUDO tee /etc/systemd/system/fluxbox.service > /dev/null <<FBEOF
+[Unit]
+Description=Fluxbox window manager
+After=xvfb.service
+Requires=xvfb.service
+
+[Service]
+Type=simple
+User=${TARGET_USER}
+Environment=DISPLAY=:99
+ExecStart=/usr/bin/fluxbox
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+FBEOF
+        echo "  -> /etc/systemd/system/fluxbox.service created (User=${TARGET_USER})"
+
+        # autocutsel: clipboard sync (runs as TARGET_USER to match desktop session)
+        if command -v autocutsel &>/dev/null; then
+          $SUDO tee /etc/systemd/system/autocutsel.service > /dev/null <<ACEOF
+[Unit]
+Description=X clipboard synchronization
+After=xvfb.service
+Requires=xvfb.service
+
+[Service]
+Type=forking
+User=${TARGET_USER}
+Environment=DISPLAY=:99
+ExecStart=/usr/bin/autocutsel -fork
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+ACEOF
+          echo "  -> /etc/systemd/system/autocutsel.service created (User=${TARGET_USER})"
+        fi
+
+        # vnc: VNC server (detect x0vncserver or x11vnc)
+        if command -v x0vncserver &>/dev/null; then
+          $SUDO tee /etc/systemd/system/vnc.service > /dev/null <<VNCEOF
+[Unit]
+Description=TigerVNC scraping server
+After=fluxbox.service
+Requires=xvfb.service
+
+[Service]
+Type=simple
+Environment=DISPLAY=:99
+ExecStart=/usr/bin/x0vncserver -display :99 -rfbport 5900 -SecurityTypes None -fg
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+VNCEOF
+          echo "  -> /etc/systemd/system/vnc.service created (x0vncserver)"
+        elif command -v x11vnc &>/dev/null; then
+          $SUDO tee /etc/systemd/system/vnc.service > /dev/null <<VNCEOF
+[Unit]
+Description=x11vnc VNC server
+After=fluxbox.service
+Requires=xvfb.service
+
+[Service]
+Type=simple
+Environment=DISPLAY=:99
+ExecStart=/usr/bin/x11vnc -display :99 -rfbport 5900 -nopw -forever -shared
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+VNCEOF
+          echo "  -> /etc/systemd/system/vnc.service created (x11vnc)"
+        else
+          echo "  WARNING: No VNC server found (x0vncserver or x11vnc)"
+        fi
+
+        # novnc: WebSocket proxy for browser access
+        if command -v websockify &>/dev/null; then
+          local NOVNC_WEB="/usr/share/novnc"
+          if [ ! -d "$NOVNC_WEB" ]; then
+            NOVNC_WEB="/usr/share/novnc/utils/../"
+          fi
+          $SUDO tee /etc/systemd/system/novnc.service > /dev/null <<NVNCEOF
+[Unit]
+Description=noVNC WebSocket proxy
+After=vnc.service
+Requires=vnc.service
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/websockify --web=${NOVNC_WEB} 6080 localhost:5900
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+NVNCEOF
+          echo "  -> /etc/systemd/system/novnc.service created"
+        fi
+      fi
       ;;
 
     supervisord)
@@ -394,11 +523,20 @@ SUPEOF
       ;;
   esac
 
-  # Step 7: Enable and start service
-  echo "[7/${TOTAL_STEPS}] Starting minion-agent service..."
+  # Step 7: Enable and start services
+  echo "[7/${TOTAL_STEPS}] Starting services..."
   case "$PROC_MGR" in
     systemd)
       $SUDO systemctl daemon-reload
+      # Enable and start VNC stack (if service files were created)
+      for svc in xvfb fluxbox autocutsel vnc novnc; do
+        if [ -f "/etc/systemd/system/${svc}.service" ]; then
+          $SUDO systemctl enable "$svc"
+          $SUDO systemctl restart "$svc"
+          echo "  -> ${svc} started"
+        fi
+      done
+      # Enable and start agent services
       $SUDO systemctl enable tmux-init
       $SUDO systemctl start tmux-init
       $SUDO systemctl enable minion-agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "server.js",
   "bin": {
@@ -13,6 +13,8 @@
     "terminal-proxy.js",
     "workflow-runner.js",
     "workflow-store.js",
+    "routine-runner.js",
+    "routine-store.js",
     "execution-store.js",
     "lib/",
     "routes/",

package/routes/files.js

@@ -15,6 +15,7 @@ const fs = require('fs').promises
 const fsSync = require('fs')
 const path = require('path')
 const os = require('os')
+const { spawn } = require('child_process')
 
 const { verifyToken } = require('../lib/auth')
 
@@ -124,7 +125,7 @@ async function fileRoutes(fastify) {
     }
   })
 
-  // GET /api/files/* - Download a file
+  // GET /api/files/* - Download a file or directory (with ?format=tar.gz for directories)
   fastify.get('/api/files/*', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
@@ -146,12 +147,6 @@ async function fileRoutes(fastify) {
     try {
       const stat = await fs.lstat(resolved)
 
-      // Don't allow downloading directories
-      if (stat.isDirectory()) {
-        reply.code(400)
-        return { success: false, error: 'Cannot download a directory' }
-      }
-
       // Check symlink safety
       if (stat.isSymbolicLink()) {
         const realPath = await fs.realpath(resolved)
@@ -161,6 +156,25 @@ async function fileRoutes(fastify) {
         }
       }
 
+      // Directory download as tar.gz
+      if (stat.isDirectory()) {
+        const format = request.query.format
+        if (format !== 'tar.gz') {
+          reply.code(400)
+          return { success: false, error: 'Cannot download a directory. Use ?format=tar.gz' }
+        }
+
+        const dirName = path.basename(resolved)
+        const parentDir = path.dirname(resolved)
+
+        reply
+          .type('application/gzip')
+          .header('Content-Disposition', `attachment; filename="${encodeURIComponent(dirName)}.tar.gz"`)
+
+        const tar = spawn('tar', ['-czf', '-', '-C', parentDir, dirName])
+        return reply.send(tar.stdout)
+      }
+
       const filename = path.basename(resolved)
       reply
         .type('application/octet-stream')

package/routes/index.js

@@ -35,6 +35,14 @@
  *   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)
@@ -47,6 +55,7 @@ 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')
 
@@ -59,6 +68,7 @@ async function registerRoutes(fastify) {
   await fastify.register(commandRoutes)
   await fastify.register(skillRoutes)
   await fastify.register(workflowRoutes)
+  await fastify.register(routineRoutes)
   await fastify.register(terminalRoutes)
   await fastify.register(fileRoutes)
 }

package/routes/routines.js

@@ -0,0 +1,260 @@
+/**
+ * Routine management endpoints
+ *
+ * Endpoints:
+ * - GET  /api/routines              - List all routines with status
+ * - POST /api/routines              - Receive routines from HQ (upsert/additive)
+ * - POST /api/routines/sync         - Pull routines from HQ and sync locally
+ * - PUT  /api/routines/:id/schedule - Update a routine schedule (cron_expression, is_active)
+ * - DELETE /api/routines/:id        - Remove a routine
+ * - POST /api/routines/trigger      - Manual trigger for a routine
+ */
+
+const { verifyToken } = require('../lib/auth')
+const routineRunner = require('../routine-runner')
+const routineStore = require('../routine-store')
+const api = require('../api')
+const { isHqConfigured } = require('../config')
+
+/**
+ * Register routine routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function routineRoutes(fastify) {
+  // Receive routines from HQ (upsert: add new, update existing)
+  fastify.post('/api/routines', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { routines: incomingRoutines } = request.body || {}
+
+    if (!Array.isArray(incomingRoutines)) {
+      reply.code(400)
+      return { success: false, error: 'routines array is required' }
+    }
+
+    console.log(`[Routines] Receiving ${incomingRoutines.length} routines from HQ`)
+
+    try {
+      // Load existing routines
+      const existingRoutines = await routineStore.load()
+
+      // Merge: update existing or add new (upsert by id)
+      const routineMap = new Map(existingRoutines.map(r => [r.id, r]))
+      for (const incoming of incomingRoutines) {
+        routineMap.set(incoming.id, incoming)
+      }
+      const mergedRoutines = Array.from(routineMap.values())
+
+      // Save to local store
+      await routineStore.save(mergedRoutines)
+
+      // Reload cron jobs
+      routineRunner.loadRoutines(mergedRoutines)
+
+      const activeCount = mergedRoutines.filter(r => r.is_active).length
+
+      return {
+        success: true,
+        message: `${incomingRoutines.length} routines upserted (total: ${mergedRoutines.length})`,
+        active: activeCount,
+      }
+    } catch (error) {
+      console.error(`[Routines] Failed to load routines: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // List all routines with their current status
+  fastify.get('/api/routines', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const routines = await routineStore.load()
+    const status = routineRunner.getStatus()
+
+    // Merge routine data with runtime status
+    const result = routines.map(r => {
+      const runtimeInfo = status.routines.find(rr => rr.id === r.id)
+      return {
+        ...r,
+        next_run: runtimeInfo?.next_run || null,
+      }
+    })
+
+    return { routines: result }
+  })
+
+  // Pull routines from HQ and sync locally
+  fastify.post('/api/routines/sync', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    if (!isHqConfigured()) {
+      reply.code(400)
+      return { success: false, error: 'HQ not configured' }
+    }
+
+    console.log('[Routines] Syncing routines from HQ')
+
+    try {
+      const result = await api.request('/routines')
+      const hqRoutines = result.routines || []
+
+      console.log(`[Routines] Received ${hqRoutines.length} routines from HQ`)
+
+      // Upsert each routine from HQ
+      let allRoutines = []
+      for (const routine of hqRoutines) {
+        allRoutines = await routineStore.upsertFromHQ(routine)
+      }
+
+      // If no routines from HQ, just load existing
+      if (hqRoutines.length === 0) {
+        allRoutines = await routineStore.load()
+      }
+
+      // Reload cron jobs
+      routineRunner.loadRoutines(allRoutines)
+
+      const activeCount = allRoutines.filter(r => r.is_active).length
+
+      return {
+        success: true,
+        message: `Synced ${hqRoutines.length} routines from HQ (total: ${allRoutines.length})`,
+        active: activeCount,
+      }
+    } catch (error) {
+      console.error(`[Routines] Failed to sync routines: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Update a routine schedule (cron_expression, is_active)
+  fastify.put('/api/routines/:id/schedule', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { id } = request.params
+    const updates = request.body || {}
+
+    console.log(`[Routines] Updating routine schedule: ${id}`)
+
+    try {
+      const routines = await routineStore.load()
+      const index = routines.findIndex(r => r.id === id)
+
+      if (index < 0) {
+        reply.code(404)
+        return { success: false, error: 'Routine not found' }
+      }
+
+      if ('cron_expression' in updates) {
+        routines[index].cron_expression = updates.cron_expression
+      }
+      if ('is_active' in updates) {
+        routines[index].is_active = updates.is_active
+      }
+
+      // Save and reload
+      await routineStore.save(routines)
+      routineRunner.loadRoutines(routines)
+
+      return {
+        success: true,
+        routine: routines[index],
+      }
+    } catch (error) {
+      console.error(`[Routines] Failed to update routine: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Delete a routine
+  fastify.delete('/api/routines/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { id } = request.params
+
+    console.log(`[Routines] Deleting routine: ${id}`)
+
+    try {
+      const routines = await routineStore.load()
+      const index = routines.findIndex(r => r.id === id)
+
+      if (index < 0) {
+        reply.code(404)
+        return { success: false, error: 'Routine not found' }
+      }
+
+      const removed = routines.splice(index, 1)[0]
+
+      // Save and reload
+      await routineStore.save(routines)
+      routineRunner.loadRoutines(routines)
+
+      return {
+        success: true,
+        message: `Routine "${removed.name}" removed`,
+      }
+    } catch (error) {
+      console.error(`[Routines] Failed to delete routine: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Manual trigger: run a routine immediately
+  fastify.post('/api/routines/trigger', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { routine_id } = request.body || {}
+
+    if (!routine_id) {
+      reply.code(400)
+      return { success: false, error: 'routine_id is required' }
+    }
+
+    // Find the routine in local store
+    const routines = await routineStore.load()
+    const routine = routines.find(r => r.id === routine_id)
+
+    if (!routine) {
+      reply.code(404)
+      return { success: false, error: 'Routine not found' }
+    }
+
+    console.log(`[Routines] Manual trigger for: ${routine.name}`)
+
+    // Run asynchronously — respond immediately
+    const executionPromise = routineRunner.runRoutine(routine)
+    executionPromise.catch(err => {
+      console.error(`[Routines] Manual trigger failed for ${routine.name}: ${err.message}`)
+    })
+
+    return {
+      success: true,
+      name: routine.name,
+      message: 'Execution triggered',
+    }
+  })
+}
+
+module.exports = { routineRoutes }

package/routes/workflows.js

@@ -156,12 +156,25 @@ async function workflowRoutes(fastify) {
         }
       }
 
+      // project_id: from request body, or from local store
+      const { project_id } = request.body || {}
+      const effectiveProjectId = project_id || workflow.project_id
+
+      if (!effectiveProjectId) {
+        reply.code(400)
+        return {
+          success: false,
+          error: 'project_id is required. Provide it in the request body or ensure the workflow has a project_id.',
+        }
+      }
+
       const result = await api.request('/workflows', {
         method: 'POST',
         body: JSON.stringify({
           name: workflow.name,
           pipeline_skill_names: pipelineSkillNames,
           content: workflow.content || '',
+          project_id: effectiveProjectId,
         }),
       })
 
@@ -231,6 +244,7 @@ async function workflowRoutes(fastify) {
         name: workflow.name,
         pipeline_skill_names: workflow.pipeline_skill_names,
         content: workflow.content || '',
+        project_id: workflow.project_id || null,
       })
 
       // 4. Reload cron jobs