@geekbeer/minion 4.5.1 → 4.7.0

package/win/routes/chat.js

@@ -24,8 +24,8 @@ const todoStore = require('../../core/stores/todo-store')
 const { DATA_DIR } = require('../../core/lib/platform')
 const { runEndOfDay } = require('../../core/lib/end-of-day')
 const { getActivePrimary } = require('../../core/llm-plugins/lib/active')
+const chatRunManager = require('../../core/lib/chat-run-manager')
 
-let activeChatChild = null
 let wslModeActive = false
 
 // ---------------------------------------------------------------------------
@@ -113,6 +113,9 @@ function proxyWslChatAbort() {
 }
 
 async function chatRoutes(fastify) {
+  // Sweep stale runs from a previous boot and prune old run logs.
+  chatRunManager.init()
+
   fastify.post('/api/chat', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
@@ -146,30 +149,79 @@ async function chatRoutes(fastify) {
       }
     }
 
+    // WSL mode proxies to the WSL session server, which owns its own process
+    // lifecycle — leave that path untouched. Non-WSL mode uses the DETACHED run
+    // manager so a dropped connection no longer kills the LLM.
+    if (wsl_mode) {
+      reply.hijack()
+      reply.raw.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      })
+      reply.raw.flushHeaders()
+      try {
+        wslModeActive = true
+        console.log('[Chat] WSL mode enabled — proxying to WSL session server')
+        await proxyWslChat(reply.raw, prompt, currentSessionId)
+      } catch (err) {
+        console.error('[Chat] stream error:', err.message)
+        const errorEvent = JSON.stringify({ type: 'error', error: err.message })
+        reply.raw.write(`data: ${errorEvent}\n\n`)
+      } finally {
+        wslModeActive = false
+      }
+      reply.raw.end()
+      return
+    }
+
+    const runId = chatRunManager.start({
+      sessionId: currentSessionId,
+      pendingSessionId,
+      workspaceId,
+      invoke: buildInvoke(prompt, currentSessionId),
+    })
+
     reply.hijack()
-    reply.raw.writeHead(200, {
+    const res = reply.raw
+    res.writeHead(200, {
       'Content-Type': 'text/event-stream',
       'Cache-Control': 'no-cache',
       'Connection': 'keep-alive',
     })
-    reply.raw.flushHeaders()
+    res.flushHeaders()
+    res.write(`data: ${JSON.stringify({ type: 'run', run_id: runId, session_id: currentSessionId })}\n\n`)
+    await tailRunToResponse(res, runId, 0)
+    res.end()
+  })
 
