@geekbeer/minion 3.43.0 → 3.49.1

package/win/board-task-runner.js

@@ -0,0 +1,181 @@
+/**
+ * Board Task Runner (Windows / WSL固定)
+ *
+ * Board tasks always run inside WSL on Windows minions. This runner is a
+ * thin HTTP proxy to wsl-session-server (which runs in user context and
+ * actually invokes wsl.exe + tmux).
+ *
+ * Why WSL-only:
+ *   - tmux exists inside WSL but not on Windows native; using tmux unifies
+ *     session naming/visibility with Linux minions (`tmux ls | grep bt-`).
+ *   - The Linux toolchain inside WSL is what board task work usually needs.
+ *   - The chat/workflow native paths remain available for users who want
+ *     them; only board tasks are pinned to WSL.
+ *
+ * Session naming: `bt-{taskId.slice(0,8)}` (same as Linux)
+ */
+
+const path = require('path')
+const fs = require('fs')
+const http = require('http')
+const { config } = require('../core/config')
+const runningTasks = require('../core/lib/running-tasks')
+const { buildBoardTaskInjection } = require('../core/lib/board-task-context')
+
+const WSL_PORT = parseInt(process.env.WSL_SESSION_PORT, 10) || 7682
+const TASK_TIMEOUT_MS = 4 * 60 * 60 * 1000
+const POLL_INTERVAL_MS = 5_000
+
+function generateSessionName(taskId) {
+  if (!taskId) throw new Error('taskId is required')
+  return `bt-${String(taskId).substring(0, 8)}`
+}
+
+function getWslToken() {
+  try {
+    const tokenPath = path.join(config.HOME_DIR, '.minion', '.wsl-session-token')
+    return fs.readFileSync(tokenPath, 'utf-8').trim()
+  } catch { return '' }
+}
+
+function proxyToWsl(method, urlPath, body) {
+  return new Promise((resolve) => {
+    const token = getWslToken()
+    const bodyStr = body ? JSON.stringify(body) : ''
+    const headers = { 'Authorization': `Bearer ${token}` }
+    if (body) {
+      headers['Content-Type'] = 'application/json'
+      headers['Content-Length'] = Buffer.byteLength(bodyStr)
+    }
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: WSL_PORT,
+      path: urlPath,
+      method,
+      headers,
+      timeout: 30_000,
+    }, (res) => {
+      let data = ''
+      res.on('data', (c) => { data += c })
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) } catch { resolve(null) }
+      })
+    })
+    req.on('error', () => resolve(null))
+    req.on('timeout', () => { req.destroy(); resolve(null) })
+    if (body) req.write(bodyStr)
+    req.end()
+  })
+}
+
+function buildKickoffPrompt(task, contextData) {
+  const lines = [
+    `[ボードタスク自動着手] [task:${task.id}] ${task.title}`,
+    '',
+    'このボードタスクが自動でアサインされたため、着手を開始してください。',
+    'アクティブスプリント内でステータスを `doing` にしました。',
+    '',
+    '完了したら以下で `review` に遷移してユーザーにレビュー依頼してください:',
+    `  PATCH \$HQ_URL/api/minion/projects/${task.project_id}/tasks/${task.id}`,
+    '  Body: {"status": "review"}',
+    '',
+  ]
+  const injection = buildBoardTaskInjection({
+    type: 'board_task',
+    task,
+    project_id: task.project_id,
+    sprint: contextData.sprint || null,
+    project_context_content: contextData.projectContextContent || null,
+    members: contextData.members || null,
+  })
+  if (injection) lines.push(injection)
+  return lines.join('\n')
+}
+
+async function runBoardTask({ task, contextData = {} }) {
+  if (!task || !task.id) {
+    return { sessionName: null, started: false, success: false, error: 'task is required' }
+  }
+
+  const sessionName = generateSessionName(task.id)
+
+  // Carry-over check
+  const hasRes = await proxyToWsl('GET', `/api/wsl/board-task/has?session=${encodeURIComponent(sessionName)}`)
+  if (!hasRes) {
+    return { sessionName, started: false, success: false, error: 'WSL session server unreachable (target user must be logged in)' }
+  }
+  if (hasRes.exists) {
+    console.log(`[BoardTaskRunner/Win] tmux session ${sessionName} already exists in WSL, skipping start`)
+    runningTasks.add({
+      type: 'board_task',
+      session_name: sessionName,
+      board_task_id: task.id,
+      started_at: new Date().toISOString(),
+    })
+    return { sessionName, started: false, success: true }
+  }
+
+  console.log(`[BoardTaskRunner/Win] Starting board task ${task.id} in WSL`)
+  console.log(`[BoardTaskRunner/Win] tmux session: ${sessionName}`)
+
+  const prompt = buildKickoffPrompt(task, contextData)
+  const promptB64 = Buffer.from(prompt, 'utf-8').toString('base64')
+
+  const startRes = await proxyToWsl('POST', '/api/wsl/board-task/start', {
+    session_name: sessionName,
+    prompt_b64: promptB64,
+  })
+  if (!startRes || !startRes.success) {
+    const errMsg = (startRes && startRes.error) || 'WSL session server unreachable'
+    console.error(`[BoardTaskRunner/Win] start failed: ${errMsg}`)
+    return { sessionName, started: false, success: false, error: errMsg }
+  }
+
+  runningTasks.add({
+    type: 'board_task',
+    session_name: sessionName,
+    board_task_id: task.id,
+    started_at: new Date().toISOString(),
+  })
+
+  try {
+    const startTime = Date.now()
+    while (Date.now() - startTime < TASK_TIMEOUT_MS) {
+      const exitRes = await proxyToWsl('GET', `/api/wsl/board-task/exit-code?session=${encodeURIComponent(sessionName)}`)
+      if (exitRes && exitRes.success && exitRes.exit_code !== null && exitRes.exit_code !== undefined) {
+        const exitCode = exitRes.exit_code
+        if (exitCode === 0) {
+          console.log(`[BoardTaskRunner/Win] Task ${task.id} CLI completed`)
+          return { sessionName, started: true, success: true }
+        }
+        console.error(`[BoardTaskRunner/Win] Task ${task.id} CLI exited with code ${exitCode}`)
+        return { sessionName, started: true, success: false, error: `Exit code: ${exitCode}` }
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+    }
+    console.error(`[BoardTaskRunner/Win] Task ${task.id} timed out after ${TASK_TIMEOUT_MS / 1000}s`)
+    await proxyToWsl('POST', '/api/wsl/board-task/kill', { session: sessionName })
+    return { sessionName, started: true, success: false, error: 'Execution timeout' }
+  } finally {
+    runningTasks.remove(sessionName)
+  }
+}
+
+async function isBoardTaskRunning(taskId) {
+  const sessionName = generateSessionName(taskId)
+  const res = await proxyToWsl('GET', `/api/wsl/board-task/has?session=${encodeURIComponent(sessionName)}`)
+  return !!(res && res.exists)
+}
+
+async function listBoardTaskSessions() {
+  const res = await proxyToWsl('GET', '/api/wsl/board-tasks')
+  if (!res || !res.success) return []
+  return (res.sessions || []).map((s) => s.name)
+}
+
+module.exports = {
+  runBoardTask,
+  isBoardTaskRunning,
+  generateSessionName,
+  listBoardTaskSessions,
+}

package/win/routes/chat.js

@@ -118,14 +118,16 @@ async function chatRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { message, session_id, context, wsl_mode, workspace_id } = request.body || {}
+    const { message, session_id, context, wsl_mode, workspace_id, referenced_tasks } = request.body || {}
     if (!message || typeof message !== 'string') {
       reply.code(400)
       return { success: false, error: 'message is required' }
     }
 
     const workspaceId = workspace_id || null
-    const prompt = await buildContextPrefix(message, context, session_id, workspaceId)
+    // referenced_tasks is injected into the prompt only (not stored in history)
+    // so the user's chat log keeps just the [task:UUID] tag, not a noisy dump.
+    const prompt = await buildContextPrefix(message, context, session_id, workspaceId, referenced_tasks)
     const currentSessionId = session_id || null
 
     if (currentSessionId) {
@@ -322,9 +324,25 @@ ${indexed}`
   })
 }
 
-async function buildContextPrefix(message, context, sessionId, workspaceId) {
+async function buildContextPrefix(message, context, sessionId, workspaceId, referencedTasks) {
   const parts = []
 
+  // Resolved [task:UUID] tags from HQ — surface ticket details so Claude can
+  // talk about them without first having to hit the API.
+  if (Array.isArray(referencedTasks) && referencedTasks.length > 0) {
+    parts.push('[参照チケット — ユーザーがメッセージ内で `[task:UUID]` 形式で参照しているHQボード上のタスク]')
+    for (const t of referencedTasks) {
+      if (!t || !t.id) continue
+      const desc = t.description ? ` / ${String(t.description).slice(0, 200).replace(/\s+/g, ' ')}` : ''
+      const due = t.due_date ? ` / 期限: ${t.due_date}` : ''
+      parts.push(
+        `- [task:${t.id}] ${t.title || '(無題)'} (status: ${t.status || '?'}, priority: ${t.priority || '?'}${due})${desc}`,
+        `  詳細/更新: GET|PATCH $HQ_URL/api/minion/projects/${t.project_id}/tasks/${t.id}`,
+      )
+    }
+    parts.push('')
+  }
+
   // Inject workspace context so Claude Code knows which workspace it's operating in
   if (workspaceId) {
     const workspaceStore = require('../../core/stores/workspace-store')
@@ -474,9 +492,9 @@ async function buildContextPrefix(message, context, sessionId, workspaceId) {
             `  hq fetch project ${context.projectId}`,
             `  hq fetch project-context ${context.projectId}`,
             `タスク・マイルストーン・健康度を扱う場合は以下のAPIを使えます (Bearer 認証必須):`,
-            `  GET    \$HQ_URL/api/minion/projects/${context.projectId}/tasks       # 一覧 (?milestone_id= ?status= ?priority=high,urgent ?assignee_minion_id= ?overdue=true ?q=<substring> 等で絞り込み可。q は日本語OKの部分一致)`,
-            `  POST   \$HQ_URL/api/minion/projects/${context.projectId}/tasks       # 作成 (body: title, description?, status?, priority?, milestone_id?, parent_task_id?, assignee_minion_id?, due_date?)`,
-            `  PATCH  \$HQ_URL/api/minion/projects/${context.projectId}/tasks/<id>  # 更新 (status変更で status_changed_at がサーバ自動更新、priority 変更も可)`,
+            `  GET    \$HQ_URL/api/minion/projects/${context.projectId}/tasks       # 一覧 (?milestone_id= ?sprint_id= ?status= ?priority=high,urgent ?assignee_minion_id= ?overdue=true ?q=<substring> 等で絞り込み可。q は日本語OKの部分一致)`,
+            `  POST   \$HQ_URL/api/minion/projects/${context.projectId}/tasks       # 作成 (body: title, description?, status?, priority?, milestone_id?, sprint_id?, parent_task_id?, assignee_minion_id?, due_date?, acceptance_criteria?)`,
+            `  PATCH  \$HQ_URL/api/minion/projects/${context.projectId}/tasks/<id>  # 更新 (status変更で status_changed_at がサーバ自動更新、acceptance_criteria/sprint_id も更新可。AC更新時は既存idを保持)`,
             `  GET    \$HQ_URL/api/minion/projects/${context.projectId}/milestones  # マイルストーン一覧`,
             `  GET    \$HQ_URL/api/minion/projects/${context.projectId}/health      # 健康度サマリ (overdue/stalled/マイルストーン進捗。progress_pct は leaf タスク基準)`,
             `タスクは5段階Kanban (backlog→todo→doing→review→done)、親子は2階層まで(孫不可)。priority は low|normal|high|urgent (可視化+フィルタ用)。親EPICに milestone_id を付ければ子タスクも進捗に自動反映される。詳細は ~/.minion/docs/api-reference.md の「Project Tasks」「Project Milestones」「Project Health」を参照。`,

package/win/routes/terminal.js

@@ -181,6 +181,14 @@ async function terminalRoutes(fastify) {
       }
     }
 
+    // Merge WSL-tmux board task sessions (bt-*)
+    const btResult = await proxyToWsl('GET', '/api/wsl/board-tasks')
+    if (btResult && btResult.success && btResult.sessions) {
+      for (const s of btResult.sessions) {
+        sessions.push({ name: s.name, type: 'wsl-tmux', completed: false })
+      }
+    }
+
     console.log(`[Terminal] Found ${sessions.length} session(s): ${sessions.map(s => s.name).join(', ') || '(none)'}`)
     return { success: true, sessions }
   })

