agentgui 1.0.153 → 1.0.155

package/database.js

@@ -430,6 +430,17 @@ export const queries = {
      });
    },
 
+  getLastUserMessage(conversationId) {
+    const stmt = prep(
+      "SELECT * FROM messages WHERE conversationId = ? AND role = 'user' ORDER BY created_at DESC LIMIT 1"
+    );
+    const msg = stmt.get(conversationId);
+    if (msg && typeof msg.content === 'string') {
+      try { msg.content = JSON.parse(msg.content); } catch (_) {}
+    }
+    return msg || null;
+  },
+
   getPaginatedMessages(conversationId, limit = 50, offset = 0) {
     const countStmt = prep('SELECT COUNT(*) as count FROM messages WHERE conversationId = ?');
     const total = countStmt.get(conversationId).count;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.153",
+  "version": "1.0.155",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -1228,29 +1228,75 @@ function recoverStaleSessions() {
   try {
     const staleSessions = queries.getActiveSessions ? queries.getActiveSessions() : [];
     const now = Date.now();
-    let recoveredCount = 0;
+    let resumedCount = 0;
+    let failedCount = 0;
+
     for (const session of staleSessions) {
       if (activeExecutions.has(session.conversationId)) continue;
       const sessionAge = now - session.started_at;
       if (sessionAge < STALE_SESSION_MIN_AGE_MS) continue;
+
       queries.updateSession(session.id, {
         status: 'error',
-        error: 'Agent died unexpectedly (server restart)',
+        error: 'Server restarted - resuming',
         completed_at: now
       });
-      queries.setIsStreaming(session.conversationId, false);
+
+      const conv = queries.getConversation(session.conversationId);
+      if (!conv) {
+        queries.setIsStreaming(session.conversationId, false);
+        failedCount++;
+        continue;
+      }
+
+      const lastMsg = queries.getLastUserMessage(session.conversationId);
+      if (!lastMsg || !conv.claudeSessionId) {
+        queries.setIsStreaming(session.conversationId, false);
+        debugLog(`[RECOVERY] Conv ${session.conversationId}: no user message or no claudeSessionId, cannot resume`);
+        broadcastSync({
+          type: 'streaming_error',
+          sessionId: session.id,
+          conversationId: session.conversationId,
+          error: 'Server restarted - could not resume (missing context)',
+          recoverable: false,
+          timestamp: now
+        });
+        failedCount++;
+        continue;
+      }
+
+      const content = typeof lastMsg.content === 'string' ? lastMsg.content : JSON.stringify(lastMsg.content);
+      const agentId = conv.agentType || conv.agentId || 'claude-code';
+
+      debugLog(`[RECOVERY] Resuming conv ${session.conversationId} with claudeSessionId=${conv.claudeSessionId}`);
+
+      const newSession = queries.createSession(session.conversationId);
+      queries.createEvent('session.created', {
+        messageId: lastMsg.id,
+        sessionId: newSession.id,
+        retryReason: 'server_restart'
+      }, session.conversationId, newSession.id);
+
       broadcastSync({
-        type: 'streaming_error',
-        sessionId: session.id,
+        type: 'streaming_start',
+        sessionId: newSession.id,
         conversationId: session.conversationId,
-        error: 'Agent died unexpectedly (server restart)',
-        recoverable: false,
+        messageId: lastMsg.id,
+        agentId,
         timestamp: now
       });
-      recoveredCount++;
+
+      processMessageWithStreaming(session.conversationId, lastMsg.id, newSession.id, content, agentId)
+        .catch(err => debugLog(`[RECOVERY] Resume error for ${session.conversationId}: ${err.message}`));
+
+      resumedCount++;
+    }
+
+    if (resumedCount > 0) {
+      console.log(`[RECOVERY] Resumed ${resumedCount} conversation(s) from previous run`);
     }
-    if (recoveredCount > 0) {
-      console.log(`[RECOVERY] Recovered ${recoveredCount} stale active session(s)`);
+    if (failedCount > 0) {
+      console.log(`[RECOVERY] Failed to resume ${failedCount} conversation(s)`);
     }
   } catch (err) {
     console.error('[RECOVERY] Stale session recovery error:', err.message);

package/static/js/client.js

@@ -609,8 +609,8 @@ class AgentGUIClient {
     console.log('Streaming completed:', data);
 
     const conversationId = data.conversationId || this.state.currentSession?.conversationId;
+    if (conversationId) this.invalidateCache(conversationId);
 
-    // If this event is for a conversation we are NOT currently viewing, just track state
     if (conversationId && this.state.currentConversation?.id !== conversationId) {
       console.log('Streaming completed for non-active conversation:', conversationId);
       this.emit('streaming:complete', data);
@@ -1243,11 +1243,34 @@ class AgentGUIClient {
     }
   }
 
+  cacheCurrentConversation() {
+    const convId = this.state.currentConversation?.id;
+    if (!convId) return;
+    const outputEl = document.getElementById('output');
+    if (!outputEl || !outputEl.firstChild) return;
+    if (this.state.isStreaming) return;
+
+    this.saveScrollPosition(convId);
+    const clone = outputEl.cloneNode(true);
+    this.conversationCache.set(convId, {
+      dom: clone,
+      conversation: this.state.currentConversation,
+      timestamp: Date.now()
+    });
+
+    if (this.conversationCache.size > this.MAX_CACHE_SIZE) {
+      const oldest = this.conversationCache.keys().next().value;
+      this.conversationCache.delete(oldest);
+    }
+  }
+
+  invalidateCache(conversationId) {
+    this.conversationCache.delete(conversationId);
+  }
+
   async loadConversationMessages(conversationId) {
     try {
-      if (this.state.currentConversation?.id) {
-        this.saveScrollPosition(this.state.currentConversation.id);
-      }
+      this.cacheCurrentConversation();
       this.stopChunkPolling();
       if (this.state.isStreaming && this.state.currentConversation?.id !== conversationId) {
         this.state.isStreaming = false;
@@ -1259,9 +1282,27 @@ class AgentGUIClient {
         this.wsManager.sendMessage({ type: 'subscribe', conversationId });
       }
 
+      const cached = this.conversationCache.get(conversationId);
+      if (cached && (Date.now() - cached.timestamp) < 120000) {
+        const outputEl = document.getElementById('output');
+        if (outputEl) {
+          outputEl.innerHTML = '';
+          while (cached.dom.firstChild) {
+            outputEl.appendChild(cached.dom.firstChild);
+          }
+          this.state.currentConversation = cached.conversation;
+          this.conversationCache.delete(conversationId);
+          this.restoreScrollPosition(conversationId);
+          this.enableControls();
+          return;
+        }
+      }
+
+      this.conversationCache.delete(conversationId);
+
       const resp = await fetch(window.__BASE_URL + `/api/conversations/${conversationId}/full`);
       if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-      const { conversation, isActivelyStreaming, latestSession, chunks: rawChunks, messages: allMessages } = await resp.json();
+      const { conversation, isActivelyStreaming, latestSession, chunks: rawChunks, totalChunks, messages: allMessages } = await resp.json();
 
       this.state.currentConversation = conversation;
 
@@ -1270,6 +1311,7 @@ class AgentGUIClient {
         block: typeof chunk.data === 'string' ? JSON.parse(chunk.data) : chunk.data
       }));
       const userMessages = (allMessages || []).filter(m => m.role === 'user');
+      const hasMoreChunks = totalChunks && chunks.length < totalChunks;
 
       const shouldResumeStreaming = isActivelyStreaming && latestSession &&
         (latestSession.status === 'active' || latestSession.status === 'pending');
@@ -1286,6 +1328,29 @@ class AgentGUIClient {
         `;
 
         const messagesEl = outputEl.querySelector('.conversation-messages');
+
+        if (hasMoreChunks) {
+          const loadMoreBtn = document.createElement('button');
+          loadMoreBtn.className = 'btn btn-secondary';
+          loadMoreBtn.style.cssText = 'width:100%;margin-bottom:1rem;padding:0.5rem;font-size:0.8rem;';
+          loadMoreBtn.textContent = `Load earlier messages (${totalChunks - chunks.length} more chunks)`;
+          loadMoreBtn.addEventListener('click', async () => {
+            loadMoreBtn.disabled = true;
+            loadMoreBtn.textContent = 'Loading...';
+            try {
+              const fullResp = await fetch(window.__BASE_URL + `/api/conversations/${conversationId}/full?allChunks=1`);
+              if (fullResp.ok) {
+                this.invalidateCache(conversationId);
+                await this.loadConversationMessages(conversationId);
+              }
+            } catch (e) {
+              loadMoreBtn.textContent = 'Failed to load. Try again.';
+              loadMoreBtn.disabled = false;
+            }
+          });
+          messagesEl.appendChild(loadMoreBtn);
+        }
+
         if (chunks.length > 0) {
           const sessionOrder = [];
           const sessionChunks = {};
@@ -1299,6 +1364,14 @@ class AgentGUIClient {
 
           const frag = document.createDocumentFragment();
           let userMsgIdx = 0;
+
+          if (hasMoreChunks && sessionOrder.length > 0) {
+            const firstChunkTime = chunks[0].created_at;
+            while (userMsgIdx < userMessages.length && userMessages[userMsgIdx].created_at < firstChunkTime) {
+              userMsgIdx++;
+            }
+          }
+
           sessionOrder.forEach((sessionId) => {
             const sessionChunkList = sessionChunks[sessionId];
             const sessionStart = sessionChunkList[0].created_at;