@geekbeer/minion 1.0.5 → 1.3.1

package/README.md

@@ -37,59 +37,6 @@ minion-cli health     # Run health check
 minion-cli log -m "Task completed" -l info -s skill-name
 ```
 
-## npm公開手順
-
-### 初回セットアップ
-
-1. npmにログイン:
-   ```bash
-   npm login
-   ```
-
-2. `geekbeer` organizationがnpmに存在することを確認（なければ作成）:
-   ```bash
-   npm org create geekbeer
-   ```
-   または https://www.npmjs.com/org/create から作成。
-
-### パッケージ公開
-
-```bash
-cd packages/minion
-
-# 含まれるファイルを事前確認
-npm pack --dry-run
-
-# 公開
-npm publish --access public
-```
-
-`publishConfig.access: "public"` が `package.json` に設定済みのため、`--access public` は省略可能。
-
-### バージョンアップ & 再公開
-
-```bash
-cd packages/minion
-
-# バージョンを上げる（patch: 1.0.0 → 1.0.1）
-npm version patch
-
-# または minor: 1.0.0 → 1.1.0
-npm version minor
-
-# または major: 1.0.0 → 2.0.0
-npm version major
-
-# 公開
-npm publish
-```
-
-### 公開確認
-
-```bash
-npm view @geekbeer/minion
-```
-
 ## Environment Variables
 
 | Variable | Description | Default |

package/api.js

@@ -38,23 +38,17 @@ async function request(endpoint, options = {}) {
 }
 
 /**
- * Send a log entry
- * @param {string} message - Log message
- * @param {'info'|'warning'|'error'} level - Log level
- * @param {object|null} metadata - Additional metadata
+ * Report skill execution status to HQ
+ * @param {object} data - Execution record data
  */
-async function log(message, level = 'info', metadata = null) {
-  return request('/log', {
+async function reportExecution(data) {
+  return request('/execution', {
     method: 'POST',
-    body: JSON.stringify({
-      message,
-      level,
-      metadata,
-    }),
+    body: JSON.stringify(data),
   })
 }
 
 module.exports = {
   request,
-  log,
+  reportExecution,
 }

package/execution-store.js

@@ -0,0 +1,127 @@
+/**
+ * Execution Store
+ * Persists skill execution history to local JSON file.
+ * Single source of truth for execution records.
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+// Max executions to keep (older ones are pruned)
+const MAX_EXECUTIONS = 200
+
+/**
+ * Get execution file path
+ * Uses /opt/minion-agent/ if available, otherwise home dir
+ */
+function getExecutionFilePath() {
+  const optPath = '/opt/minion-agent/executions.json'
+  try {
+    require('fs').accessSync(path.dirname(optPath))
+    return optPath
+  } catch {
+    return path.join(os.homedir(), 'executions.json')
+  }
+}
+
+const EXECUTION_FILE = getExecutionFilePath()
+
+/**
+ * Load executions from local file
+ * @returns {Promise<Array>} Array of execution objects
+ */
+async function load() {
+  try {
+    const data = await fs.readFile(EXECUTION_FILE, 'utf-8')
+    return JSON.parse(data)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return []
+    }
+    console.error(`[ExecutionStore] Failed to load executions: ${err.message}`)
+    return []
+  }
+}
+
+/**
+ * Save executions to local file
+ * @param {Array} executions - Array of execution objects
+ */
+async function saveAll(executions) {
+  try {
+    await fs.writeFile(EXECUTION_FILE, JSON.stringify(executions, null, 2), 'utf-8')
+  } catch (err) {
+    console.error(`[ExecutionStore] Failed to save executions: ${err.message}`)
+    throw err
+  }
+}
+
+/**
+ * Save a single execution record
+ * Upserts by ID, prunes old records if over limit
+ * @param {object} execution - Execution record
+ */
+async function save(execution) {
+  console.log(`[ExecutionStore] save() called: id=${execution.id}, skill=${execution.skill_name}, status=${execution.status}`)
+
+  const executions = await load()
+  console.log(`[ExecutionStore] Loaded ${executions.length} existing executions`)
+
+  // Find existing by ID and update, or add new
+  const existingIndex = executions.findIndex(e => e.id === execution.id)
+  if (existingIndex >= 0) {
+    const oldStatus = executions[existingIndex].status
+    executions[existingIndex] = { ...executions[existingIndex], ...execution }
+    console.log(`[ExecutionStore] Updated existing record at index ${existingIndex}: ${oldStatus} → ${execution.status}`)
+  } else {
+    executions.unshift(execution) // Add to beginning (newest first)
+    console.log(`[ExecutionStore] Added new record (now ${executions.length} total)`)
+  }
+
+  // Prune old executions
+  const pruned = executions.slice(0, MAX_EXECUTIONS)
+
+  await saveAll(pruned)
+  console.log(`[ExecutionStore] ✓ Saved to file: ${execution.id} (${execution.skill_name} → ${execution.status})`)
+}
+
+/**
+ * List executions with optional limit
+ * @param {number} limit - Max number of executions to return
+ * @returns {Promise<Array>} Array of execution objects (newest first)
+ */
+async function list(limit = 50) {
+  const executions = await load()
+  return executions.slice(0, limit)
+}
+
+/**
+ * Get executions for a specific workflow
+ * @param {string} workflowId - Workflow UUID
+ * @param {number} limit - Max number to return
+ * @returns {Promise<Array>} Array of execution objects
+ */
+async function getByWorkflow(workflowId, limit = 20) {
+  const executions = await load()
+  return executions
+    .filter(e => e.workflow_id === workflowId)
+    .slice(0, limit)
+}
+
+/**
+ * Get a single execution by ID
+ * @param {string} id - Execution UUID
+ * @returns {Promise<object|null>} Execution object or null
+ */
+async function getById(id) {
+  const executions = await load()
+  return executions.find(e => e.id === id) || null
+}
+
+module.exports = {
+  save,
+  list,
+  getByWorkflow,
+  getById,
+}

package/lib/auth.js

@@ -0,0 +1,21 @@
+/**
+ * Authentication utilities for minion agent
+ */
+
+const { config } = require('../config')
+
+/**
+ * Verify API token from Authorization header
+ * @param {import('fastify').FastifyRequest} request
+ * @returns {boolean}
+ */
+function verifyToken(request) {
+  const authHeader = request.headers.authorization
+  if (!authHeader?.startsWith('Bearer ')) {
+    return false
+  }
+  const token = authHeader.substring(7)
+  return token === config.API_TOKEN
+}
+
+module.exports = { verifyToken }

package/lib/log-manager.js

@@ -0,0 +1,183 @@
+/**
+ * Log Manager
+ * Manages workflow execution log files.
+ * Logs are stored as text files and automatically pruned when exceeding MAX_LOG_FILES.
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+// Log storage configuration
+const LOG_DIR = '/opt/minion-agent/logs'
+const MAX_LOG_FILES = 100
+
+/**
+ * Ensure log directory exists
+ */
+async function ensureLogDir() {
+  try {
+    await fs.mkdir(LOG_DIR, { recursive: true })
+  } catch (err) {
+    console.error(`[LogManager] Failed to create log directory: ${err.message}`)
+    throw err
+  }
+}
+
+/**
+ * Get log file path for an execution
+ * @param {string} executionId - Execution UUID
+ * @returns {string} Full path to log file
+ */
+function getLogPath(executionId) {
+  return path.join(LOG_DIR, `${executionId}.log`)
+}
+
+/**
+ * Check if log file exists
+ * @param {string} executionId - Execution UUID
+ * @returns {Promise<boolean>}
+ */
+async function logExists(executionId) {
+  try {
+    await fs.access(getLogPath(executionId))
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Read log file content
+ * @param {string} executionId - Execution UUID
+ * @param {object} options - Read options
+ * @param {number} options.tail - Return only last N lines
+ * @returns {Promise<{content: string, lines: number, size: number}>}
+ */
+async function readLog(executionId, options = {}) {
+  const logPath = getLogPath(executionId)
+
+  try {
+    const stats = await fs.stat(logPath)
+    const content = await fs.readFile(logPath, 'utf-8')
+    const allLines = content.split('\n')
+
+    let resultContent = content
+    if (options.tail && options.tail > 0) {
+      resultContent = allLines.slice(-options.tail).join('\n')
+    }
+
+    return {
+      content: resultContent,
+      lines: allLines.length,
+      size: stats.size,
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null // File not found
+    }
+    throw err
+  }
+}
+
+/**
+ * Prune old log files when exceeding MAX_LOG_FILES
+ * Deletes oldest files first (by mtime)
+ */
+async function pruneOldLogs() {
+  try {
+    // Ensure directory exists before reading
+    try {
+      await fs.access(LOG_DIR)
+    } catch {
+      // Directory doesn't exist yet, nothing to prune
+      return
+    }
+
+    const files = await fs.readdir(LOG_DIR)
+    const logFiles = files.filter(f => f.endsWith('.log'))
+
+    if (logFiles.length <= MAX_LOG_FILES) {
+      return // No pruning needed
+    }
+
+    console.log(`[LogManager] Pruning logs: ${logFiles.length} files (max: ${MAX_LOG_FILES})`)
+
+    // Get file stats for sorting
+    const fileStats = await Promise.all(
+      logFiles.map(async f => {
+        const filePath = path.join(LOG_DIR, f)
+        try {
+          const stats = await fs.stat(filePath)
+          return { name: f, mtime: stats.mtime }
+        } catch {
+          // File may have been deleted, skip it
+          return null
+        }
+      })
+    )
+
+    // Filter out null entries and sort by mtime (oldest first)
+    const validFiles = fileStats.filter(f => f !== null)
+    validFiles.sort((a, b) => a.mtime - b.mtime)
+
+    // Delete oldest files
+    const toDelete = validFiles.slice(0, validFiles.length - MAX_LOG_FILES)
+    for (const file of toDelete) {
+      try {
+        await fs.unlink(path.join(LOG_DIR, file.name))
+        console.log(`[LogManager] Deleted old log: ${file.name}`)
+      } catch (err) {
+        console.error(`[LogManager] Failed to delete ${file.name}: ${err.message}`)
+      }
+    }
+
+    console.log(`[LogManager] Pruned ${toDelete.length} old log files`)
+  } catch (err) {
+    console.error(`[LogManager] Failed to prune logs: ${err.message}`)
+  }
+}
+
+/**
+ * Get log file statistics
+ * @returns {Promise<{count: number, totalSize: number}>}
+ */
+async function getLogStats() {
+  try {
+    try {
+      await fs.access(LOG_DIR)
+    } catch {
+      return { count: 0, totalSize: 0 }
+    }
+
+    const files = await fs.readdir(LOG_DIR)
+    const logFiles = files.filter(f => f.endsWith('.log'))
+
+    let totalSize = 0
+    for (const f of logFiles) {
+      try {
+        const stats = await fs.stat(path.join(LOG_DIR, f))
+        totalSize += stats.size
+      } catch {
+        // Skip files that can't be stat'd
+      }
+    }
+
+    return {
+      count: logFiles.length,
+      totalSize,
+    }
+  } catch {
+    return { count: 0, totalSize: 0 }
+  }
+}
+
+module.exports = {
+  LOG_DIR,
+  MAX_LOG_FILES,
+  ensureLogDir,
+  getLogPath,
+  logExists,
+  readLog,
+  pruneOldLogs,
+  getLogStats,
+}

package/lib/process-manager.js

@@ -0,0 +1,103 @@
+/**
+ * Process manager detection and command building
+ */
+
+const { execSync } = require('child_process')
+
+// Use sudo only when not running as root
+const SUDO = process.getuid && process.getuid() !== 0 ? 'sudo ' : ''
+
+/**
+ * Detect process manager (matching minion-cli.sh logic)
+ * Checks if systemd is actually running as PID 1, not just if command exists
+ * @returns {'systemd' | 'supervisord' | 'standalone'}
+ */
+function detectProcessManager() {
+  const fs = require('fs')
+
+  // Check if systemd is actually running (not just installed)
+  // /run/systemd/system exists only when systemd is the init system
+  if (fs.existsSync('/run/systemd/system')) {
+    try {
+      execSync('systemctl --version', { stdio: 'ignore' })
+      return 'systemd'
+    } catch {
+      // systemctl not working
+    }
+  }
+
+  try {
+    execSync('which supervisorctl', { stdio: 'ignore' })
+    return 'supervisord'
+  } catch {
+    // supervisord not available
+  }
+  return 'standalone'
+}
+
+/**
+ * Build allowed commands based on detected process manager
+ * @param {string} procMgr - Process manager type
+ * @returns {Record<string, { description: string; command: string; deferred?: boolean }>}
+ */
+function buildAllowedCommands(procMgr) {
+  const commands = {}
+
+  if (procMgr === 'systemd') {
+    commands['restart-agent'] = {
+      description: 'Restart the minion agent service',
+      command: `${SUDO}systemctl restart minion-agent`,
+      deferred: true,
+    }
+    commands['update-agent'] = {
+      description: 'Update @geekbeer/minion to latest version and restart',
+      command: `npm update -g @geekbeer/minion && ${SUDO}systemctl restart minion-agent`,
+      deferred: true,
+    }
+    commands['restart-display'] = {
+      description: 'Restart Xvfb, Fluxbox, x11vnc and noVNC services',
+      command: `${SUDO}systemctl restart xvfb fluxbox x11vnc novnc`,
+    }
+    commands['status-services'] = {
+      description: 'Check status of all services',
+      command: 'systemctl status minion-agent xvfb fluxbox x11vnc novnc --no-pager',
+    }
+  } else if (procMgr === 'supervisord') {
+    commands['restart-agent'] = {
+      description: 'Restart the minion agent service',
+      command: `${SUDO}supervisorctl restart minion-agent`,
+      deferred: true,
+    }
+    commands['update-agent'] = {
+      description: 'Update @geekbeer/minion to latest version and restart',
+      command: `npm update -g @geekbeer/minion && ${SUDO}supervisorctl restart minion-agent`,
+      deferred: true,
+    }
+    commands['restart-display'] = {
+      description: 'Restart Xvfb, x11vnc and noVNC services',
+      command: `${SUDO}supervisorctl restart xvfb fluxbox x11vnc novnc`,
+    }
+    commands['status-services'] = {
+      description: 'Check status of all services',
+      command: `${SUDO}supervisorctl status`,
+    }
+  } else {
+    // Standalone mode: limited commands
+    commands['update-agent'] = {
+      description: 'Update @geekbeer/minion to latest version',
+      command: 'npm update -g @geekbeer/minion',
+    }
+    commands['status-services'] = {
+      description: 'Show agent process info',
+      command: 'echo "Process Manager: standalone (no systemd/supervisord)" && echo "Agent PID: $$" && echo "Node version: $(node -v)" && echo "Uptime: $(ps -o etime= -p $$)"',
+    }
+  }
+
+  return commands
+}
+
+module.exports = {
+  SUDO,
+  detectProcessManager,
+  buildAllowedCommands,
+}