@geekbeer/minion 4.2.0 → 4.2.1

package/core/stores/chat-store.js

@@ -133,6 +133,7 @@ function save(session) {
  * Add a message to a session.
  * Creates a new session if none exists for the given session_id.
  * Past sessions are preserved (not deleted).
+ * Wrapped in a transaction so partial saves can't happen on failure.
  * @param {string} sessionId - Claude CLI session ID
  * @param {{ role: string, content: string }} msg - Message to add
  * @param {number} [turnCount] - Optional turn count to add
@@ -140,40 +141,71 @@ function save(session) {
  */
 function addMessage(sessionId, msg, turnCount, workspaceId) {
   const db = getDb()
-  const existing = db.prepare('SELECT * FROM chat_sessions WHERE session_id = ?').get(sessionId)
+  const tx = db.transaction(() => {
+    const existing = db.prepare('SELECT session_id FROM chat_sessions WHERE session_id = ?').get(sessionId)
+
+    if (!existing) {
+      const now = Date.now()
+      db.prepare(
+        'INSERT INTO chat_sessions (session_id, workspace_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
+      ).run(sessionId, workspaceId || null, 0, now, now)
+    }
 
-  // If session doesn't exist, create a new one (past sessions remain in DB)
-  if (!existing) {
-    const now = Date.now()
     db.prepare(
-      'INSERT INTO chat_sessions (session_id, workspace_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
-    ).run(sessionId, workspaceId || null, 0, now, now)
-  }
+      'INSERT INTO chat_messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)'
+    ).run(sessionId, msg.role, msg.content, Date.now())
 
-  // Insert message
-  db.prepare(
-    'INSERT INTO chat_messages (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)'
-  ).run(sessionId, msg.role, msg.content, Date.now())
-
-  // Update session metadata
-  const newTurnCount = (turnCount && turnCount > 0) ? turnCount : 0
-  db.prepare(`
-    UPDATE chat_sessions
-    SET updated_at = ?,
-        turn_count = turn_count + ?
-    WHERE session_id = ?
-  `).run(Date.now(), newTurnCount, sessionId)
-
-  // Prune old messages for this session (keep only MAX_MESSAGES most recent)
-  const count = db.prepare('SELECT COUNT(*) as cnt FROM chat_messages WHERE session_id = ?').get(sessionId).cnt
-  if (count > MAX_MESSAGES) {
+    const newTurnCount = (turnCount && turnCount > 0) ? turnCount : 0
     db.prepare(`
-      DELETE FROM chat_messages WHERE id IN (
-        SELECT id FROM chat_messages WHERE session_id = ?
-        ORDER BY id ASC LIMIT ?
-      )
-    `).run(sessionId, count - MAX_MESSAGES)
-  }
+      UPDATE chat_sessions
+      SET updated_at = ?,
+          turn_count = turn_count + ?
+      WHERE session_id = ?
+    `).run(Date.now(), newTurnCount, sessionId)
+
+    const count = db.prepare('SELECT COUNT(*) as cnt FROM chat_messages WHERE session_id = ?').get(sessionId).cnt
+    if (count > MAX_MESSAGES) {
+      db.prepare(`
+        DELETE FROM chat_messages WHERE id IN (
+          SELECT id FROM chat_messages WHERE session_id = ?
+          ORDER BY id ASC LIMIT ?
+        )
+      `).run(sessionId, count - MAX_MESSAGES)
+    }
+  })
+  tx()
+}
+
+/**
+ * Rename a session's ID, carrying over all messages.
+ * Used when a pending session ID (generated locally before the LLM call) is
+ * replaced by the real session_id returned by Claude CLI.
+ * If `newSessionId` already exists, messages from `oldSessionId` are merged
+ * into it and the old session row is dropped.
+ * @param {string} oldSessionId
+ * @param {string} newSessionId
+ * @returns {boolean} true if any rows were touched
+ */
+function rekeySession(oldSessionId, newSessionId) {
+  if (!oldSessionId || !newSessionId || oldSessionId === newSessionId) return false
+  const db = getDb()
+  const tx = db.transaction(() => {
+    const oldSession = db.prepare('SELECT * FROM chat_sessions WHERE session_id = ?').get(oldSessionId)
+    if (!oldSession) return false
+
+    const existingNew = db.prepare('SELECT session_id FROM chat_sessions WHERE session_id = ?').get(newSessionId)
+    if (existingNew) {
+      db.prepare('UPDATE chat_messages SET session_id = ? WHERE session_id = ?').run(newSessionId, oldSessionId)
+      db.prepare('UPDATE chat_sessions SET updated_at = ?, turn_count = turn_count + ? WHERE session_id = ?')
+        .run(Date.now(), oldSession.turn_count || 0, newSessionId)
+      db.prepare('DELETE FROM chat_sessions WHERE session_id = ?').run(oldSessionId)
+    } else {
+      db.prepare('UPDATE chat_sessions SET session_id = ? WHERE session_id = ?').run(newSessionId, oldSessionId)
+      db.prepare('UPDATE chat_messages SET session_id = ? WHERE session_id = ?').run(newSessionId, oldSessionId)
+    }
+    return true
+  })
+  return tx() === true
 }
 
 /**
@@ -208,4 +240,4 @@ function deleteSession(sessionId) {
   return result.changes > 0
 }
 
-module.exports = { load, loadById, listSessions, save, addMessage, clear, deleteSession }
+module.exports = { load, loadById, listSessions, save, addMessage, rekeySession, clear, deleteSession }

package/linux/routes/chat.js

@@ -17,6 +17,7 @@
  */
 
 const { spawn } = require('child_process')
+const crypto = require('crypto')
 const fs = require('fs')
 const path = require('path')
 const { verifyToken } = require('../../core/lib/auth')
@@ -57,10 +58,16 @@ async function chatRoutes(fastify) {
     // 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)
 
-    // Store user message
+    // Persist the user message BEFORE invoking the LLM so that crashes,
+    // timeouts, or unparseable CLI output can't lose it. For new sessions we
+    // mint a local pending ID; it gets rekeyed to the real Claude CLI session
+    // ID once that comes back on the SSE stream.
     const currentSessionId = session_id || null
-    if (currentSessionId) {
-      await chatStore.addMessage(currentSessionId, { role: 'user', content: message }, undefined, workspaceId)
+    const pendingSessionId = currentSessionId || `pending-${crypto.randomUUID()}`
+    try {
+      await chatStore.addMessage(pendingSessionId, { role: 'user', content: message }, undefined, workspaceId)
+    } catch (err) {
+      console.error('[Chat] failed to persist user message:', err.message)
     }
 
     // Take over response handling from Fastify for SSE streaming
@@ -74,7 +81,7 @@ async function chatRoutes(fastify) {
     reply.raw.flushHeaders()
 
     try {
-      await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message)
+      await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message, pendingSessionId)
     } catch (err) {
       console.error('[Chat] stream error:', err.message)
       const errorEvent = JSON.stringify({ type: 'error', error: err.message })
@@ -541,16 +548,16 @@ function getLlmBinary() {
  * Tracks block types to correctly forward tool_use vs text events
  * and counts turns for session management.
  */
-async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage) {
+async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   // Plugin system path: Primary is set → delegate to plugin
   const primary = getActivePrimary()
   if (primary) {
-    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage)
+    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
   }
-  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage)
+  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
 }
 
-async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage) {
+async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   const input = { prompt }
   const activeRef = { current: null }
   activeChatChild = { kill: () => activeRef.current?.kill?.('SIGTERM') }
@@ -576,6 +583,7 @@ async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, orig
 
   res.on('close', () => { activeRef.current?.kill?.('SIGTERM') })
 
+  let pluginError = null
   try {
     let output
     if (plugin.capabilities.streaming && typeof plugin.stream === 'function') {
@@ -592,25 +600,42 @@ async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, orig
       }
     }
     resolvedSessionId = output?.metadata?.sessionId || resolvedSessionId
+  } catch (err) {
+    // Swallow here so we can persist any partial response first; rethrow below.
+    pluginError = err
   } finally {
     activeChatChild = null
   }
 
-  if (resolvedSessionId) {
-    if (!sessionId) {
-      await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
+  // 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) {
-      await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+    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)
   }
 
-  const session = await chatStore.load(workspaceId)
-  const totalTurnCount = session?.turn_count || turnCount
+  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`)
 }
 
-function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage) {
+function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -786,16 +811,21 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
         console.log(`[Chat] final stderr (tail 500): ${stderrBuffer.slice(-500)}`)
       }
 
-      // Store messages in chat-store
-      if (resolvedSessionId) {
-        // If this was a new session, also store the user message now
-        if (!sessionId) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
+      // 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)
         }
-        // Store assistant response with turn count
-        if (fullResponse) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+        // Persist any partial response we managed to collect, even on error
+        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) {
@@ -811,8 +841,13 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
       }
 
       // Load current turn count from session for the done event