-    try {
-      if (wsl_mode) {
-        wslModeActive = true
-        console.log('[Chat] WSL mode enabled — proxying to WSL session server')
-        await proxyWslChat(reply.raw, prompt, currentSessionId)
-        wslModeActive = false
-      } else {
-        await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message, pendingSessionId)
-      }
-    } catch (err) {
-      wslModeActive = false
-      console.error('[Chat] stream error:', err.message)
-      const errorEvent = JSON.stringify({ type: 'error', error: err.message })
-      reply.raw.write(`data: ${errorEvent}\n\n`)
+  // GET /api/chat/stream - Reconnect to an in-flight (or recently finished) run
+  // and resume tailing from `cursor`. (Detached, non-WSL runs only.)
+  fastify.get('/api/chat/stream', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
     }
-    reply.raw.end()
+
+    const workspaceId = request.query?.workspace_id || null
+    const runId = request.query?.run_id || chatRunManager.getActiveRunId(workspaceId)
+    const cursor = parseInt(request.query?.cursor, 10) || 0
+    if (!runId) {
+      reply.code(404)
+      return { success: false, error: 'No active run' }
+    }
+
+    reply.hijack()
+    const res = reply.raw
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    })
+    res.flushHeaders()
+    res.write(`data: ${JSON.stringify({ type: 'run', run_id: runId })}\n\n`)
+    await tailRunToResponse(res, runId, cursor)
+    res.end()
   })
 
   fastify.get('/api/chat/session', async (request, reply) => {
@@ -179,7 +231,9 @@ async function chatRoutes(fastify) {
     }
     const workspaceId = request.query?.workspace_id || null
     const session = chatStore.load(workspaceId)
-    if (!session) return { success: true, session: null }
+    const activeRunId = chatRunManager.getActiveRunId(workspaceId)
+    const activeRun = activeRunId ? chatRunManager.getRunInfo(activeRunId) : null
+    if (!session) return { success: true, session: null, active_run: activeRun }
     return {
       success: true,
       session: {
@@ -190,6 +244,7 @@ async function chatRoutes(fastify) {
         created_at: session.created_at,
         updated_at: session.updated_at,
       },
+      active_run: activeRun,
     }
   })
 
@@ -244,20 +299,16 @@ async function chatRoutes(fastify) {
       return proxyWslChatAbort()
     }
 
-    if (!activeChatChild) {
+    const workspaceId = request.body?.workspace_id || null
+    const runId = request.body?.run_id || chatRunManager.getActiveRunId(workspaceId)
+    if (!runId) {
       return { success: false, error: 'No active chat process' }
     }
-    console.log(`[Chat] Aborting active chat process PID: ${activeChatChild.pid}`)
-    activeChatChild.kill('SIGTERM')
-    const pid = activeChatChild.pid
-    setTimeout(() => {
-      try {
-        if (activeChatChild && activeChatChild.pid === pid) {
-          activeChatChild.kill('SIGKILL')
-        }
-      } catch { /* already dead */ }
-    }, 2000)
-    return { success: true }
+    const aborted = chatRunManager.abort(runId)
+    if (!aborted) {
+      return { success: false, error: 'No active chat process' }
+    }
+    return { success: true, run_id: runId }
   })
 
   // POST /api/chat/reset - Carry over relevant messages and start fresh session
