agentgui 1.0.959 → 1.0.961

package/lib/ws-handlers-util.js

@@ -18,6 +18,20 @@ const SUB_AGENT_MAP = {
 export function register(router, deps) {
   const { queries, wsOptimizer, broadcastSync, getProviderConfigs, saveProviderConfig, STARTUP_CWD, discoveredAgents, subscriptionIndex, activeChats } = deps;
 
+  // Short-lived per-session terminal-event buffer (finding 35): a turn that
+  // completes/errors/cancels while a client ws is down would otherwise be a
+  // fire-and-forget broadcast the client never sees, hanging it busy forever.
+  // A re-subscribing client gets the buffered terminal frame replayed.
+  const TERMINAL_TTL_MS = 60000;
+  const terminalEvents = new Map(); // sessionId -> terminal event
+  function recordTerminal(sessionId, event) {
+    terminalEvents.set(sessionId, event);
+    const t = setTimeout(() => {
+      if (terminalEvents.get(sessionId) === event) terminalEvents.delete(sessionId);
+    }, TERMINAL_TTL_MS);
+    if (typeof t.unref === 'function') t.unref();
+  }
+
   // --- agents.list: enumerate registered ACP agents + claude-code ---
   router.handle('agents.list', () => {
     const agents = registry.list().map(a => ({
@@ -55,7 +69,11 @@ export function register(router, deps) {
     subscriptionIndex.get(sid).add(ws);
     ws.subscriptions = ws.subscriptions || new Set();
     ws.subscriptions.add(sid);
-    return { subscribed: true, sessionId: sid };
+    // Replay a buffered terminal frame (complete/error/cancelled) so a client
+    // that re-subscribes after a ws drop learns the turn already ended.
+    const term = terminalEvents.get(sid);
+    if (term) { try { wsOptimizer.sendToClient(ws, { ...term, replayed: true }); } catch {} }
+    return { subscribed: true, sessionId: sid, replayedTerminal: !!term };
   });
 
   // --- chat.sendMessage: start a one-shot streaming chat with an agent.
@@ -88,6 +106,9 @@ export function register(router, deps) {
 
     const ctrl = { aborted: false, proc: null, agentId, model, cwd, startedAt: Date.now() };
     activeChats.set(sessionId, ctrl);
+    // Push-driven hint so clients refresh active-session state without
+    // waiting for the 3s chat.active poll (finding 48).
+    broadcastSync({ type: 'chat_active_changed', reason: 'started', sessionId, agentId, timestamp: Date.now() });
 
     // Fire-and-forget. Errors broadcast as streaming_error.
     (async () => {
@@ -127,11 +148,20 @@ export function register(router, deps) {
           onPid: () => {}, onProcess: (proc) => { ctrl.proc = proc; },
         };
         await runClaudeWithStreaming(content, cwd, agentId, config);
-        broadcastSync({ type: 'streaming_complete', sessionId, agentId, eventCount, timestamp: Date.now() });
+        if (!ctrl.aborted) {
+          const ev = { type: 'streaming_complete', sessionId, claudeSessionId: ctrl.claudeSessionId || null, agentId, eventCount, timestamp: Date.now() };
+          recordTerminal(sessionId, ev);
+          broadcastSync(ev);
+        }
       } catch (e) {
-        broadcastSync({ type: 'streaming_error', sessionId, agentId, error: e.message || String(e), recoverable: false, timestamp: Date.now() });
+        if (!ctrl.aborted) {
+          const ev = { type: 'streaming_error', sessionId, claudeSessionId: ctrl.claudeSessionId || null, agentId, error: e.message || String(e), recoverable: false, timestamp: Date.now() };
+          recordTerminal(sessionId, ev);
+          broadcastSync(ev);
+        }
       } finally {
         activeChats.delete(sessionId);
+        broadcastSync({ type: 'chat_active_changed', reason: 'ended', sessionId, agentId, timestamp: Date.now() });
       }
     })();
 
@@ -142,7 +172,7 @@ export function register(router, deps) {
   router.handle('chat.active', () => {
     const sessions = [];
     for (const [sid, c] of activeChats) {
-      sessions.push({ sessionId: sid, agentId: c.agentId || null, model: c.model || null, cwd: c.cwd || null, startedAt: c.startedAt || null, pid: c.proc?.pid || null });
+      sessions.push({ sessionId: sid, claudeSessionId: c.claudeSessionId || null, agentId: c.agentId || null, model: c.model || null, cwd: c.cwd || null, startedAt: c.startedAt || null, pid: c.proc?.pid || null });
     }
     return { sessions };
   });
@@ -154,8 +184,16 @@ export function register(router, deps) {
     const ctrl = activeChats.get(sid);
     if (!ctrl) return { cancelled: false, reason: 'not-found' };
     ctrl.aborted = true;
+    // Broadcast the terminal 'cancelled' frame BEFORE killing the proc so a
+    // remote cancellation (other tab, dashboard stop-all) does not read as a
+    // normal completion (finding 44). streaming_cancelled is in BROADCAST_TYPES
+    // so every connected client sees it; it is also buffered for re-subscribers.
+    const ev = { type: 'streaming_cancelled', sessionId: sid, claudeSessionId: ctrl.claudeSessionId || null, agentId: ctrl.agentId || null, cancelled: true, timestamp: Date.now() };
+    recordTerminal(sid, ev);
+    broadcastSync(ev);
     try { ctrl.proc?.kill?.(); } catch {}
     activeChats.delete(sid);
+    broadcastSync({ type: 'chat_active_changed', reason: 'cancelled', sessionId: sid, agentId: ctrl.agentId || null, timestamp: Date.now() });
     return { cancelled: true };
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.959",
+  "version": "1.0.961",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/server.js

@@ -70,6 +70,33 @@ const staticDir = path.join(rootDir, 'site', 'app');
 if (!fs.existsSync(staticDir)) fs.mkdirSync(staticDir, { recursive: true });
 
 const expressApp = createExpressApp({ queries, BASE_URL });
+
+// ccsniff's /v1/history/sessions/:sid/events returns ALL events with no
+// paging. Shim (mounted BEFORE the ccsniff router; node_modules untouched):
+// when ?limit= is present, slice the most-recent window server-side and
+// report { total, offset } so the client can page older on demand via
+// ?before= (slice end index, exclusive; defaults to total).
+function historyEventsLimitShim(req, res, next) {
+  if (!/\/v1\/history\/sessions\/[^/]+\/events$/.test(req.path)) return next();
+  const limit = parseInt(req.query.limit, 10);
+  if (!Number.isFinite(limit) || limit <= 0) return next();
+  const origJson = res.json.bind(res);
+  res.json = (body) => {
+    try {
+      if (body && Array.isArray(body.events)) {
+        const total = body.events.length;
+        const before = parseInt(req.query.before, 10);
+        const end = (Number.isFinite(before) && before >= 0) ? Math.min(before, total) : total;
+        const start = Math.max(0, end - limit);
+        body = { ...body, events: body.events.slice(start, end), total, offset: start };
+      }
+    } catch {}
+    return origJson(body);
+  };
+  next();
+}
+expressApp.use(historyEventsLimitShim);
+
 try {
   const historyRouter = await createHistoryRouter({ projectsDir: process.env.CLAUDE_PROJECTS_DIR });
   expressApp.use('/', historyRouter);