package/win/server.js

@@ -28,6 +28,7 @@ let lastBeatAt = null
 // Windows-specific modules
 const workflowRunner = require('./workflow-runner')
 const routineRunner = require('./routine-runner')
+const boardTaskRunner = require('./board-task-runner')
 
 // Config warnings (included in heartbeat)
 const { getConfigWarnings } = require('../core/lib/config-warnings')
@@ -35,6 +36,7 @@ const { getConfigWarnings } = require('../core/lib/config-warnings')
 // Pull-model daemons (from core/)
 const stepPoller = require('../core/lib/step-poller')
 const dagStepPoller = require('../core/lib/dag-step-poller')
+const boardTaskPoller = require('../core/lib/board-task-poller')
 const revisionWatcher = require('../core/lib/revision-watcher')
 const reflectionScheduler = require('../core/lib/reflection-scheduler')
 const threadWatcher = require('../core/lib/thread-watcher')
@@ -97,6 +99,7 @@ async function shutdown(signal) {
 
   stepPoller.stop()
   dagStepPoller.stop()
+  boardTaskPoller.stop()
   revisionWatcher.stop()
   reflectionScheduler.stop()
   threadWatcher.stop()
@@ -371,6 +374,8 @@ async function start() {
       // Start Pull-model daemons
       stepPoller.start()
       dagStepPoller.start()
+      boardTaskPoller.setRunner(boardTaskRunner)
+      boardTaskPoller.start()
       revisionWatcher.start()
       threadWatcher.start(runQuickLlmCall)
     } else {

package/win/wsl-session-server.js

@@ -17,7 +17,9 @@
 const fs = require('fs')
 const path = require('path')
 const http = require('http')
-const { spawn } = require('child_process')
+const { spawn, exec } = require('child_process')
+const { promisify } = require('util')
+const execAsync = promisify(exec)
 
 // ---------------------------------------------------------------------------
 // Configuration
@@ -240,6 +242,43 @@ function streamLlmResponse(res, prompt, sessionId) {
   })
 }
 
