agentgui 1.0.154 → 1.0.156

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.154",
+  "version": "1.0.156",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -27,7 +27,6 @@ const messageQueues = new Map();
 const rateLimitState = new Map();
 const STUCK_AGENT_THRESHOLD_MS = 600000;
 const NO_PID_GRACE_PERIOD_MS = 60000;
-const STALE_SESSION_MIN_AGE_MS = 30000;
 const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 60000;
 
 const debugLog = (msg) => {
@@ -231,10 +230,8 @@ const server = http.createServer(async (req, res) => {
         const conv = queries.getConversation(convMatch[1]);
         if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
 
-        // Check both in-memory and database for active streaming status
         const latestSession = queries.getLatestSession(convMatch[1]);
-        const isActivelyStreaming = activeExecutions.has(convMatch[1]) ||
-          (latestSession && latestSession.status === 'active');
+        const isActivelyStreaming = activeExecutions.has(convMatch[1]);
 
                 sendJSON(req, res, 200, {
           conversation: conv,
@@ -279,17 +276,41 @@ const server = http.createServer(async (req, res) => {
         const conv = queries.getConversation(conversationId);
         if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
         const body = await parseBody(req);
+        const agentId = body.agentId || conv.agentType || conv.agentId || 'claude-code';
         const idempotencyKey = body.idempotencyKey || null;
         const message = queries.createMessage(conversationId, 'user', body.content, idempotencyKey);
         queries.createEvent('message.created', { role: 'user', messageId: message.id }, conversationId);
         broadcastSync({ type: 'message_created', conversationId, message, timestamp: Date.now() });
+
+        if (activeExecutions.has(conversationId)) {
+          if (!messageQueues.has(conversationId)) messageQueues.set(conversationId, []);
+          messageQueues.get(conversationId).push({ content: body.content, agentId, messageId: message.id });
+          const queueLength = messageQueues.get(conversationId).length;
+          broadcastSync({ type: 'queue_status', conversationId, queueLength, messageId: message.id, timestamp: Date.now() });
+          sendJSON(req, res, 200, { message, queued: true, queuePosition: queueLength, idempotencyKey });
+          return;
+        }
+
         const session = queries.createSession(conversationId);
         queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, conversationId, session.id);
-                  sendJSON(req, res, 201, { message, session, idempotencyKey });
-         // Fire-and-forget with proper error handling
-         processMessage(conversationId, message.id, body.content, body.agentId)
-           .catch(err => debugLog(`[processMessage] Uncaught error: ${err.message}`));
-         return;
+
+        activeExecutions.set(conversationId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
+        queries.setIsStreaming(conversationId, true);
+
+        broadcastSync({
+          type: 'streaming_start',
+          sessionId: session.id,
+          conversationId,
+          messageId: message.id,
+          agentId,
+          timestamp: Date.now()
+        });
+
+        sendJSON(req, res, 201, { message, session, idempotencyKey });
+
+        processMessageWithStreaming(conversationId, message.id, session.id, body.content, agentId)
+          .catch(err => debugLog(`[messages] Uncaught error: ${err.message}`));
+        return;
       }
     }
 
@@ -323,7 +344,8 @@ const server = http.createServer(async (req, res) => {
       const session = queries.createSession(conversationId);
       queries.createEvent('session.created', { messageId: userMessage.id, sessionId: session.id }, conversationId, session.id);
 
-            sendJSON(req, res, 200, { message: userMessage, session, streamId: session.id });
+      activeExecutions.set(conversationId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
+      queries.setIsStreaming(conversationId, true);
 
       broadcastSync({
         type: 'streaming_start',
@@ -334,6 +356,8 @@ const server = http.createServer(async (req, res) => {
         timestamp: Date.now()
       });
 
+      sendJSON(req, res, 200, { message: userMessage, session, streamId: session.id });
+
       processMessageWithStreaming(conversationId, userMessage.id, session.id, prompt, agentId)
         .catch(err => debugLog(`[stream] Uncaught error: ${err.message}`));
       return;
@@ -362,8 +386,7 @@ const server = http.createServer(async (req, res) => {
       const conv = queries.getConversation(conversationId);
       if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
       const latestSession = queries.getLatestSession(conversationId);
-      const isActivelyStreaming = activeExecutions.has(conversationId) ||
-        (latestSession && latestSession.status === 'active');
+      const isActivelyStreaming = activeExecutions.has(conversationId);
 
       const url = new URL(req.url, 'http://localhost');
       const chunkLimit = Math.min(parseInt(url.searchParams.get('chunkLimit') || '500'), 5000);
@@ -896,8 +919,6 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
       });
 
       batcher.drain();
-      activeExecutions.delete(conversationId);
-      queries.setIsStreaming(conversationId, false);
 
       setTimeout(() => {
         rateLimitState.delete(conversationId);
@@ -987,54 +1008,6 @@ function drainMessageQueue(conversationId) {
     .catch(err => debugLog(`[queue] Error processing queued message: ${err.message}`));
 }
 
-async function processMessage(conversationId, messageId, content, agentId) {
-  try {
-    debugLog(`[processMessage] Starting: conversationId=${conversationId}, agentId=${agentId}`);
-
-    const conv = queries.getConversation(conversationId);
-    const cwd = conv?.workingDirectory || STARTUP_CWD;
-    const resumeSessionId = conv?.claudeSessionId || null;
-
-    let contentStr = typeof content === 'object' ? JSON.stringify(content) : content;
-
-    const { outputs, sessionId: claudeSessionId } = await runClaudeWithStreaming(contentStr, cwd, agentId || 'claude-code', {
-      resumeSessionId,
-      systemPrompt: SYSTEM_PROMPT
-    });
-
-    if (claudeSessionId) {
-      queries.setClaudeSessionId(conversationId, claudeSessionId);
-    }
-
-    let allBlocks = [];
-    for (const output of outputs) {
-      if (output.type === 'assistant' && output.message?.content) {
-        allBlocks.push(...(output.message.content || []));
-      }
-    }
-
-    let messageContent = null;
-    if (allBlocks.length > 0) {
-      messageContent = JSON.stringify({ type: 'claude_execution', blocks: allBlocks, timestamp: Date.now() });
-    } else {
-      let textParts = [];
-      for (const output of outputs) {
-        if (output.type === 'result' && output.result) textParts.push(String(output.result));
-        else if (typeof output === 'string') textParts.push(output);
-      }
-      messageContent = textParts.join('\n').trim();
-    }
-
-    if (messageContent) {
-      const assistantMessage = queries.createMessage(conversationId, 'assistant', messageContent);
-      broadcastSync({ type: 'message_created', conversationId, message: assistantMessage, timestamp: Date.now() });
-    }
-  } catch (error) {
-    debugLog(`[processMessage] Error: ${error.message}`);
-    const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
-    broadcastSync({ type: 'message_created', conversationId, message: errorMessage, timestamp: Date.now() });
-  }
-}
 
 const wss = new WebSocketServer({
   server,
@@ -1128,10 +1101,10 @@ wss.on('connection', (ws, req) => {
 });
 
 const BROADCAST_TYPES = new Set([
-  'message_created', 'conversation_created', 'conversations_updated',
-  'conversation_deleted', 'queue_status', 'streaming_start',
-  'streaming_complete', 'streaming_error', 'rate_limit_hit',
-  'rate_limit_clear'
+  'message_created', 'conversation_created', 'conversation_updated',
+  'conversations_updated', 'conversation_deleted', 'queue_status',
+  'streaming_start', 'streaming_complete', 'streaming_error',
+  'rate_limit_hit', 'rate_limit_clear'
 ]);
 
 const wsBatchQueues = new Map();
@@ -1228,29 +1201,73 @@ 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

@@ -24,7 +24,7 @@ class AgentGUIClient {
       isInitialized: false,
       currentSession: null,
       currentConversation: null,
-      isStreaming: false,
+      streamingConversations: new Map(),
       sessionEvents: [],
       conversations: [],
       agents: []
@@ -405,11 +405,12 @@ class AgentGUIClient {
     // just track the state but do not modify the DOM or start polling
     if (this.state.currentConversation?.id !== data.conversationId) {
       console.log('Streaming started for non-active conversation:', data.conversationId);
+      this.state.streamingConversations.set(data.conversationId, true);
       this.emit('streaming:start', data);
       return;
     }
 
-    this.state.isStreaming = true;
+    this.state.streamingConversations.set(data.conversationId, true);
     this.state.currentSession = {
       id: data.sessionId,
       conversationId: data.conversationId,
@@ -583,11 +584,12 @@ class AgentGUIClient {
     // 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 error for non-active conversation:', conversationId);
+      this.state.streamingConversations.delete(conversationId);
       this.emit('streaming:error', data);
       return;
     }
 
-    this.state.isStreaming = false;
+    this.state.streamingConversations.delete(conversationId);
 
     // Stop polling for chunks
     this.stopChunkPolling();
@@ -613,11 +615,12 @@ class AgentGUIClient {
 
     if (conversationId && this.state.currentConversation?.id !== conversationId) {
       console.log('Streaming completed for non-active conversation:', conversationId);
+      this.state.streamingConversations.delete(conversationId);
       this.emit('streaming:complete', data);
       return;
     }
 
-    this.state.isStreaming = false;
+    this.state.streamingConversations.delete(conversationId);
 
     // Stop polling for chunks
     this.stopChunkPolling();
@@ -662,7 +665,7 @@ class AgentGUIClient {
       return;
     }
 
-    if (data.message.role === 'assistant' && this.state.isStreaming) {
+    if (data.message.role === 'assistant' && this.state.streamingConversations.has(data.conversationId)) {
       this.emit('message:created', data);
       return;
     }
@@ -707,15 +710,21 @@ class AgentGUIClient {
 
   handleRateLimitHit(data) {
     if (data.conversationId !== this.state.currentConversation?.id) return;
-    this.state.isStreaming = false;
+    this.state.streamingConversations.delete(data.conversationId);
     this.stopChunkPolling();
+    this.enableControls();
+
+    const cooldownMs = data.retryAfterMs || 60000;
+    this._rateLimitSafetyTimer = setTimeout(() => {
+      this.enableControls();
+    }, cooldownMs + 10000);
 
     const sessionId = data.sessionId || this.state.currentSession?.id;
     const streamingEl = document.getElementById(`streaming-${sessionId}`);
     if (streamingEl) {
       const indicator = streamingEl.querySelector('.streaming-indicator');
       if (indicator) {
-        const retrySeconds = Math.ceil((data.retryAfterMs || 60000) / 1000);
+        const retrySeconds = Math.ceil(cooldownMs / 1000);
         indicator.innerHTML = `<span style="color:var(--color-warning);">Rate limited. Retrying in ${retrySeconds}s...</span>`;
         let remaining = retrySeconds;
         const countdownTimer = setInterval(() => {
@@ -733,6 +742,10 @@ class AgentGUIClient {
 
   handleRateLimitClear(data) {
     if (data.conversationId !== this.state.currentConversation?.id) return;
+    if (this._rateLimitSafetyTimer) {
+      clearTimeout(this._rateLimitSafetyTimer);
+      this._rateLimitSafetyTimer = null;
+    }
     this.enableControls();
   }
 
@@ -1012,35 +1025,46 @@ class AgentGUIClient {
     pollState.lastFetchTimestamp = Date.now();
     pollState.backoffDelay = 150;
     pollState.sessionCheckCounter = 0;
+    pollState.emptyPollCount = 0;
+
+    const checkSessionStatus = async () => {
+      if (!this.state.currentSession?.id) return false;
+      const sessionResponse = await fetch(`${window.__BASE_URL}/api/sessions/${this.state.currentSession.id}`);
+      if (!sessionResponse.ok) return false;
+      const { session } = await sessionResponse.json();
+      if (session && (session.status === 'complete' || session.status === 'error')) {
+        if (session.status === 'complete') {
+          this.handleStreamingComplete({ sessionId: session.id, conversationId, timestamp: Date.now() });
+        } else {
+          this.handleStreamingError({ sessionId: session.id, conversationId, error: session.error || 'Unknown error', timestamp: Date.now() });
+        }
+        return true;
+      }
+      return false;
+    };
 
     const pollOnce = async () => {
       if (!pollState.isPolling) return;
 
       try {
         pollState.sessionCheckCounter++;
-        if (pollState.sessionCheckCounter % 10 === 0 && this.state.currentSession?.id) {
-          const sessionResponse = await fetch(`${window.__BASE_URL}/api/sessions/${this.state.currentSession.id}`);
-          if (sessionResponse.ok) {
-            const { session } = await sessionResponse.json();
-            if (session && (session.status === 'complete' || session.status === 'error')) {
-              if (session.status === 'complete') {
-                this.handleStreamingComplete({ sessionId: session.id, conversationId, timestamp: Date.now() });
-              } else {
-                this.handleStreamingError({ sessionId: session.id, conversationId, error: session.error || 'Unknown error', timestamp: Date.now() });
-              }
-              return;
-            }
-          }
+        const shouldCheckSession = pollState.sessionCheckCounter % 3 === 0 || pollState.emptyPollCount >= 3;
+        if (shouldCheckSession) {
+          const done = await checkSessionStatus();
+          if (done) return;
+          if (pollState.emptyPollCount >= 3) pollState.emptyPollCount = 0;
         }
 
         const chunks = await this.fetchChunks(conversationId, pollState.lastFetchTimestamp);
 
         if (chunks.length > 0) {
           pollState.backoffDelay = 150;
+          pollState.emptyPollCount = 0;
           const lastChunk = chunks[chunks.length - 1];
           pollState.lastFetchTimestamp = lastChunk.created_at;
           this.renderChunkBatch(chunks.filter(c => c.block && c.block.type));
         } else {
+          pollState.emptyPollCount++;
           pollState.backoffDelay = Math.min(pollState.backoffDelay + 50, 500);
         }
 
@@ -1248,7 +1272,7 @@ class AgentGUIClient {
     if (!convId) return;
     const outputEl = document.getElementById('output');
     if (!outputEl || !outputEl.firstChild) return;
-    if (this.state.isStreaming) return;
+    if (this.state.streamingConversations.has(convId)) return;
 
     this.saveScrollPosition(convId);
     const clone = outputEl.cloneNode(true);
@@ -1272,8 +1296,7 @@ class AgentGUIClient {
     try {
       this.cacheCurrentConversation();
       this.stopChunkPolling();
-      if (this.state.isStreaming && this.state.currentConversation?.id !== conversationId) {
-        this.state.isStreaming = false;
+      if (this.state.currentConversation?.id !== conversationId) {
         this.state.currentSession = null;
       }
 
@@ -1313,7 +1336,8 @@ class AgentGUIClient {
       const userMessages = (allMessages || []).filter(m => m.role === 'user');
       const hasMoreChunks = totalChunks && chunks.length < totalChunks;
 
-      const shouldResumeStreaming = isActivelyStreaming && latestSession &&
+      const clientKnowsStreaming = this.state.streamingConversations.has(conversationId);
+      const shouldResumeStreaming = (isActivelyStreaming || clientKnowsStreaming) && latestSession &&
         (latestSession.status === 'active' || latestSession.status === 'pending');
 
       const outputEl = document.getElementById('output');
@@ -1444,7 +1468,7 @@ class AgentGUIClient {
         }
 
         if (shouldResumeStreaming && latestSession) {
-          this.state.isStreaming = true;
+          this.state.streamingConversations.set(conversationId, true);
           this.state.currentSession = {
             id: latestSession.id,
             conversationId: conversationId,

package/static/js/conversations.js

@@ -218,10 +218,11 @@ class ConversationManager {
       const data = await res.json();
       this.conversations = data.conversations || [];
 
-      // Seed streaming state from database isStreaming flag
       for (const conv of this.conversations) {
         if (conv.isStreaming === 1 || conv.isStreaming === true) {
           this.streamingConversations.add(conv.id);
+        } else {
+          this.streamingConversations.delete(conv.id);
         }
       }
 
@@ -272,7 +273,7 @@ class ConversationManager {
     const isActive = conv.id === this.activeId;
     el.classList.toggle('active', isActive);
 
-    const isStreaming = conv.isStreaming === 1 || conv.isStreaming === true || this.streamingConversations?.has(conv.id);
+    const isStreaming = this.streamingConversations.has(conv.id);
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';
     const agent = conv.agentType || 'unknown';
@@ -298,7 +299,7 @@ class ConversationManager {
     li.dataset.convId = conv.id;
     if (conv.id === this.activeId) li.classList.add('active');
 
-    const isStreaming = conv.isStreaming === 1 || conv.isStreaming === true || this.streamingConversations?.has(conv.id);
+    const isStreaming = this.streamingConversations.has(conv.id);
 
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';

package/static/js/websocket-manager.js

@@ -26,6 +26,7 @@ class WebSocketManager {
     this.requestMap = new Map();
     this.heartbeatTimer = null;
     this.connectionState = 'disconnected';
+    this.activeSubscriptions = new Set();
 
     // Statistics
     this.stats = {
@@ -124,11 +125,10 @@ class WebSocketManager {
 
     // Flush buffered messages
     this.flushMessageBuffer();
+    this.resubscribeAll();
 
-    // Start heartbeat
     this.startHeartbeat();
 
-    // Emit connected event
     this.emit('connected', { timestamp: Date.now() });
   }
 
@@ -271,8 +271,15 @@ class WebSocketManager {
       throw new Error('Invalid message data');
     }
 
+    if (data.type === 'subscribe') {
+      const key = data.sessionId ? `session:${data.sessionId}` : `conv:${data.conversationId}`;
+      this.activeSubscriptions.add(key);
+    } else if (data.type === 'unsubscribe') {
+      const key = data.sessionId ? `session:${data.sessionId}` : `conv:${data.conversationId}`;
+      this.activeSubscriptions.delete(key);
+    }
+
     if (!this.isConnected) {
-      // Buffer message if not connected
       this.bufferMessage(data);
       return false;
     }
@@ -335,6 +342,19 @@ class WebSocketManager {
     });
   }
 
+  resubscribeAll() {
+    for (const key of this.activeSubscriptions) {
+      const [type, id] = key.split(':');
+      const msg = { type: 'subscribe', timestamp: Date.now() };
+      if (type === 'session') msg.sessionId = id;
+      else msg.conversationId = id;
+      try {
+        this.ws.send(JSON.stringify(msg));
+        this.stats.totalMessagesSent++;
+      } catch (_) {}
+    }
+  }
+
   /**
    * Unsubscribe from streaming session
    */