@geekbeer/minion 2.23.0 → 2.32.0

package/{routes → linux/routes}/terminal.js

@@ -20,8 +20,8 @@ const path = require('path')
 const net = require('net')
 const execAsync = promisify(exec)
 
-const { verifyToken } = require('../lib/auth')
-const { config } = require('../config')
+const { verifyToken } = require('../../core/lib/auth')
+const { config } = require('../../core/config')
 
 // Ensure consistent HOME for tmux socket path
 const homeDir = config.HOME_DIR

package/{routine-runner.js → linux/routine-runner.js}

@@ -18,10 +18,10 @@ const path = require('path')
 const fs = require('fs').promises
 const execAsync = promisify(exec)
 
-const { config } = require('./config')
-const executionStore = require('./execution-store')
-const routineStore = require('./routine-store')
-const logManager = require('./lib/log-manager')
+const { config } = require('../core/config')
+const executionStore = require('../core/stores/execution-store')
+const routineStore = require('../core/stores/routine-store')
+const logManager = require('../core/lib/log-manager')
 
 // Active cron jobs keyed by routine ID
 const activeJobs = new Map()

package/{server.js → linux/server.js}

@@ -1,24 +1,60 @@
 /**
- * Minion Agent HTTP Server
+ * Minion Agent HTTP Server (Linux)
  *
- * Entry point for the minion agent. Registers all routes and manages lifecycle.
- * See routes/index.js for API documentation.
+ * Entry point for the minion agent on Linux.
+ * Registers shared routes (from core/) and Linux-specific routes.
+ *
+ * API Overview:
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Health & Status:      GET/POST /api/health, /api/status
+ * Commands:             GET /api/commands, POST /api/command
+ * Skills:               GET /api/list-skills, POST /api/deploy-skill, etc.
+ * Workflows:            GET/POST/PUT/DELETE /api/workflows, /api/workflows/trigger
+ * Routines:             GET/POST/PUT/DELETE /api/routines, /api/routines/trigger
+ * Terminal:             GET/POST /api/terminal/sessions, /send, /kill, /capture
+ * Files:                GET/POST/DELETE /api/files
+ * Directives:           POST /api/directive
+ * Auth:                 GET /api/auth/status
+ * Chat:                 POST /api/chat, GET /api/chat/session, POST /api/chat/clear
+ * Config:               GET /api/config/backup, GET/PUT /api/config/env
+ * Executions:           GET /api/executions, GET /api/executions/:id, etc.
+ * ─────────────────────────────────────────────────────────────────────────────
  */
 
 const fs = require('fs')
 const path = require('path')
 
 const fastify = require('fastify')({ logger: true })
-const { config, validate, isHqConfigured } = require('./config')
+
+// Package root (one level up from linux/)
+const PACKAGE_ROOT = path.join(__dirname, '..')
+
+// Core shared modules
+const { config, validate, isHqConfigured } = require('../core/config')
+const workflowStore = require('../core/stores/workflow-store')
+const routineStore = require('../core/stores/routine-store')
+
+// Linux-specific modules
 const workflowRunner = require('./workflow-runner')
-const workflowStore = require('./workflow-store')
 const routineRunner = require('./routine-runner')
-const routineStore = require('./routine-store')
-
-const { registerRoutes, setOffline, getProcessManager, getAllowedCommands } = require('./routes')
 const { cleanupTtyd, killStaleTtydProcesses } = require('./routes/terminal')
 const { startTerminalProxy, stopTerminalProxy } = require('./terminal-proxy')
 
+// Shared routes (from core/)
+const { healthRoutes, setOffline } = require('../core/routes/health')
+const { skillRoutes } = require('../core/routes/skills')
+const { workflowRoutes } = require('../core/routes/workflows')
+const { routineRoutes } = require('../core/routes/routines')
+const { authRoutes } = require('../core/routes/auth')
+
+// Linux-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 } = require('./routes/chat')
+const { configRoutes } = require('./routes/config')
+
 // Validate configuration before starting
 validate()
 const PROC_MGR = getProcessManager()
