@geekbeer/minion 2.25.0 → 2.33.4

package/win/routes/directives.js

@@ -0,0 +1,136 @@
+/**
+ * Windows Directive endpoints
+ *
+ * Same as routes/directives.js but uses win/workflow-runner.
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const crypto = require('crypto')
+
+const { verifyToken } = require('../../core/lib/auth')
+const { config } = require('../../core/config')
+const { writeSkillToLocal } = require('../../core/routes/skills')
+const workflowRunner = require('../workflow-runner')
+const executionStore = require('../../core/stores/execution-store')
+const logManager = require('../../core/lib/log-manager')
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  if (!match) return { metadata: {}, body: content }
+  const metadata = {}
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':')
+    if (key && rest.length) {
+      metadata[key.trim()] = rest.join(':').trim()
+    }
+  }
+  return { metadata, body: match[2].trimStart() }
+}
+
+async function directiveRoutes(fastify) {
+  fastify.post('/api/directive', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { skill_name, skill_content, execution_id, context } = request.body || {}
+
+    if (!skill_name || !skill_content) {
+      reply.code(400)
+      return { success: false, error: 'skill_name and skill_content are required' }
+    }
+
+    if (!skill_name.startsWith('__')) {
+      reply.code(400)
+      return { success: false, error: 'Directive skill names must start with __' }
+    }
+
+    const effectiveExecutionId = execution_id || crypto.randomUUID()
+    const sessionName = `dir-${effectiveExecutionId.substring(0, 8)}-${effectiveExecutionId.substring(8, 12)}`
+
+    console.log(`[Directive] Received directive: ${skill_name} (execution: ${effectiveExecutionId})`)
+
+    try {
+      const homeDir = config.HOME_DIR
+      const skillDir = path.join(homeDir, '.claude', 'skills', skill_name)
+      await fs.mkdir(skillDir, { recursive: true })
+      await fs.writeFile(path.join(skillDir, 'SKILL.md'), skill_content, 'utf-8')
+      console.log(`[Directive] Temp skill written: ${skillDir}`)
+    } catch (err) {
+      console.error(`[Directive] Failed to write temp skill: ${err.message}`)
+      reply.code(500)
+      return { success: false, error: `Failed to write temp skill: ${err.message}` }
+    }
+
+    const startedAt = new Date().toISOString()
+    const logFile = logManager.getLogPath(effectiveExecutionId)
+    const workflowName = context?.workflow_name || skill_name
+
+    await executionStore.save({
+      id: effectiveExecutionId,
+      skill_name,
+      workflow_id: null,
+      workflow_name: workflowName,
+      status: 'running',
+      outcome: null,
+      started_at: startedAt,
+      completed_at: null,
+      parent_execution_id: null,
+      error_message: null,
+      log_file: logFile,
+    })
+
+    const executionPromise = (async () => {
+      const homeDir = config.HOME_DIR
+      const skillDir = path.join(homeDir, '.claude', 'skills', skill_name)
+
+      try {
+        const result = await workflowRunner.runWorkflow({
+          id: effectiveExecutionId,
+          name: workflowName,
+          pipeline_skill_names: [skill_name],
+        }, { skipExecutionReport: true })
+
+        console.log(`[Directive] Execution completed: ${skill_name} (success: ${result.execution_id ? 'yes' : 'no'})`)
+      } catch (err) {
+        console.error(`[Directive] Execution failed: ${err.message}`)
+        await executionStore.save({
+          id: effectiveExecutionId,
+          skill_name,
+          workflow_id: null,
+          workflow_name: workflowName,
+          status: 'failed',
+          outcome: 'failure',
+          started_at: startedAt,
+          completed_at: new Date().toISOString(),
+          parent_execution_id: null,
+          error_message: err.message,
+          log_file: logFile,
+        })
+      } finally {
+        try {
+          await fs.rm(skillDir, { recursive: true, force: true })
+          console.log(`[Directive] Temp skill cleaned up: ${skillDir}`)
+        } catch (cleanupErr) {
+          console.error(`[Directive] Failed to cleanup temp skill: ${cleanupErr.message}`)
+        }
+      }
+    })()
+
+    executionPromise.catch(err => {
+      console.error(`[Directive] Unhandled error: ${err.message}`)
+    })
+
+    reply.code(202)
+    return {
+      success: true,
+      session_name: sessionName,
+      execution_id: effectiveExecutionId,
+      message: 'Directive accepted',
+    }
+  })
+}
+
+module.exports = { directiveRoutes }

package/win/routes/files.js

@@ -0,0 +1,283 @@
+/**
+ * Windows File management endpoints
+ *
+ * Same as routes/files.js but uses Node.js archiver for directory downloads
+ * instead of tar command. Single-file operations are identical.
+ */
+
+const fs = require('fs').promises
+const fsSync = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+
+const { verifyToken } = require('../../core/lib/auth')
+const { config } = require('../../core/config')
+
+const FILES_DIR = path.join(config.HOME_DIR, 'files')
+const MAX_UPLOAD_SIZE = 50 * 1024 * 1024
+
+function safePath(basedir, userPath) {
+  const decoded = decodeURIComponent(userPath)
+  if (decoded.includes('\0')) return null
+  const resolved = path.resolve(basedir, decoded)
+  if (resolved === basedir) return resolved
+  if (!resolved.startsWith(basedir + path.sep)) return null
+  return resolved
+}
+
+/**
+ * Create a gzip-compressed tar-like stream from a directory using pure Node.js.
+ * Returns a JSON manifest of files (same format as config-routes backup).
+ */
+function createDirArchive(dirPath) {
+  const files = []
+  const baseName = path.basename(dirPath)
+
+  function collect(dir, prefix) {
+    const entries = fsSync.readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+      const relativePath = path.join(prefix, entry.name)
+      if (entry.isDirectory()) {
+        collect(fullPath, relativePath)
+      } else {
+        try {
+          const content = fsSync.readFileSync(fullPath)
+          files.push({ path: relativePath, content: content.toString('base64'), encoding: 'base64' })
+        } catch { /* skip unreadable */ }
+      }
+    }
+  }
+
+  collect(dirPath, baseName)
+  const json = JSON.stringify(files)
+  return zlib.gzipSync(Buffer.from(json))
+}
+
+async function fileRoutes(fastify) {
+  fastify.addContentTypeParser('application/octet-stream', function (request, payload, done) {
+    const chunks = []
+    let totalSize = 0
+    payload.on('data', chunk => {
+      totalSize += chunk.length
+      if (totalSize > MAX_UPLOAD_SIZE) {
+        done(new Error('File too large (max 50MB)'))
+        return
+      }
+      chunks.push(chunk)
+    })
+    payload.on('end', () => done(null, Buffer.concat(chunks)))
+    payload.on('error', done)
+  })
+
+  // List files
+  fastify.get('/api/files', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const subPath = request.query.path || ''
+    try {
+      let targetDir = FILES_DIR
+      if (subPath) {
+        targetDir = safePath(FILES_DIR, subPath)
+        if (!targetDir) {
+          reply.code(403)
+          return { success: false, error: 'Invalid path' }
+        }
+      }
+
+      await fs.mkdir(targetDir, { recursive: true })
+      const entries = await fs.readdir(targetDir, { withFileTypes: true })
+      const files = []
+
+      for (const entry of entries) {
+        const entryPath = path.join(targetDir, entry.name)
+        try {
+          const stat = await fs.lstat(entryPath)
+          if (stat.isSymbolicLink()) {
+            const realPath = await fs.realpath(entryPath)
+            if (!realPath.startsWith(FILES_DIR)) continue
+          }
+          const relativePath = path.relative(FILES_DIR, entryPath)
+          files.push({
+            name: entry.name,
+            path: relativePath,
+            size: stat.size,
+            modified: stat.mtime.toISOString(),
+            is_directory: entry.isDirectory(),
+          })
+        } catch { /* skip */ }
+      }
+
+      files.sort((a, b) => {
+        if (a.is_directory !== b.is_directory) return a.is_directory ? -1 : 1
+        return a.name.localeCompare(b.name)
+      })
+
+      return { success: true, files, current_path: subPath || '' }
+    } catch (error) {
+      console.error(`[Files] List error: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Download file or directory
+  fastify.get('/api/files/*', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const filePath = request.params['*']
+    if (!filePath) {
+      reply.code(400)
+      return { success: false, error: 'File path is required' }
+    }
+
+    const resolved = safePath(FILES_DIR, filePath)
+    if (!resolved) {
+      reply.code(403)
+      return { success: false, error: 'Invalid path' }
+    }
+
+    try {
+      const stat = await fs.lstat(resolved)
+
+      if (stat.isSymbolicLink()) {
+        const realPath = await fs.realpath(resolved)
+        if (!realPath.startsWith(FILES_DIR)) {
+          reply.code(403)
+          return { success: false, error: 'Invalid path' }
+        }
+      }
+
+      // Directory download as gzip
+      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 compressed = createDirArchive(resolved)
+
+        reply
+          .type('application/gzip')
+          .header('Content-Disposition', `attachment; filename="${encodeURIComponent(dirName)}.tar.gz"`)
+
+        return reply.send(compressed)
+      }
+
+      const filename = path.basename(resolved)
+      reply
+        .type('application/octet-stream')
+        .header('Content-Disposition', `attachment; filename="${encodeURIComponent(filename)}"`)
+        .header('Content-Length', stat.size)
+
+      return reply.send(fsSync.createReadStream(resolved))
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        reply.code(404)
+        return { success: false, error: 'File not found' }
+      }
+      console.error(`[Files] Download error: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Upload file
+  fastify.post('/api/files/*', { bodyLimit: MAX_UPLOAD_SIZE }, async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const filePath = request.params['*']
+    if (!filePath) {
+      reply.code(400)
+      return { success: false, error: 'File path is required' }
+    }
+
+    const resolved = safePath(FILES_DIR, filePath)
+    if (!resolved) {
+      reply.code(403)
+      return { success: false, error: 'Invalid path' }
+    }
+    if (resolved === FILES_DIR) {
+      reply.code(400)
+      return { success: false, error: 'Invalid file path' }
+    }
+
+    try {
+      const body = request.body
+      if (!Buffer.isBuffer(body)) {
+        reply.code(400)
+        return { success: false, error: 'Expected binary body (application/octet-stream)' }
+      }
+
+      await fs.mkdir(path.dirname(resolved), { recursive: true })
+      await fs.writeFile(resolved, body)
+
+      const stat = await fs.stat(resolved)
+      const relativePath = path.relative(FILES_DIR, resolved)
+
+      console.log(`[Files] Uploaded: ${relativePath} (${stat.size} bytes)`)
+      return {
+        success: true,
+        file: { name: path.basename(resolved), path: relativePath, size: stat.size },
+      }
+    } catch (error) {
+      console.error(`[Files] Upload error: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Delete file
+  fastify.delete('/api/files/*', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const filePath = request.params['*']
+    if (!filePath) {
+      reply.code(400)
+      return { success: false, error: 'File path is required' }
+    }
+
+    const resolved = safePath(FILES_DIR, filePath)
+    if (!resolved) {
+      reply.code(403)
+      return { success: false, error: 'Invalid path' }
+    }
+    if (resolved === FILES_DIR) {
+      reply.code(400)
+      return { success: false, error: 'Cannot delete root files directory' }
+    }
+
+    try { await fs.access(resolved) } catch {
+      reply.code(404)
+      return { success: false, error: 'File not found' }
+    }
+
+    try {
+      const stat = await fs.lstat(resolved)
+      await fs.rm(resolved, { recursive: stat.isDirectory(), force: true })
+      const relativePath = path.relative(FILES_DIR, resolved)
+      console.log(`[Files] Deleted: ${relativePath}`)
+      return { success: true, message: `Deleted ${relativePath}` }
+    } catch (error) {
+      console.error(`[Files] Delete error: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+}
+
+module.exports = { fileRoutes }