@geekbeer/minion 1.3.3 → 1.4.1

package/minion-cli.sh

@@ -24,6 +24,22 @@ set -euo pipefail
 # Ensure HOME is set (cloud-init may not set it)
 export HOME="${HOME:-$(getent passwd "$(whoami)" | cut -d: -f6)}"
 
+# Detect target user: when running as root (e.g., cloud-init), install user-level
+# tools for the 'ubuntu' user instead of root
+if [ "$(id -u)" -eq 0 ] && getent passwd ubuntu &>/dev/null; then
+  TARGET_USER="ubuntu"
+  TARGET_HOME=$(getent passwd "$TARGET_USER" | cut -d: -f6)
+  RUN_AS="sudo -u $TARGET_USER"
+elif [ "$(id -u)" -eq 0 ]; then
+  TARGET_USER="root"
+  TARGET_HOME="$HOME"
+  RUN_AS=""
+else
+  TARGET_USER="$(whoami)"
+  TARGET_HOME="$HOME"
+  RUN_AS=""
+fi
+
 # Resolve version from package.json (installed location)
 CLI_DIR="$(cd "$(dirname "$(readlink -f "$0")")" && pwd)"
 CLI_VERSION="$(node -p "require('${CLI_DIR}/package.json').version")"
@@ -144,13 +160,14 @@ do_setup() {
 
   # Step 1: Install Claude Code
   echo "[1/${TOTAL_STEPS}] Installing Claude Code..."
-  if command -v claude &>/dev/null; then
-    echo "  -> Claude Code already installed ($(claude --version 2>/dev/null || echo 'unknown version'))"
+  # Install as target user (claude native installer writes to $HOME/.local/bin)
+  # Note: sudo -u resets PATH, so we must set it explicitly in subshells
+  export PATH="${TARGET_HOME}/.local/bin:$HOME/.local/bin:$PATH"
+  if $RUN_AS bash -c 'export PATH="$HOME/.local/bin:$PATH"; command -v claude' &>/dev/null; then
+    echo "  -> Claude Code already installed ($($RUN_AS bash -c 'export PATH="$HOME/.local/bin:$PATH"; claude --version' 2>/dev/null || echo 'unknown version'))"
   else
-    curl -fsSL https://claude.ai/install.sh | bash
-    # Reload PATH to pick up newly installed binary
-    export PATH="$HOME/.local/bin:$PATH"
-    if command -v claude &>/dev/null; then
+    $RUN_AS bash -c 'curl -fsSL https://claude.ai/install.sh | bash'
+    if $RUN_AS bash -c 'export PATH="$HOME/.local/bin:$PATH"; command -v claude' &>/dev/null; then
       echo "  -> Claude Code installed successfully"
     else
       echo "  WARNING: Claude Code installation may have failed"
@@ -321,11 +338,11 @@ SUPEOF
   # Step 8: Deploy bundled skills
   echo "[8/${TOTAL_STEPS}] Deploying bundled skills..."
   local BUNDLED_SKILLS_DIR="${NPM_ROOT}/@geekbeer/minion/skills"
-  local CLAUDE_SKILLS_DIR="$HOME/.claude/skills"
+  local CLAUDE_SKILLS_DIR="${TARGET_HOME}/.claude/skills"
 
   if [ -d "$BUNDLED_SKILLS_DIR" ]; then
     # Create Claude skills directory if it doesn't exist
-    mkdir -p "$CLAUDE_SKILLS_DIR"
+    $RUN_AS mkdir -p "$CLAUDE_SKILLS_DIR"
 
     # Copy each bundled skill
     for skill_dir in "$BUNDLED_SKILLS_DIR"/*/; do
@@ -334,7 +351,7 @@ SUPEOF
         local target_dir="${CLAUDE_SKILLS_DIR}/${skill_name}"
 
         # Copy skill files
-        cp -r "$skill_dir" "$target_dir"
+        $RUN_AS cp -r "$skill_dir" "$target_dir"
         echo "  -> Deployed skill: $skill_name"
       fi
     done

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "server.js",
   "bin": {
@@ -10,6 +10,7 @@
     "server.js",
     "config.js",
     "api.js",
+    "terminal-proxy.js",
     "workflow-runner.js",
     "workflow-store.js",
     "execution-store.js",

package/routes/terminal.js

@@ -34,8 +34,8 @@ const homeDir = os.homedir()
  */
 const ttydProcesses = new Map()
 
-// Base port for ttyd instances (will increment for each session)
-const TTYD_BASE_PORT = 7681
+// Base port for ttyd instances (7681 is reserved for the WebSocket proxy)
+const TTYD_BASE_PORT = 7682
 
 /**
  * Find an available port for ttyd
@@ -63,6 +63,75 @@ async function isTtydInstalled() {
   }
 }
 
+/**
+ * Start ttyd for a tmux session (shared logic used by routes and proxy).
+ * @param {string} session - tmux session name
+ * @returns {Promise<{port: number, alreadyRunning: boolean}>}
+ */
+async function startTtydForSession(session) {
+  // Check if already running
+  const existing = ttydProcesses.get(session)
+  if (existing && !existing.proc.killed) {
+    return { port: existing.port, alreadyRunning: true }
+  }
+
+  // Check if ttyd is installed
+  const installed = await isTtydInstalled()
+  if (!installed) {
+    throw new Error('ttyd is not installed')
+  }
+
+  // Verify tmux session exists
+  try {
+    await execAsync(`tmux has-session -t "${session}"`, {
+      timeout: 5000,
+      env: { ...process.env, HOME: homeDir },
+    })
+  } catch {
+    throw new Error(`tmux session '${session}' not found`)
+  }
+
+  const port = findAvailablePort()
+
+  const proc = spawn('ttyd', [
+    '-p', port.toString(),
+    '-t', 'fontSize=14',
+    '-t', 'theme={"background": "#1a1a2e", "foreground": "#eee"}',
+    'tmux', 'attach', '-t', session,
+  ], {
+    env: { ...process.env, HOME: homeDir },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: false,
+  })
+
+  proc.on('error', (err) => {
+    console.error(`[Terminal] ttyd error for session '${session}': ${err.message}`)
+    ttydProcesses.delete(session)
+  })
+
+  proc.on('exit', (code) => {
+    console.log(`[Terminal] ttyd exited for session '${session}' with code ${code}`)
+    ttydProcesses.delete(session)
+  })
+
+  proc.stderr.on('data', (data) => {
+    console.log(`[Terminal] ttyd[${session}]: ${data.toString().trim()}`)
+  })
+
+  ttydProcesses.set(session, {
+    proc,
+    port,
+    startedAt: new Date().toISOString(),
+  })
+
+  console.log(`[Terminal] Started ttyd for session '${session}' on port ${port}`)
+
+  // Wait for ttyd to start listening
+  await new Promise(resolve => setTimeout(resolve, 500))
+
+  return { port, alreadyRunning: false }
+}
+
 /**
  * Register terminal routes as Fastify plugin
  * @param {import('fastify').FastifyInstance} fastify
@@ -446,103 +515,28 @@ async function terminalRoutes(fastify) {
       return { success: false, error: 'session is required' }
     }
 
-    // Sanitize session name
     if (!/^[\w-]+$/.test(session)) {
       reply.code(400)
       return { success: false, error: 'Invalid session name' }
     }
 
-    // Check if ttyd is installed
-    const installed = await isTtydInstalled()
-    if (!installed) {
-      reply.code(503)
-      return {
-        success: false,
-        error: 'ttyd is not installed. Install with: apt-get install ttyd',
-      }
-    }
-
-    // Check if already running for this session
-    const existing = ttydProcesses.get(session)
-    if (existing && !existing.proc.killed) {
-      return {
-        success: true,
-        session,
-        port: existing.port,
-        message: 'ttyd already running for this session',
-        already_running: true,
-      }
-    }
-
-    // Verify tmux session exists
     try {
-      await execAsync(`tmux has-session -t "${session}"`, {
-        timeout: 5000,
-        env: { ...process.env, HOME: homeDir },
-      })
-    } catch {
-      reply.code(404)
-      return {
-        success: false,
-        error: `tmux session '${session}' not found`,
-      }
-    }
-
-    // Find available port and start ttyd
-    const port = findAvailablePort()
-
-    try {
-      const proc = spawn('ttyd', [
-        '-p', port.toString(),
-        '-W',  // Writable (allow input)
-        '-t', 'fontSize=14',
-        '-t', 'theme={"background": "#1a1a2e", "foreground": "#eee"}',
-        'tmux', 'attach', '-t', session,
-      ], {
-        env: { ...process.env, HOME: homeDir },
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: false,
-      })
-
-      proc.on('error', (err) => {
-        console.error(`[Terminal] ttyd error for session '${session}': ${err.message}`)
-        ttydProcesses.delete(session)
-      })
-
-      proc.on('exit', (code) => {
-        console.log(`[Terminal] ttyd exited for session '${session}' with code ${code}`)
-        ttydProcesses.delete(session)
-      })
-
-      // Log stderr for debugging
-      proc.stderr.on('data', (data) => {
-        console.log(`[Terminal] ttyd[${session}]: ${data.toString().trim()}`)
-      })
-
-      ttydProcesses.set(session, {
-        proc,
-        port,
-        startedAt: new Date().toISOString(),
-      })
-
-      console.log(`[Terminal] Started ttyd for session '${session}' on port ${port}`)
-
-      // Wait a moment for ttyd to start
-      await new Promise(resolve => setTimeout(resolve, 500))
-
+      const result = await startTtydForSession(session)
       return {
         success: true,
         session,
-        port,
-        message: `ttyd started on port ${port}`,
+        port: result.port,
+        message: result.alreadyRunning
+          ? 'ttyd already running for this session'
+          : `ttyd started on port ${result.port}`,
+        already_running: result.alreadyRunning,
       }
     } catch (error) {
-      console.error(`[Terminal] Failed to start ttyd: ${error.message}`)
-      reply.code(500)
-      return {
-        success: false,
-        error: error.message,
-      }
+      const status = error.message.includes('not found') ? 404
+        : error.message.includes('not installed') ? 503
+        : 500
+      reply.code(status)
+      return { success: false, error: error.message }
     }
   })
 
@@ -643,4 +637,6 @@ function cleanupTtyd() {
 module.exports = {
   terminalRoutes,
   cleanupTtyd,
+  ttydProcesses,
+  startTtydForSession,
 }

package/server.js

@@ -19,6 +19,7 @@ const workflowStore = require('./workflow-store')
 const { registerRoutes, setOffline, getProcessManager, getAllowedCommands } = require('./routes')
 const { SUDO } = require('./lib/process-manager')
 const { cleanupTtyd } = require('./routes/terminal')
+const { startTerminalProxy, stopTerminalProxy } = require('./terminal-proxy')
 
 // Validate configuration before starting
 validate()
@@ -36,7 +37,8 @@ async function shutdown(signal) {
   // Stop workflow runner
   workflowRunner.stopAll()
 
-  // Stop all ttyd processes
+  // Stop terminal proxy and all ttyd processes
+  stopTerminalProxy()
   cleanupTtyd()
 
   // Close server
@@ -116,6 +118,14 @@ async function start() {
 
     console.log(`[Server] Minion agent listening on port ${config.AGENT_PORT}`)
 
+    // Start terminal WebSocket proxy on port 7681
+    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()

package/terminal-proxy.js

@@ -0,0 +1,158 @@
+/**
+ * Terminal WebSocket Proxy
+ *
+ * Listens on port 7681 and routes WebSocket connections to the correct
+ * ttyd instance based on the session name in the URL path.
+ *
+ * URL format: /terminal/ws/{sessionName} (via tunnel) or /ws/{sessionName} (dev)
+ *
+ * Each tmux session gets its own ttyd on a unique port (7682+).
+ * If ttyd is not running for a session, it is auto-started on demand.
+ */
+
+const http = require('http')
+const net = require('net')
+const { ttydProcesses, startTtydForSession } = require('./routes/terminal')
+
+const PROXY_PORT = 7681
+
+/**
+ * Parse session name from URL path.
+ * Handles both /terminal/ws/{session} and /ws/{session}.
+ * Falls back to 'main' if no session specified.
+ */
+function parseSessionName(url) {
+  const match = url?.match(/\/ws\/([^/?]+)/)
+  return match ? match[1] : 'main'
+}
+
+/**
+ * Try to connect to a local port with retries.
+ * ttyd may take a moment to start listening after spawn.
+ */
+function connectWithRetry(port, retries, delay) {
+  return new Promise((resolve, reject) => {
+    function attempt(remaining) {
+      const conn = net.connect(port, '127.0.0.1')
+
+      conn.once('connect', () => resolve(conn))
+
+      conn.once('error', (err) => {
+        conn.destroy()
+        if (remaining > 0) {
+          setTimeout(() => attempt(remaining - 1), delay)
+        } else {
+          reject(err)
+        }
+      })
+    }
+
+    attempt(retries)
+  })
+}
+
+/**
+ * Build the HTTP upgrade request to forward to ttyd.
+ * Rewrites the path to /ws (what ttyd expects) and forwards all headers.
+ */
+function buildUpgradeRequest(req) {
+  let lines = [`GET /ws HTTP/${req.httpVersion}`]
+
+  // Forward all headers (ttyd needs Upgrade, Connection, Sec-WebSocket-* headers)
+  for (const [key, value] of Object.entries(req.headers)) {
+    lines.push(`${key}: ${value}`)
+  }
+
+  return lines.join('\r\n') + '\r\n\r\n'
+}
+
+const server = http.createServer((req, res) => {
+  // Only WebSocket upgrade requests are handled
+  res.writeHead(426, { 'Content-Type': 'text/plain' })
+  res.end('WebSocket connections only')
+})
+
+server.on('upgrade', async (req, socket, head) => {
+  const sessionName = parseSessionName(req.url)
+  console.log(`[Terminal Proxy] WebSocket upgrade for session '${sessionName}' (url: ${req.url})`)
+
+  // Validate session name
+  if (!/^[\w-]+$/.test(sessionName)) {
+    console.log(`[Terminal Proxy] Invalid session name: '${sessionName}'`)
+    socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
+    return
+  }
+
+  // Ensure ttyd is running for this session
+  let entry = ttydProcesses.get(sessionName)
+  if (!entry || entry.proc.killed) {
+    try {
+      console.log(`[Terminal Proxy] Auto-starting ttyd for session '${sessionName}'`)
+      await startTtydForSession(sessionName)
+      entry = ttydProcesses.get(sessionName)
+    } catch (err) {
+      console.error(`[Terminal Proxy] Failed to start ttyd for '${sessionName}': ${err.message}`)
+      socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n')
+      return
+    }
+  }
+
+  if (!entry) {
+    console.error(`[Terminal Proxy] No ttyd entry after start for '${sessionName}'`)
+    socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n')
+    return
+  }
+
+  const targetPort = entry.port
+  console.log(`[Terminal Proxy] Routing '${sessionName}' to ttyd on port ${targetPort}`)
+
+  try {
+    // Connect to the local ttyd instance (retry up to 3 times with 300ms delay)
+    const target = await connectWithRetry(targetPort, 3, 300)
+
+    // Forward the upgrade request with path rewritten to /ws
+    const upgradeReq = buildUpgradeRequest(req)
+    target.write(upgradeReq)
+    if (head.length > 0) {
+      target.write(head)
+    }
+
+    // Pipe data bidirectionally (raw TCP after upgrade)
+    socket.pipe(target)
+    target.pipe(socket)
+
+    // Clean up on close/error
+    socket.on('error', () => target.destroy())
+    socket.on('close', () => target.destroy())
+    target.on('error', () => socket.destroy())
+    target.on('close', () => socket.destroy())
+  } catch (err) {
+    console.error(`[Terminal Proxy] Failed to connect to ttyd on port ${targetPort}: ${err.message}`)
+    socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n')
+  }
+})
+
+/**
+ * Start the terminal WebSocket proxy server.
+ */
+function startTerminalProxy() {
+  return new Promise((resolve, reject) => {
+    server.listen(PROXY_PORT, '0.0.0.0', () => {
+      console.log(`[Terminal Proxy] WebSocket proxy listening on port ${PROXY_PORT}`)
+      resolve()
+    })
+    server.on('error', (err) => {
+      console.error(`[Terminal Proxy] Failed to start: ${err.message}`)
+      reject(err)
+    })
+  })
+}
+
+/**
+ * Stop the terminal proxy server.
+ */
+function stopTerminalProxy() {
+  server.close()
+}
+
+module.exports = { startTerminalProxy, stopTerminalProxy }