@@ -50,11 +86,9 @@ process.on('SIGINT', () => shutdown('SIGINT'))
 
 /**
  * Sync bundled permissions into ~/.claude/settings.json.
- * Merges package-defined allow/deny into the existing settings without
- * removing user-added entries or non-permission keys (e.g. mcpServers).
  */
 function syncPermissions() {
-  const bundledPath = path.join(__dirname, 'settings', 'permissions.json')
+  const bundledPath = path.join(PACKAGE_ROOT, 'settings', 'permissions.json')
   const settingsDir = path.join(config.HOME_DIR, '.claude')
   const settingsPath = path.join(settingsDir, 'settings.json')
 
@@ -63,13 +97,11 @@ function syncPermissions() {
 
     const bundled = JSON.parse(fs.readFileSync(bundledPath, 'utf-8'))
 
-    // Read existing settings or start fresh
     let settings = {}
     if (fs.existsSync(settingsPath)) {
       settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'))
     }
 
-    // Replace permissions section with bundled values
     settings.permissions = {
       allow: bundled.allow || [],
       deny: bundled.deny || [],
@@ -85,10 +117,9 @@ function syncPermissions() {
 
 /**
  * Sync bundled tmux.conf to ~/.tmux.conf.
- * Enables mouse-driven scrollback (copy-mode) for the WebSocket terminal.
  */
 function syncTmuxConfig() {
-  const bundledPath = path.join(__dirname, 'settings', 'tmux.conf')
+  const bundledPath = path.join(PACKAGE_ROOT, 'settings', 'tmux.conf')
   const destPath = path.join(config.HOME_DIR, '.tmux.conf')
 
   try {
@@ -103,11 +134,9 @@ function syncTmuxConfig() {
 
 /**
  * Sync bundled rules from the package to ~/.claude/rules/.
- * Deploys core.md only. Role context is injected per-execution, not as rules.
- * Removes legacy files (minion.md, role-*.md) if present.
  */
 function syncBundledRules() {
-  const bundledRulesDir = path.join(__dirname, 'rules')
+  const bundledRulesDir = path.join(PACKAGE_ROOT, 'rules')
   const targetRulesDir = path.join(config.HOME_DIR, '.claude', 'rules')
 
   try {
@@ -115,14 +144,12 @@ function syncBundledRules() {
 
     fs.mkdirSync(targetRulesDir, { recursive: true })
 
-    // Always deploy core.md
     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')
     }
 
-    // Remove legacy files if present
     for (const legacy of ['minion.md', 'role-pm.md', 'role-engineer.md']) {
       const legacyPath = path.join(targetRulesDir, legacy)
       if (fs.existsSync(legacyPath)) {
@@ -137,11 +164,9 @@ function syncBundledRules() {
 
 /**
  * Sync bundled role context files to ~/.minion/roles/.
- * These are NOT loaded as Claude Code rules — they are injected
- * into the prompt at execution time based on the minion's role.
  */
 function syncBundledRoles() {
-  const bundledRolesDir = path.join(__dirname, 'roles')
+  const bundledRolesDir = path.join(PACKAGE_ROOT, 'roles')
   const targetRolesDir = path.join(config.HOME_DIR, '.minion', 'roles')
 
   try {
@@ -163,11 +188,9 @@ function syncBundledRoles() {
 
 /**
  * Sync bundled documentation files to ~/.minion/docs/.
- * These are reference documents accessed on-demand by Claude Code,
- * NOT loaded automatically as rules.
  */
 function syncBundledDocs() {
-  const bundledDocsDir = path.join(__dirname, 'docs')
+  const bundledDocsDir = path.join(PACKAGE_ROOT, 'docs')
   const targetDocsDir = path.join(config.HOME_DIR, '.minion', 'docs')
 
   try {
@@ -187,26 +210,38 @@ function syncBundledDocs() {
   }
 }
 
+/**
+ * Register all routes (shared + Linux-specific)
+ */
+async function registerAllRoutes(app) {
+  // Shared routes (from core/) - inject runners via opts
+  await app.register(healthRoutes)
+  await app.register(skillRoutes, { workflowRunner })
+  await app.register(workflowRoutes, { workflowRunner })
+  await app.register(routineRoutes, { routineRunner })
+  await app.register(authRoutes)
+
+  // Linux-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 {
-    // Sync bundled rules to ~/.claude/rules/ (core.md only)
+    // Sync bundled assets
     syncBundledRules()
-
-    // Sync bundled roles to ~/.minion/roles/ (injected per-execution)
     syncBundledRoles()
-
-    // Sync bundled docs to ~/.minion/docs/ (on-demand reference)
     syncBundledDocs()
-
-    // Sync bundled permissions to ~/.claude/settings.json (broad allow + deny-list)
     syncPermissions()
-
-    // Sync tmux.conf for mouse scroll support in WebSocket terminal
     syncTmuxConfig()
 
     // Register all routes
-    await registerRoutes(fastify)
+    await registerAllRoutes(fastify)
 
     // Listen on all interfaces
     await fastify.listen({ port: config.AGENT_PORT, host: '0.0.0.0' })

package/{workflow-runner.js → linux/workflow-runner.js}

@@ -18,10 +18,10 @@ const path = require('path')
 const fs = require('fs').promises
 const execAsync = promisify(exec)
 
-const { config } = require('./config')
-const executionStore = require('./execution-store')
-const workflowStore = require('./workflow-store')
-const logManager = require('./lib/log-manager')
+const { config } = require('../core/config')
+const executionStore = require('../core/stores/execution-store')
+const workflowStore = require('../core/stores/workflow-store')
+const logManager = require('../core/lib/log-manager')
 
 // Active cron jobs keyed by workflow ID
 const activeJobs = new Map()

package/package.json

@@ -1,40 +1,36 @@
 {
   "name": "@geekbeer/minion",
-  "version": "2.23.0",
+  "version": "2.32.0",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
-  "main": "server.js",
+  "main": "linux/server.js",
   "bin": {
-    "minion-cli": "./minion-cli.sh",
-    "hq": "./bin/hq"
+    "minion-cli": "./linux/minion-cli.sh",
+    "hq": "./linux/bin/hq",
+    "minion-cli-win": "./win/bin/minion-cli-win.js",
+    "hq-win": "./win/bin/hq-win.js"
   },
   "files": [
-    "server.js",
-    "config.js",
-    "api.js",
-    "terminal-proxy.js",
-    "workflow-runner.js",
-    "workflow-store.js",
-    "routine-runner.js",
-    "routine-store.js",
-    "execution-store.js",
-    "chat-store.js",
-    "lib/",
-    "routes/",
+    "core/",
+    "linux/",
+    "win/",
     "skills/",
     "rules/",
     "roles/",
     "docs/",
     "settings/",
-    "bin/",
-    "minion-cli.sh",
     ".env.example"
   ],
   "scripts": {
-    "start": "node server.js"
+    "start": "node linux/server.js",
+    "start:win": "node win/server.js"
   },
   "dependencies": {
     "croner": "^9.0.0",
-    "fastify": "^5.2.2"
+    "fastify": "^5.2.2",
+    "ws": "^8.0.0"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/win/bin/hq-win.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// Node.js wrapper to launch hq.ps1 via powershell.exe
+// See minion-cli-win.js for rationale.
+const { spawn } = require('child_process');
+const path = require('path');
+
+const child = spawn('powershell.exe', [
+  '-ExecutionPolicy', 'Bypass',
+  '-NoLogo',
+  '-File', path.join(__dirname, 'hq.ps1'),
+  ...process.argv.slice(2)
+], { stdio: 'inherit' });
+
+child.on('exit', (code) => process.exit(code || 0));
+child.on('error', (err) => {
+  console.error('Failed to start PowerShell:', err.message);
+  process.exit(1);
+});

package/win/bin/hq.ps1

@@ -0,0 +1,108 @@
+#Requires -Version 5.1
+<#
+.SYNOPSIS
+    HQ API helper for minion chat context (Windows version)
+
+.DESCRIPTION
+    Fetches resource details from the HQ server API.
+    Used by Claude CLI during chat to retrieve information about
+    skills, workflows, and projects that the user is viewing on the dashboard.
+
+    Environment variables (inherited from minion server):
+      HQ_URL    - HQ server URL (e.g., https://minion-agent.com)
+      API_TOKEN - Minion API token for authentication
+
+.EXAMPLE
+    .\hq.ps1 fetch skill <name>
+    .\hq.ps1 fetch workflow <name>
+    .\hq.ps1 fetch project <id>
+    .\hq.ps1 fetch project-context <id>
+#>
+
+param(
+    [Parameter(Position = 0)]
+    [string]$Command,
+
+    [Parameter(Position = 1)]
+    [string]$Resource,
+
+    [Parameter(Position = 2)]
+    [string]$Identifier
+)
+
+$ErrorActionPreference = 'Stop'
+
+# Validate required environment variables
+if (-not $env:HQ_URL) {
+    Write-Error "Error: HQ_URL is not set"
+    exit 1
+}
+if (-not $env:API_TOKEN) {
+    Write-Error "Error: API_TOKEN is not set"
+    exit 1
+}
+
+$BaseUrl = "$($env:HQ_URL)/api/minion"
+$Headers = @{ 'Authorization' = "Bearer $($env:API_TOKEN)" }
+
+function Invoke-HqApi {
+    param([string]$Url)
+
+    try {
+        $response = Invoke-RestMethod -Uri $Url -Headers $Headers -Method Get -ErrorAction Stop
+        $response | ConvertTo-Json -Depth 10
+    }
+    catch {
+        $statusCode = $_.Exception.Response.StatusCode.value__
+        Write-Error "Error: HQ API returned HTTP $statusCode"
+        Write-Error $_.ErrorDetails.Message
+        exit 1
+    }
+}
+
+switch ($Command) {
+    'fetch' {
+        if (-not $Resource -or -not $Identifier) {
+            Write-Error "Usage: hq fetch {skill|workflow|project|project-context} <identifier>"
+            exit 1
+        }
+
+        switch ($Resource) {
+            'skill' {
+                Invoke-HqApi "$BaseUrl/skills/$Identifier"
+            }
+            'workflow' {
+                Invoke-HqApi "$BaseUrl/workflows/$Identifier"
+            }
+            'project' {
+                $response = Invoke-RestMethod -Uri "$BaseUrl/me/projects" -Headers $Headers -Method Get
+                $project = $response.projects | Where-Object { $_.id -eq $Identifier }
+                if ($project) {
+                    $project | ConvertTo-Json -Depth 10
+                }
+                else {
+                    Write-Error "Project not found: $Identifier"
+                    exit 1
+                }
+            }
+            'project-context' {
+                Invoke-HqApi "$BaseUrl/me/project/$Identifier/context"
+            }
+            default {
+                Write-Error "Unknown resource: $Resource"
+                Write-Error "Usage: hq fetch {skill|workflow|project|project-context} <identifier>"
+                exit 1
+            }
+        }
+    }
+    default {
+        Write-Host "HQ API helper for minion chat" -ForegroundColor Cyan
+        Write-Host ""
+        Write-Host "Usage:"
+        Write-Host "  hq fetch skill <name>            - Get skill details"
+        Write-Host "  hq fetch workflow <name>          - Get workflow details"
+        Write-Host "  hq fetch project <id>             - Get project info"
+        Write-Host "  hq fetch project-context <id>     - Get project context"
+        exit 1
+    }
+}

package/win/bin/minion-cli-win.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Node.js wrapper to launch minion-cli.ps1 via powershell.exe
+// npm's cmd-shim cannot execute .ps1 files directly from cmd.exe because
+// #Requires is not recognized as a shebang. This wrapper ensures the CLI
+// works from any shell (cmd.exe, PowerShell, Git Bash).
+const { spawn } = require('child_process');
+const path = require('path');
+
+const child = spawn('powershell.exe', [
+  '-ExecutionPolicy', 'Bypass',
+  '-NoLogo',
+  '-File', path.join(__dirname, '..', 'minion-cli.ps1'),
+  ...process.argv.slice(2)
+], { stdio: 'inherit' });
+
+child.on('exit', (code) => process.exit(code || 0));
+child.on('error', (err) => {
+  console.error('Failed to start PowerShell:', err.message);
+  process.exit(1);
+});

package/win/lib/llm-checker.js

@@ -0,0 +1,115 @@
+/**
+ * Windows LLM Service authentication checker
+ *
+ * Same logic as lib/llm-checker.js but with Windows-compatible paths
+ * and PATH separator handling.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const { config } = require('../../core/config')
+const { buildExtendedPath } = require('../../core/lib/platform')
+
+const CACHE_TTL_MS = 60000
+let cachedResult = null
+let cachedAt = 0
+
+function isClaudeAuthenticated() {
+  const candidates = [
+    path.join(config.HOME_DIR, '.claude', '.credentials.json'),
+    path.join(config.HOME_DIR, '.claude', 'credentials.json'),
+  ]
+  for (const p of candidates) {
+    try {
+      if (fs.existsSync(p)) {
+        const content = fs.readFileSync(p, 'utf-8')
+        const parsed = JSON.parse(content)
+        if (parsed && Object.keys(parsed).length > 0) return true
+      }
+    } catch { /* not authenticated */ }
+  }
+
+  try {
+    const claudePath = path.join(config.HOME_DIR, '.local', 'bin', 'claude')
+    const claudeBin = fs.existsSync(claudePath) ? claudePath : 'claude'
+    execSync(`${claudeBin} auth whoami`, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        HOME: config.HOME_DIR,
+        USERPROFILE: config.HOME_DIR,
+        PATH: buildExtendedPath(config.HOME_DIR),
+      },
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isGeminiAuthenticated() {
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) return true
+
+  const possiblePaths = [
+    path.join(config.HOME_DIR, '.config', 'gemini'),
+    path.join(config.HOME_DIR, '.config', 'gcloud', 'application_default_credentials.json'),
+    // Windows-specific locations
+    path.join(config.HOME_DIR, 'AppData', 'Roaming', 'gcloud', 'application_default_credentials.json'),
+  ]
+  for (const p of possiblePaths) {
+    try {
+      if (!fs.existsSync(p)) continue
+      const stat = fs.statSync(p)
+      if (stat.isDirectory()) {
+        if (fs.readdirSync(p).length > 0) return true
+      } else {
+        if (fs.readFileSync(p, 'utf-8').trim().length > 0) return true
+      }
+    } catch { /* ignore */ }
+  }
+  return false
+}
+
+function isCodexAuthenticated() {
+  if (process.env.OPENAI_API_KEY) return true
+  const codexConfig = path.join(config.HOME_DIR, '.codex')
+  try {
+    if (fs.existsSync(codexConfig) && fs.statSync(codexConfig).isDirectory()) {
+      if (fs.readdirSync(codexConfig).length > 0) return true
+    }
+  } catch { /* ignore */ }
+  return false
+}
+
+const SERVICE_DEFINITIONS = [
+  { name: 'claude', display_name: 'Claude Code', check: isClaudeAuthenticated },
+  { name: 'gemini', display_name: 'Gemini CLI', check: isGeminiAuthenticated },
+  { name: 'codex', display_name: 'Codex', check: isCodexAuthenticated },
+]
+
+function isLlmCommandConfigured() {
+  return !!config.LLM_COMMAND
+}
+
+function getLlmServices() {
+  const now = Date.now()
+  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
+    return cachedResult
+  }
+  const services = SERVICE_DEFINITIONS.map(({ name, display_name, check }) => ({
+    name, display_name, authenticated: check(),
+  }))
+  cachedResult = services
+  cachedAt = now
+  return services
+}
+
+function clearLlmCache() {
+  cachedResult = null
+  cachedAt = 0
+}
+
+module.exports = { getLlmServices, clearLlmCache, isLlmCommandConfigured }