-      const session = await chatStore.load(workspaceId)
-      const totalTurnCount = session?.turn_count || turnCount
+      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)
+      }
 
       const doneEvent = JSON.stringify({
         type: 'done',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {

package/win/routes/chat.js

@@ -13,6 +13,7 @@
  */
 
 const { spawn } = require('child_process')
+const crypto = require('crypto')
 const fs = require('fs')
 const path = require('path')
 const http = require('http')
@@ -130,8 +131,19 @@ async function chatRoutes(fastify) {
     const prompt = await buildContextPrefix(message, context, session_id, workspaceId, referenced_tasks)
     const currentSessionId = session_id || null
 
-    if (currentSessionId) {
-      await chatStore.addMessage(currentSessionId, { role: 'user', content: message }, undefined, workspaceId)
+    // Persist the user message BEFORE invoking the LLM so that crashes,
+    // timeouts, or unparseable CLI output can't lose it. New sessions get a
+    // local pending ID; it gets rekeyed to the real Claude CLI session ID
+    // once that comes back on the SSE stream.
+    // In WSL mode the upstream WSL session server keeps its own store, so we
+    // only persist locally for existing sessions (matching prior behavior).
+    const pendingSessionId = currentSessionId || `pending-${crypto.randomUUID()}`
+    if (!wsl_mode || currentSessionId) {
+      try {
+        await chatStore.addMessage(pendingSessionId, { role: 'user', content: message }, undefined, workspaceId)
+      } catch (err) {
+        console.error('[Chat] failed to persist user message:', err.message)
+      }
     }
 
     reply.hijack()
@@ -149,7 +161,7 @@ async function chatRoutes(fastify) {
         await proxyWslChat(reply.raw, prompt, currentSessionId)
         wslModeActive = false
       } else {
-        await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message)
+        await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message, pendingSessionId)
       }
     } catch (err) {
       wslModeActive = false
@@ -594,15 +606,15 @@ function getLlmBinary() {
  * Tracks block types to correctly forward tool_use vs text events
  * and counts turns for session management.
  */
-async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage) {
+async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   const primary = getActivePrimary()
   if (primary) {
-    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage)
+    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
   }
-  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage)
+  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
 }
 
-async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage) {
+async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   const input = { prompt }
   const activeRef = { current: null }
 
@@ -627,37 +639,57 @@ async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, orig
 
   res.on('close', () => { activeRef.current?.kill?.('SIGTERM') })
 
-  let output
-  if (plugin.capabilities.streaming && typeof plugin.stream === 'function') {
-    output = await plugin.stream(input, emit, { 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`)
-      turnCount = 1
-    }
-    if (output.error) {
-      res.write(`data: ${JSON.stringify({ type: 'error', error: output.error.message })}\n\n`)
+  let pluginError = null
+  try {
+    let output
+    if (plugin.capabilities.streaming && typeof plugin.stream === 'function') {
+      output = await plugin.stream(input, emit, { 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`)
+        turnCount = 1
+      }
+      if (output.error) {
+        res.write(`data: ${JSON.stringify({ type: 'error', error: output.error.message })}\n\n`)
+      }
     }
+    resolvedSessionId = output?.metadata?.sessionId || resolvedSessionId
+  } catch (err) {
+    // Swallow here so we can persist any partial response first; rethrow below.
+    pluginError = err
   }
-  resolvedSessionId = output?.metadata?.sessionId || resolvedSessionId
 
-  if (resolvedSessionId) {
-    if (!sessionId) {
-      await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
+  // 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) {
-      await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+    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)
   }
 
-  const session = await chatStore.load(workspaceId)
-  const totalTurnCount = session?.turn_count || turnCount
+  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`)
 }
 
-function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage) {
+function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -809,14 +841,22 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
         console.log(`[Chat] final stderr (tail 500): ${stderrBuffer.slice(-500)}`)
       }
 
-      if (resolvedSessionId) {
-        if (!sessionId) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
+      // 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) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+        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}`)
@@ -828,8 +868,13 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
         })}\n\n`)
       }
 
-      const session = await chatStore.load(workspaceId)
-      const totalTurnCount = session?.turn_count || turnCount
+      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`)
       resolve()