+// ---------------------------------------------------------------------------
+// Board Task helpers (run inside WSL via wsl.exe + tmux)
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a tmux command inside WSL and return stdout.
+ * Throws on non-zero exit.
+ */
+async function wslExec(command) {
+  const { stdout } = await execAsync(`wsl.exe -e bash -lc ${JSON.stringify(command)}`, {
+    encoding: 'utf-8',
+    maxBuffer: 4 * 1024 * 1024,
+  })
+  return stdout
+}
+
+async function wslHasTmuxSession(sessionName) {
+  try {
+    await execAsync(`wsl.exe -e bash -lc ${JSON.stringify(`tmux has-session -t ${sessionName} 2>/dev/null`)}`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function wslListBoardTaskSessions() {
+  try {
+    const stdout = await wslExec(`tmux ls -F '#S' 2>/dev/null || true`)
+    return stdout
+      .split('\n')
+      .map((s) => s.trim())
+      .filter((s) => s.startsWith('bt-'))
+  } catch {
+    return []
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Fastify HTTP server
 // ---------------------------------------------------------------------------
@@ -363,6 +402,102 @@ async function startServer() {
     return { success: true, session: sessionName, content, lines: lineCount, timestamp: Date.now() }
   })
 
+  // --- Board Task: list bt-* tmux sessions inside WSL ---
+  fastify.get('/api/wsl/board-tasks', async (request, reply) => {
+    if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }
+    const names = await wslListBoardTaskSessions()
+    return { success: true, sessions: names.map((name) => ({ name, type: 'wsl-tmux' })) }
+  })
+
+  // --- Board Task: check if a bt-* tmux session exists inside WSL ---
+  fastify.get('/api/wsl/board-task/has', async (request, reply) => {
+    if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }
+    const { session } = request.query || {}
+    if (!session || !/^[\w-]+$/.test(session)) {
+      reply.code(400); return { success: false, error: 'Invalid session name' }
+    }
+    const exists = await wslHasTmuxSession(session)
+    return { success: true, exists }
+  })
+
+  // --- Board Task: start a detached tmux session inside WSL ---
+  // Request body: { session_name, prompt_b64 }
+  // Writes prompt to ~/.minion/board-task-{session_name}.txt inside WSL,
+  // then starts: tmux new-session -d -s {name} 'claude -p < prompt; echo $? > exit-file'
+  fastify.post('/api/wsl/board-task/start', async (request, reply) => {
+    if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }
+    const { session_name, prompt_b64 } = request.body || {}
+    if (!session_name || !/^bt-[\w-]+$/.test(session_name)) {
+      reply.code(400); return { success: false, error: 'session_name must match bt-*' }
+    }
+    if (!prompt_b64 || typeof prompt_b64 !== 'string') {
+      reply.code(400); return { success: false, error: 'prompt_b64 is required' }
+    }
+
+    // Skip if already running
+    if (await wslHasTmuxSession(session_name)) {
+      return { success: true, started: false, message: `Session ${session_name} already exists` }
+    }
+
+    try {
+      // Write prompt file inside WSL ($HOME path).
+      // Use stdin->base64->file to avoid quoting issues with the prompt content.
+      const promptPath = `$HOME/.minion/board-task-${session_name}.txt`
+      const exitCodePath = `/tmp/tmux-exit-${session_name}`
+      const writeCmd = `mkdir -p $HOME/.minion && echo ${prompt_b64} | base64 -d > ${promptPath}`
+      await wslExec(writeCmd)
+
+      // Build the claude invocation. Default to `claude -p < prompt`.
+      // LLM_COMMAND override is ignored here since WSL has its own env;
+      // future: read /api/llm/config from the minion-agent if needed.
+      const inner = `claude -p < ${promptPath}; echo $? > ${exitCodePath}`
+      const tmuxCmd =
+        `tmux new-session -d -s ${session_name} -x 200 -y 50 'bash -lc ${JSON.stringify(inner).replace(/'/g, `'\\''`)}'` +
+        ` && tmux set-option -t ${session_name} remain-on-exit on`
+      await wslExec(tmuxCmd)
+
+      console.log(`[WSL] Started board task tmux session ${session_name}`)
+      return { success: true, started: true, session_name }
+    } catch (err) {
+      console.error('[WSL] board-task/start failed:', err.message)
+      reply.code(500); return { success: false, error: err.message }
+    }
+  })
+
+  // --- Board Task: read exit code file (returns null if not yet exited) ---
+  fastify.get('/api/wsl/board-task/exit-code', async (request, reply) => {
+    if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }
+    const { session } = request.query || {}
+    if (!session || !/^bt-[\w-]+$/.test(session)) {
+      reply.code(400); return { success: false, error: 'Invalid session name' }
+    }
+    try {
+      const stdout = await wslExec(`cat /tmp/tmux-exit-${session} 2>/dev/null || echo ""`)
+      const trimmed = stdout.trim()
+      if (!trimmed) return { success: true, exit_code: null }
+      const code = parseInt(trimmed, 10)
+      return { success: true, exit_code: isNaN(code) ? null : code }
+    } catch (err) {
+      reply.code(500); return { success: false, error: err.message }
+    }
+  })
+
+  // --- Board Task: kill a bt-* tmux session ---
+  fastify.post('/api/wsl/board-task/kill', async (request, reply) => {
+    if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }
+    const { session } = request.body || {}
+    if (!session || !/^bt-[\w-]+$/.test(session)) {
+      reply.code(400); return { success: false, error: 'Invalid session name' }
+    }
+    try {
+      await wslExec(`tmux kill-session -t ${session} 2>/dev/null || true`)
+      await wslExec(`rm -f /tmp/tmux-exit-${session} $HOME/.minion/board-task-${session}.txt 2>/dev/null || true`)
+      return { success: true, session }
+    } catch (err) {
+      reply.code(500); return { success: false, error: err.message }
+    }
+  })
+
   // --- Chat: SSE stream ---
   fastify.post('/api/wsl/chat', async (request, reply) => {
     if (!verifyToken(request)) { reply.code(401); return { success: false, error: 'Unauthorized' } }