@geekbeer/minion 1.6.1 → 2.4.1

package/routes/skills.js

@@ -2,8 +2,11 @@
  * Skill management endpoints
  *
  * Endpoints:
- * - GET  /api/list-skills   - List deployed skills
- * - POST /api/deploy-skill  - Deploy a skill
+ * - GET  /api/list-skills        - List locally deployed skills
+ * - DELETE /api/skills/:name     - Delete a local skill
+ * - POST /api/skills/push/:name  - Push local skill to HQ
+ * - POST /api/skills/fetch/:name - Fetch skill from HQ and deploy locally
+ * - GET  /api/skills/remote      - List skills on HQ
  */
 
 const fs = require('fs').promises
@@ -11,6 +14,111 @@ const path = require('path')
 const os = require('os')
 
 const { verifyToken } = require('../lib/auth')
+const api = require('../api')
+const { isHqConfigured } = require('../config')
+
+/**
+ * Parse YAML frontmatter from SKILL.md content
+ * @param {string} content - Raw file content
+ * @returns {{ metadata: object, body: string }}
+ */
+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() }
+}
+
+/**
+ * Write a skill to the local ~/.claude/skills/ directory.
+ * Shared by deploy-skill and skills/fetch endpoints.
+ *
+ * @param {string} name - Skill slug (e.g. "execution-report")
+ * @param {object} opts
+ * @param {string} opts.content - Skill body (markdown without frontmatter)
+ * @param {string} [opts.description] - Skill description for frontmatter
+ * @param {string} [opts.display_name] - Display name for frontmatter
+ * @param {Array<{filename: string, content: string}>} [opts.references] - Reference files
+ * @returns {Promise<{path: string, references_count: number}>}
+ */
+async function writeSkillToLocal(name, { content, description, display_name, references = [] }) {
+  const skillDir = path.join(os.homedir(), '.claude', 'skills', name)
+  const referencesDir = path.join(skillDir, 'references')
+
+  await fs.mkdir(skillDir, { recursive: true })
+  await fs.mkdir(referencesDir, { recursive: true })
+
+  // Build frontmatter with all available metadata
+  const frontmatterLines = [
+    `name: ${name}`,
+    display_name ? `display_name: ${display_name}` : null,
+    `description: ${description || ''}`,
+  ].filter(Boolean).join('\n')
+
+  await fs.writeFile(
+    path.join(skillDir, 'SKILL.md'),
+    `---\n${frontmatterLines}\n---\n\n${content}`,
+    'utf-8'
+  )
+
+  // Write reference files
+  for (const ref of references) {
+    if (ref.filename && ref.content) {
+      const safeFilename = path.basename(ref.filename)
+      await fs.writeFile(path.join(referencesDir, safeFilename), ref.content, 'utf-8')
+    }
+  }
+
+  return { path: skillDir, references_count: references.length }
+}
+
+/**
+ * Read a local skill and push it to HQ.
+ * Reusable by workflow push to auto-sync pipeline skills.
+ *
+ * @param {string} name - Skill slug (e.g. "execution-report")
+ * @returns {Promise<object>} HQ response
+ * @throws {Error} If skill not found locally or HQ rejects
+ */
+async function pushSkillToHQ(name) {
+  const homeDir = os.homedir()
+  const skillDir = path.join(homeDir, '.claude', 'skills', name)
+  const skillMdPath = path.join(skillDir, 'SKILL.md')
+
+  const rawContent = await fs.readFile(skillMdPath, 'utf-8')
+  const { metadata, body } = parseFrontmatter(rawContent)
+
+  // Read references
+  const referencesDir = path.join(skillDir, 'references')
+  const references = []
+  try {
+    const refEntries = await fs.readdir(referencesDir)
+    for (const filename of refEntries) {
+      const refContent = await fs.readFile(path.join(referencesDir, filename), 'utf-8')
+      references.push({ filename, content: refContent })
+    }
+  } catch {
+    // No references directory
+  }
+
+  return api.request('/skills', {
+    method: 'POST',
+    body: JSON.stringify({
+      name: metadata.name || name,
+      display_name: metadata.display_name || metadata.name || name,
+      description: metadata.description || '',
+      content: body,
+      references,
+    }),
+  })
+}
 
 /**
  * Register skill routes as Fastify plugin
@@ -66,71 +174,105 @@ async function skillRoutes(fastify) {
     }
   })
 
-  // Deploy skill to local .claude/skills directory
-  fastify.post('/api/deploy-skill', async (request, reply) => {
+  // Push local skill to HQ
+  fastify.post('/api/skills/push/:name', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { name, content, references = [] } = request.body || {}
-
-    if (!name || !content) {
+    if (!isHqConfigured()) {
       reply.code(400)
-      return { success: false, error: 'name and content are required' }
+      return { success: false, error: 'HQ not configured' }
     }
 
-    // Validate skill name (URL-safe slug)
-    if (!/^[a-z0-9-]+$/.test(name)) {
+    const { name } = request.params
+
+    if (!name || !/^[a-z0-9-]+$/.test(name)) {
       reply.code(400)
-      return { success: false, error: 'Skill name must be URL-safe (lowercase letters, numbers, and hyphens only)' }
+      return { success: false, error: 'Invalid skill name' }
     }
 
-    console.log(`[Deploy] Deploying skill: ${name}`)
+    console.log(`[Skills] Pushing skill to HQ: ${name}`)
 
     try {
-      // Create skill directory in ~/.claude/skills/
-      const homeDir = os.homedir()
-      const skillDir = path.join(homeDir, '.claude', 'skills', name)
-      const referencesDir = path.join(skillDir, 'references')
-
-      // Create directories
-      await fs.mkdir(skillDir, { recursive: true })
-      await fs.mkdir(referencesDir, { recursive: true })
-
-      // Write SKILL.md with frontmatter
-      const skillContent = `---
-name: ${name}
-description: Deployed from HQ
----
-
-${content}`
-      await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf-8')
-
-      // Write reference files
-      for (const ref of references) {
-        if (ref.filename && ref.content) {
-          // Sanitize filename to prevent directory traversal
-          const safeFilename = path.basename(ref.filename)
-          await fs.writeFile(path.join(referencesDir, safeFilename), ref.content, 'utf-8')
-        }
-      }
+      const result = await pushSkillToHQ(name)
+      console.log(`[Skills] Skill pushed to HQ: ${name}`)
+      return { success: true, ...result }
+    } catch (error) {
+      console.error(`[Skills] Failed to push skill: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
 
-      console.log(`[Deploy] Skill deployed successfully: ${name}`)
+  // Fetch skill from HQ and deploy locally
+  fastify.post('/api/skills/fetch/:name', 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' }
+    }
+
+    const { name } = request.params
+
+    if (!name || !/^[a-z0-9-]+$/.test(name)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid skill name' }
+    }
+
+    console.log(`[Skills] Fetching skill from HQ: ${name}`)
+
+    try {
+      // Fetch from HQ
+      const skill = await api.request(`/skills/${encodeURIComponent(name)}`)
+
+      // Write to local filesystem using shared helper
+      const result = await writeSkillToLocal(name, {
+        content: skill.content,
+        description: skill.description,
+        display_name: skill.display_name,
+        references: skill.references || [],
+      })
+
+      console.log(`[Skills] Skill fetched and deployed: ${name}`)
       return {
         success: true,
-        message: `Skill "${name}" deployed successfully`,
-        path: skillDir,
-        references_count: references.length,
+        message: `Skill "${name}" fetched from HQ`,
+        ...result,
       }
     } catch (error) {
-      console.error(`[Deploy] Failed to deploy skill: ${error.message}`)
-      reply.code(500)
-      return {
-        success: false,
-        error: error.message,
-      }
+      console.error(`[Skills] Failed to fetch skill: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // List skills on HQ (remote)
+  fastify.get('/api/skills/remote', 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('[Skills] Listing remote skills from HQ')
+
+    try {
+      const result = await api.request('/skills')
+      return result
+    } catch (error) {
+      console.error(`[Skills] Failed to list remote skills: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
     }
   })
 
@@ -185,4 +327,4 @@ ${content}`
   })
 }
 
-module.exports = { skillRoutes }
+module.exports = { skillRoutes, writeSkillToLocal, pushSkillToHQ }

package/routes/terminal.js

@@ -16,6 +16,7 @@
 
 const { exec, spawn } = require('child_process')
 const { promisify } = require('util')
+const path = require('path')
 const net = require('net')
 const os = require('os')
 const execAsync = promisify(exec)
@@ -122,6 +123,17 @@ async function startTtydForSession(session) {
     }
   }
 
+  // Reload tmux.conf to ensure mouse/scroll settings are active
+  const tmuxConf = path.join(homeDir, '.tmux.conf')
+  try {
+    await execAsync(`tmux source-file "${tmuxConf}"`, {
+      timeout: 5000,
+      env: { ...process.env, HOME: homeDir },
+    })
+  } catch {
+    // Ignore: .tmux.conf may not exist yet on first run
+  }
+
   const port = await findAvailablePort()
 
   const proc = spawn('ttyd', [

package/routes/workflows.js

@@ -2,22 +2,32 @@
  * Workflow management endpoints
  *
  * Endpoints:
- * - GET  /api/workflows           - List all workflows with status
- * - POST /api/workflows           - Receive workflows from HQ (upsert/additive)
- * - PUT  /api/workflows/:id       - Update a workflow (schedule, is_active)
- * - DELETE /api/workflows/:id     - Remove a workflow
- * - POST /api/workflows/trigger   - Manual trigger for a workflow
- * - GET  /api/executions          - List execution history
- * - GET  /api/executions/:id      - Get single execution details
- * - GET  /api/executions/:id/log  - Get execution log file content
+ * - GET  /api/workflows              - List all workflows with status
+ * - POST /api/workflows              - Receive workflows from HQ (upsert/additive)
+ * - POST /api/workflows/push/:name   - Push local workflow to HQ
+ * - POST /api/workflows/fetch/:name  - Fetch workflow from HQ and deploy locally
+ * - GET  /api/workflows/remote       - List workflows on HQ
+ * - PUT  /api/workflows/:id/schedule - Update a workflow schedule (cron_expression, is_active)
+ * - DELETE /api/workflows/:id        - Remove a workflow
+ * - POST /api/workflows/trigger      - Manual trigger for a workflow
+ * - GET  /api/executions             - List execution history
+ * - GET  /api/executions/:id         - Get single execution details
+ * - GET  /api/executions/:id/log     - Get execution log file content
  * - POST /api/executions/:id/outcome - Update execution outcome (no auth, local)
  */
 
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
 const { verifyToken } = require('../lib/auth')
 const workflowRunner = require('../workflow-runner')
 const workflowStore = require('../workflow-store')
 const executionStore = require('../execution-store')
 const logManager = require('../lib/log-manager')