@@ -474,9 +525,11 @@ async function buildContextPrefix(message, context, sessionId, workspaceId, refe
       'このAPIは内部で Playwright + Readability を回し、抽出済みJSONだけを返すため、',
       'DOM全体がチャットに流れ込んでトークン肥大化することを防げる。',
       '初回アクセスで学習したセレクタはSQLiteにキャッシュされ、2回目以降はLLM呼び出しなしで抽出される。',
+      'SPA(クライアント描画)も内部でDOM静止を待ってから抽出するためそのまま利用可。',
+      '無限スクロールで件数を増やしたい場合は `"scroll": {"strategy":"count","targetItems":50}` を付ける(どれだけ集めるかは呼び出し側が指定)。',
       '',
-      'Playwright MCP (`mcp__playwright__*`) は **ログイン・フォーム入力・複数画面の対話操作**が必要な場合のみ使用する。',
-      '単純な閲覧・要約・一覧取得用途ではMCPを使わない。',
+      'Playwright MCP (`mcp__playwright__*`) は **ログイン・フォーム入力・複数画面の対話操作・「もっと見る」ボタン**が必要な場合のみ使用する。',
+      '単純な閲覧・要約・一覧取得用途(SPA・無限スクロール含む)ではMCPを使わない。',
       '',
       'HQ (`*.minion-agent.com`) のページURLは **Playwrightで開かずAPIで取得する**。ノートは `GET $HQ_URL/api/minion/workspaces/:wsId/notes/:id`、タスクは `GET $HQ_URL/api/minion/projects/:pid/tasks/:id`。チャットで参照されたノート/タスクの本文は上記「参照ノート」「参照チケット」ブロックに既に注入済み。',
       ''
@@ -627,95 +680,98 @@ function getLlmBinary() {
 }
 
 /**
- * Stream LLM CLI output as SSE events.
- * Uses --resume to continue existing sessions.
- * Tracks block types to correctly forward tool_use vs text events
- * and counts turns for session management.
+ * Tail a detached run into an SSE response. Subscribes from `cursor`, forwards
+ * each event (seq-stamped), and resolves on the terminal `done` event OR when
+ * the client disconnects. Disconnecting only stops the tail — it never touches
+ * the underlying LLM process.
+ *
+ * @param {import('http').ServerResponse} res
+ * @param {string} runId
+ * @param {number} cursor   last sequence the client already has
  */
-async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
+function tailRunToResponse(res, runId, cursor) {
+  return new Promise(resolve => {
+    let settled = false
+    let unsubscribe = () => {}
+    const finish = () => {
+      if (settled) return
+      settled = true
+      try { unsubscribe() } catch { /* ignore */ }
+      resolve()
+    }
+    unsubscribe = chatRunManager.subscribe(runId, cursor, event => {
+      try { res.write(`data: ${JSON.stringify(event)}\n\n`) } catch { /* socket gone */ }
+      if (event.type === 'done') finish()
+    })
+    res.on('close', finish)
+  })
+}
+
+/**
+ * Build the LLM executor for a run. The executor emits normalized wire events
+ * and returns the collected result; the run manager owns persistence, the
+ * terminal `done` event, and abort.
+ *
+ * @param {string} prompt
+ * @param {string|null} sessionId
+ * @returns {(emit: (e: object) => void, activeRef: { current: any }) => Promise<{ fullResponse: string, resolvedSessionId: string|null, turnCount: number }>}
+ */
+function buildInvoke(prompt, sessionId) {
   const primary = getActivePrimary()
   if (primary) {
-    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
+    return (emit, activeRef) => invokeViaPlugin(primary, prompt, sessionId, emit, activeRef)
   }
-  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
+  return (emit, activeRef) => invokeViaLegacy(prompt, sessionId, emit, activeRef)
 }
 
-async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
+async function invokeViaPlugin(plugin, prompt, sessionId, emit, activeRef) {
   const input = { prompt }
-  const activeRef = { current: null }
-
   let fullResponse = ''
   let resolvedSessionId = sessionId || null
   let turnCount = 0
 
-  const emit = event => {
+  const onEvent = event => {
     if (event.type === 'session') {
       resolvedSessionId = event.sessionId
     } else if (event.type === 'delta') {
       fullResponse += event.content
-      res.write(`data: ${JSON.stringify({ type: 'delta', content: event.content })}\n\n`)
+      emit({ type: 'delta', content: event.content })
     } else if (event.type === 'text') {
       fullResponse += event.content
-      res.write(`data: ${JSON.stringify({ type: 'text', content: event.content })}\n\n`)
+      emit({ type: 'text', content: event.content })
       turnCount++
     } else {
-      res.write(`data: ${JSON.stringify(event)}\n\n`)
+      emit(event)
     }
   }
 
-  res.on('close', () => { activeRef.current?.kill?.('SIGTERM') })
-
-  let pluginError = null
   try {
     let output
     if (plugin.capabilities.streaming && typeof plugin.stream === 'function') {
-      output = await plugin.stream(input, emit, { resumeSessionId: sessionId, activeChildRef: activeRef })
+      output = await plugin.stream(input, onEvent, { resumeSessionId: sessionId, activeChildRef: activeRef })
     } else {
       output = await plugin.invoke(input)
       if (output.text) {
         fullResponse = output.text
-        res.write(`data: ${JSON.stringify({ type: 'text', content: output.text })}\n\n`)
+        emit({ type: 'text', content: output.text })
         turnCount = 1
       }
       if (output.error) {
-        res.write(`data: ${JSON.stringify({ type: 'error', error: output.error.message })}\n\n`)
+        emit({ type: 'error', error: output.error.message })
       }
     }
     resolvedSessionId = output?.metadata?.sessionId || resolvedSessionId
-  } catch (err) {
-    // Swallow here so we can persist any partial response first; rethrow below.
-    pluginError = err
-  }
-
-  // For new sessions, the user message was persisted under pendingSessionId
-  // before the plugin call. Rekey it to the real session ID now that we
-  // know it. If the plugin never reported a session ID, leave the message
-  // under the pending key so the history isn't lost.
-  const persistSessionId = resolvedSessionId || pendingSessionId
-  try {
-    if (!sessionId && resolvedSessionId && pendingSessionId && pendingSessionId !== resolvedSessionId) {
-      chatStore.rekeySession(pendingSessionId, resolvedSessionId)
-    }
-    if (fullResponse && persistSessionId) {
-      await chatStore.addMessage(persistSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+    if (output?.error) {
+      emit({ type: 'error', error: output.error.message, partial: !!fullResponse })
     }
   } catch (err) {
-    console.error('[Chat] failed to persist assistant message:', err.message)
+    emit({ type: 'error', error: err.message, partial: !!fullResponse })
   }
 
-  if (pluginError) throw pluginError
-
-  let totalTurnCount = turnCount
-  try {
-    const session = await chatStore.load(workspaceId)
-    totalTurnCount = session?.turn_count || turnCount
-  } catch (err) {
-    console.error('[Chat] failed to load session for done event:', err.message)
-  }
-  res.write(`data: ${JSON.stringify({ type: 'done', session_id: resolvedSessionId, turn_count: totalTurnCount })}\n\n`)
+  return { fullResponse, resolvedSessionId, turnCount }
 }
 
-function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
+function invokeViaLegacy(prompt, sessionId, emit, activeRef) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -727,8 +783,6 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
 
     const args = ['-p', '--verbose', '--model', 'sonnet', '--output-format', 'stream-json']
     if (sessionId) args.push('--resume', sessionId)
-    // Prompt is passed via stdin (not as CLI argument) to avoid
-    // shell argument parsing issues with spaces/special characters.
 
     console.log(`[Chat] spawning: ${binary} ${sessionId ? `--resume ${sessionId}` : '(new session)'}`)
 
@@ -739,19 +793,16 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
       shell: true, // Required on Windows to resolve .cmd shims (e.g. claude.cmd)
     })
 
-    activeChatChild = child
-    // Write prompt to stdin and close — claude -p reads from stdin when no positional arg
+    // Expose the child to the run manager for abort. NOT tied to any HTTP request.
+    activeRef.current = child
     child.stdin.write(prompt)
     child.stdin.end()
-
     console.log(`[Chat] child PID: ${child.pid}`)
 
     let fullResponse = ''
     let stderrBuffer = ''
     let lineBuffer = ''
     let resolvedSessionId = sessionId || null
-
-    // Block-type state tracking for correct event forwarding
     let currentBlockType = null  // 'text' | 'tool_use' | null
     let currentToolName = null
     let toolInputBuffer = ''
@@ -767,84 +818,66 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
         try {
           const parsed = JSON.parse(line)
 
-          // system init event — capture session_id
           if (parsed.type === 'system' && parsed.session_id) {
             resolvedSessionId = parsed.session_id
             console.log(`[Chat] session_id: ${resolvedSessionId}`)
           }
 
-          // content_block_start — track block type
           if (parsed.type === 'content_block_start') {
             const blockType = parsed.content_block?.type
             if (blockType === 'tool_use') {
               currentBlockType = 'tool_use'
               currentToolName = parsed.content_block.name || 'unknown'
               toolInputBuffer = ''
-              const event = JSON.stringify({
-                type: 'tool_start',
-                tool: currentToolName,
-              })
-              res.write(`data: ${event}\n\n`)
+              emit({ type: 'tool_start', tool: currentToolName })
             } else if (blockType === 'text') {
               currentBlockType = 'text'
             }
           }
 
-          // content_block_delta — handle both text and tool input
           if (parsed.type === 'content_block_delta') {
             const deltaType = parsed.delta?.type
             if (deltaType === 'input_json_delta' && currentBlockType === 'tool_use') {
               const partial = parsed.delta.partial_json || ''
               if (partial) {
                 toolInputBuffer += partial
-                const event = JSON.stringify({ type: 'tool_input_delta', partial_json: partial })
-                res.write(`data: ${event}\n\n`)
+                emit({ type: 'tool_input_delta', partial_json: partial })
               }
             } else {
               const delta = parsed.delta?.text || ''
               if (delta) {
                 fullResponse += delta
-                const event = JSON.stringify({ type: 'delta', content: delta })
-                res.write(`data: ${event}\n\n`)
+                emit({ type: 'delta', content: delta })
               }
             }
           }
 
-          // content_block_stop — only emit tool_end for tool_use blocks (bug fix)
           if (parsed.type === 'content_block_stop') {
             if (currentBlockType === 'tool_use') {
               let parsedInput = null
               try {
                 if (toolInputBuffer) parsedInput = JSON.parse(toolInputBuffer)
               } catch { /* partial or invalid JSON */ }
-              const event = JSON.stringify({
-                type: 'tool_end',
-                tool: currentToolName,
-                input: parsedInput,
-              })
-              res.write(`data: ${event}\n\n`)
+              emit({ type: 'tool_end', tool: currentToolName, input: parsedInput })
             }
             currentBlockType = null
             currentToolName = null
             toolInputBuffer = ''
           }
 
-          // assistant message — count turns and forward text blocks
           if (parsed.type === 'assistant' && parsed.message) {
             turnCount++
             for (const block of (parsed.message.content || [])) {
               if (block.type === 'text') {
                 fullResponse += block.text
-                res.write(`data: ${JSON.stringify({ type: 'text', content: block.text })}\n\n`)
+                emit({ type: 'text', content: block.text })
               }
             }
           } else if (parsed.type === 'result') {
             const resultText = parsed.result || ''
             if (resultText) {
-              res.write(`data: ${JSON.stringify({ type: 'result', content: resultText })}\n\n`)
-              if (!fullResponse) {
-                fullResponse = resultText
-              }
+              emit({ type: 'result', content: resultText })
+              if (!fullResponse) fullResponse = resultText
             }
           }
         } catch {
@@ -859,61 +892,25 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
       console.error(`[Chat] stderr: ${text}`)
     })
 
-    child.on('close', async (code) => {
-      activeChatChild = null
-
+    child.on('close', (code) => {
+      activeRef.current = null
       console.log(`[Chat] child closed: code=${code}, response=${fullResponse.length}chars, turns=${turnCount}, stderr=${stderrBuffer.length}bytes, session=${resolvedSessionId}`)
       if (stderrBuffer.trim()) {
         console.log(`[Chat] final stderr (tail 500): ${stderrBuffer.slice(-500)}`)
       }
-
-      // For new sessions, the user message was already persisted under
-      // pendingSessionId before spawn. Rekey it to the real session ID when
-      // Claude CLI reported one; otherwise leave the message under the
-      // pending key so the history is never lost on crash.
-      const persistSessionId = resolvedSessionId || pendingSessionId
-      try {
-        if (!sessionId && resolvedSessionId && pendingSessionId && pendingSessionId !== resolvedSessionId) {
-          chatStore.rekeySession(pendingSessionId, resolvedSessionId)
-        }
-        if (fullResponse && persistSessionId) {
-          await chatStore.addMessage(persistSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
-        }
-      } catch (err) {
-        console.error('[Chat] failed to persist assistant message:', err.message)
-      }
-
       if (code !== 0) {
         const errorMsg = stderrBuffer.trim() || `Claude CLI exited with code ${code}`
         console.error(`[Chat] CLI failed (exit ${code}, partial=${!!fullResponse}): ${errorMsg}`)
-        res.write(`data: ${JSON.stringify({
-          type: 'error',
-          error: errorMsg,
-          partial: !!fullResponse,
-          exit_code: code,
-        })}\n\n`)
-      }
-
-      let totalTurnCount = turnCount
-      try {
-        const session = await chatStore.load(workspaceId)
-        totalTurnCount = session?.turn_count || turnCount
-      } catch (err) {
-        console.error('[Chat] failed to load session for done event:', err.message)
+        emit({ type: 'error', error: errorMsg, partial: !!fullResponse, exit_code: code })
       }
-
-      res.write(`data: ${JSON.stringify({ type: 'done', session_id: resolvedSessionId, turn_count: totalTurnCount })}\n\n`)
-      resolve()
+      // Resolve (don't reject) on non-zero exit so the manager persists the
+      // partial response and emits a clean terminal `done`.
+      resolve({ fullResponse, resolvedSessionId, turnCount })
     })
 
     child.on('error', (err) => {
-      activeChatChild = null
-      res.write(`data: ${JSON.stringify({ type: 'error', error: `Failed to start CLI: ${err.message}` })}\n\n`)
-      reject(err)
-    })
-
-    res.on('close', () => {
-      child.kill('SIGTERM')
+      activeRef.current = null
+      reject(new Error(`Failed to start CLI: ${err.message}`))
     })
   })
 }