+const api = require('../api')
+const { isHqConfigured } = require('../config')
+const { writeSkillToLocal, pushSkillToHQ } = require('./skills')
 
 /**
  * Register workflow routes as Fastify plugin
@@ -93,8 +103,179 @@ async function workflowRoutes(fastify) {
     return { workflows: result }
   })
 
-  // Update a workflow (schedule, is_active)
-  fastify.put('/api/workflows/:id', async (request, reply) => {
+  // Push local workflow to HQ
+  fastify.post('/api/workflows/push/:name', 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' }
+    }
+
+    const { name } = request.params
+
+    if (!name || !/^[a-z0-9-]+$/.test(name)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid workflow name' }
+    }
+
+    console.log(`[Workflows] Pushing workflow to HQ: ${name}`)
+
+    try {
+      const workflow = await workflowStore.findByName(name)
+      if (!workflow) {
+        reply.code(404)
+        return { success: false, error: `Local workflow not found: ${name}` }
+      }
+
+      const pipelineSkillNames = workflow.pipeline_skill_names || []
+
+      // Auto-push pipeline skills to HQ (ensures they exist before workflow push)
+      const skillsPushed = []
+      const skillsFailed = []
+      for (const skillName of pipelineSkillNames) {
+        try {
+          await pushSkillToHQ(skillName)
+          skillsPushed.push(skillName)
+          console.log(`[Workflows] Auto-pushed pipeline skill: ${skillName}`)
+        } catch (err) {
+          console.log(`[Workflows] Skill "${skillName}" not auto-pushed: ${err.message}`)
+          skillsFailed.push(skillName)
+        }
+      }
+
+      if (skillsFailed.length > 0) {
+        reply.code(400)
+        return {
+          success: false,
+          error: `Pipeline skills not found locally: ${skillsFailed.join(', ')}. Deploy them first with: minion-cli skill fetch <name>`,
+          skills_pushed: skillsPushed,
+        }
+      }
+
+      const result = await api.request('/workflows', {
+        method: 'POST',
+        body: JSON.stringify({
+          name: workflow.name,
+          pipeline_skill_names: pipelineSkillNames,
+          content: workflow.content || '',
+        }),
+      })
+
+      console.log(`[Workflows] Workflow pushed to HQ: ${name}`)
+      return { success: true, skills_pushed: skillsPushed, ...result }
+    } catch (error) {
+      console.error(`[Workflows] Failed to push workflow: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Fetch workflow from HQ and deploy locally
+  fastify.post('/api/workflows/fetch/:name', 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' }
+    }
+
+    const { name } = request.params
+
+    if (!name || !/^[a-z0-9-]+$/.test(name)) {
+      reply.code(400)
+      return { success: false, error: 'Invalid workflow name' }
+    }
+
+    console.log(`[Workflows] Fetching workflow from HQ: ${name}`)
+
+    try {
+      // 1. Fetch workflow definition from HQ
+      const workflow = await api.request(`/workflows/${encodeURIComponent(name)}`)
+
+      // 2. Fetch pipeline skills that are not deployed locally
+      const fetchedSkills = []
+      const homeDir = os.homedir()
+
+      for (const skillName of workflow.pipeline_skill_names || []) {
+        const skillMdPath = path.join(homeDir, '.claude', 'skills', skillName, 'SKILL.md')
+        let exists = false
+        try {
+          await fs.access(skillMdPath)
+          exists = true
+        } catch {
+          // Skill not deployed locally
+        }
+
+        if (!exists) {
+          console.log(`[Workflows] Fetching pipeline skill: ${skillName}`)
+          const skill = await api.request(`/skills/${encodeURIComponent(skillName)}`)
+          await writeSkillToLocal(skillName, {
+            content: skill.content,
+            description: skill.description,
+            display_name: skill.display_name,
+            references: skill.references || [],
+          })
+          fetchedSkills.push(skillName)
+        }
+      }
+
+      // 3. Save workflow to local store (upsert by name)
+      const updatedWorkflows = await workflowStore.upsertByName({
+        name: workflow.name,
+        pipeline_skill_names: workflow.pipeline_skill_names,
+        content: workflow.content || '',
+      })
+
+      // 4. Reload cron jobs
+      workflowRunner.loadWorkflows(updatedWorkflows)
+
+      console.log(`[Workflows] Workflow fetched: ${name} (${fetchedSkills.length} skills fetched)`)
+      return {
+        success: true,
+        message: `Workflow "${name}" fetched from HQ`,
+        skills_fetched: fetchedSkills,
+        pipeline: workflow.pipeline_skill_names,
+      }
+    } catch (error) {
+      console.error(`[Workflows] Failed to fetch workflow: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // List workflows on HQ (remote)
+  fastify.get('/api/workflows/remote', 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('[Workflows] Listing remote workflows from HQ')
+
+    try {
+      const result = await api.request('/workflows')
+      return result
+    } catch (error) {
+      console.error(`[Workflows] Failed to list remote workflows: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Update a workflow schedule (cron_expression, is_active)
+  fastify.put('/api/workflows/:id/schedule', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
@@ -103,7 +284,7 @@ async function workflowRoutes(fastify) {
     const { id } = request.params
     const updates = request.body || {}
 
-    console.log(`[Workflows] Updating workflow: ${id}`)
+    console.log(`[Workflows] Updating workflow schedule: ${id}`)
 
     try {
       const workflows = await workflowStore.load()