agentgui 1.0.837 → 1.0.839

package/lib/routes-runs.js

@@ -0,0 +1,156 @@
+import os from 'os';
+
+export function register(deps) {
+  const { sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD } = deps;
+
+  const routes = {};
+
+  routes['_match'] = (method, pathOnly) => {
+    const key = `${method} ${pathOnly}`;
+    if (routes[key]) return routes[key];
+    let m;
+    if ((m = pathOnly.match(/^\/api\/runs\/([^/]+)$/))) return (req, res) => handleRunById(req, res, m[1]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/runs\/([^/]+)\/wait$/))) return (req, res) => handleRunWait(req, res, m[1]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/runs\/([^/]+)\/stream$/))) return (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/))) return (req, res) => handleRunCancel(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/))) return (req, res) => handleThreadRunCancel(req, res, m[1], m[2]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/wait$/))) return (req, res) => handleThreadRunWait(req, res, m[1], m[2]);
+    return null;
+  };
+
+  routes['POST /api/runs'] = async (req, res) => {
+    let body = '';
+    for await (const chunk of req) { body += chunk; }
+    let parsed = {};
+    try { parsed = body ? JSON.parse(body) : {}; } catch {}
+    const { input, agentId } = parsed;
+    if (!input) { sendJSON(req, res, 400, { error: 'Missing input in request body' }); return; }
+    const resolvedAgentId = agentId || 'claude-code';
+    const resolvedModel = parsed.model || null;
+    const cwd = parsed.workingDirectory || STARTUP_CWD;
+    const thread = queries.createConversation(resolvedAgentId, 'Stateless Run', cwd);
+    const session = queries.createSession(thread.id, resolvedAgentId, 'pending');
+    const content = typeof input === 'string' ? input : JSON.stringify(input);
+    const message = queries.createMessage(thread.id, 'user', content);
+    processMessageWithStreaming(thread.id, message.id, session.id, content, resolvedAgentId, resolvedModel);
+    sendJSON(req, res, 200, { id: session.id, status: 'pending', started_at: session.started_at, agentId: resolvedAgentId });
+  };
+
+  routes['POST /api/runs/search'] = async (req, res) => {
+    const sessions = queries.getAllSessions();
+    const runs = sessions.slice(0, 50).map(s => ({ id: s.id, status: s.status, started_at: s.started_at, completed_at: s.completed_at, agentId: s.agentId, input: null, output: null })).reverse();
+    sendJSON(req, res, 200, runs);
+  };
+
+  routes['POST /api/runs/stream'] = (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
+
+  routes['POST /api/runs/wait'] = async (req, res) => {
+    const body = await parseBody(req);
+    const { agent_id, input, config } = body;
+    if (!agent_id) { sendJSON(req, res, 422, { error: 'agent_id is required' }); return; }
+    const agent = discoveredAgents.find(a => a.id === agent_id);
+    if (!agent) { sendJSON(req, res, 404, { error: 'Agent not found' }); return; }
+    const run = queries.createRun(agent_id, null, input, config);
+    sendJSON(req, res, 200, run);
+  };
+
+  async function handleRunById(req, res, runId) {
+    if (req.method === 'GET') {
+      const run = queries.getRun(runId);
+      if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+      sendJSON(req, res, 200, run);
+      return;
+    }
+    if (req.method === 'POST') {
+      const run = queries.getRun(runId);
+      if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+      if (run.status !== 'pending') { sendJSON(req, res, 409, { error: 'Run is not resumable' }); return; }
+      sendJSON(req, res, 200, run);
+      return;
+    }
+    if (req.method === 'DELETE') {
+      try { queries.deleteRun(runId); res.writeHead(204); res.end(); } catch { sendJSON(req, res, 404, { error: 'Run not found' }); }
+    }
+  }
+
+  async function handleRunWait(req, res, runId) {
+    const run = queries.getRun(runId);
+    if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+    const startTime = Date.now();
+    const poll = setInterval(() => {
+      const cur = queries.getRun(runId);
+      const done = cur && ['success', 'error', 'cancelled'].includes(cur.status);
+      if (done) { clearInterval(poll); sendJSON(req, res, 200, cur); }
+      else if (Date.now() - startTime > 30000) { clearInterval(poll); sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: cur?.status || run.status }); }
+    }, 500);
+    req.on('close', () => clearInterval(poll));
+  }
+
+  async function handleRunCancel(req, res, runId) {
+    try {
+      const run = queries.getRun(runId);
+      if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+      if (['success', 'error', 'cancelled'].includes(run.status)) { sendJSON(req, res, 409, { error: 'Run already completed or cancelled' }); return; }
+      const cancelled = queries.cancelRun(runId);
+      const threadId = run.thread_id;
+      if (threadId) {
+        const execution = activeExecutions.get(threadId);
+        if (execution?.pid) {
+          try { process.kill(-execution.pid, 'SIGTERM'); } catch { try { process.kill(execution.pid, 'SIGTERM'); } catch {} }
+          setTimeout(() => { try { process.kill(-execution.pid, 'SIGKILL'); } catch { try { process.kill(execution.pid, 'SIGKILL'); } catch {} } }, 3000);
+        }
+        if (execution?.sessionId) queries.updateSession(execution.sessionId, { status: 'error', error: 'Cancelled by user', completed_at: Date.now() });
+        activeExecutions.delete(threadId);
+        queries.setIsStreaming(threadId, false);
+        broadcastSync({ type: 'streaming_cancelled', sessionId: execution?.sessionId || runId, conversationId: threadId, runId, timestamp: Date.now() });
+      }
+      sendJSON(req, res, 200, cancelled);
+    } catch (err) {
+      if (err.message === 'Run not found') sendJSON(req, res, 404, { error: err.message });
+      else if (err.message.includes('already completed')) sendJSON(req, res, 409, { error: err.message });
+      else sendJSON(req, res, 500, { error: err.message });
+    }
+  }
+
+  async function handleThreadRunCancel(req, res, threadId, runId) {
+    try {
+      const run = queries.getRun(runId);
+      if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+      if (run.thread_id !== threadId) { sendJSON(req, res, 400, { error: 'Run does not belong to specified thread' }); return; }
+      if (['success', 'error', 'cancelled'].includes(run.status)) { sendJSON(req, res, 409, { error: 'Run already completed or cancelled' }); return; }
+      const cancelled = queries.cancelRun(runId);
+      const execution = activeExecutions.get(threadId);
+      if (execution?.pid) {
+        try { process.kill(-execution.pid, 'SIGTERM'); } catch { try { process.kill(execution.pid, 'SIGTERM'); } catch {} }
+        setTimeout(() => { try { process.kill(-execution.pid, 'SIGKILL'); } catch { try { process.kill(execution.pid, 'SIGKILL'); } catch {} } }, 3000);
+      }
+      if (execution?.sessionId) queries.updateSession(execution.sessionId, { status: 'error', error: 'Cancelled by user', completed_at: Date.now() });
+      activeExecutions.delete(threadId);
+      activeProcessesByRunId.delete(runId);
+      queries.setIsStreaming(threadId, false);
+      broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: execution?.sessionId, timestamp: Date.now() });
+      broadcastSync({ type: 'streaming_cancelled', sessionId: execution?.sessionId || runId, conversationId: threadId, runId, timestamp: Date.now() });
+      sendJSON(req, res, 200, cancelled);
+    } catch (err) {
+      if (err.message === 'Run not found') sendJSON(req, res, 404, { error: err.message });
+      else if (err.message.includes('already completed')) sendJSON(req, res, 409, { error: err.message });
+      else sendJSON(req, res, 500, { error: err.message });
+    }
+  }
+
+  async function handleThreadRunWait(req, res, threadId, runId) {
+    const run = queries.getRun(runId);
+    if (!run) { sendJSON(req, res, 404, { error: 'Run not found' }); return; }
+    if (run.thread_id !== threadId) { sendJSON(req, res, 400, { error: 'Run does not belong to specified thread' }); return; }
+    const startTime = Date.now();
+    const poll = setInterval(() => {
+      const cur = queries.getRun(runId);
+      const done = cur && ['success', 'error', 'cancelled'].includes(cur.status);
+      if (done) { clearInterval(poll); sendJSON(req, res, 200, cur); }
+      else if (Date.now() - startTime > 30000) { clearInterval(poll); sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: cur?.status || run.status }); }
+    }, 500);
+    req.on('close', () => clearInterval(poll));
+  }
+
+  return routes;
+}

package/lib/routes-scripts.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+
+export function register(deps) {
+  const { sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD } = deps;
+
+  const routes = {};
+
+  routes['_match'] = (method, pathOnly) => {
+    let m;
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/scripts$/))) return (req, res) => handleScripts(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/run-script$/))) return (req, res) => handleRunScript(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/stop-script$/))) return (req, res) => handleStopScript(req, res, m[1]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/script-status$/))) return (req, res) => handleScriptStatus(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/cancel$/))) return (req, res) => handleCancel(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/resume$/))) return (req, res) => handleResume(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/inject$/))) return (req, res) => handleInject(req, res, m[1]);
+    return null;
+  };
+
+  async function handleScripts(req, res, conversationId) {
+    const conv = queries.getConversation(conversationId);
+    if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    const wd = conv.workingDirectory || STARTUP_CWD;
+    let hasStart = false, hasDev = false;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
+      const scripts = pkg.scripts || {};
+      hasStart = !!scripts.start;
+      hasDev = !!scripts.dev;
+    } catch {}
+    const running = activeScripts.has(conversationId);
+    const runningScript = running ? activeScripts.get(conversationId).script : null;
+    sendJSON(req, res, 200, { hasStart, hasDev, running, runningScript });
+  }
+
+  async function handleRunScript(req, res, conversationId) {
+    const conv = queries.getConversation(conversationId);
+    if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Script already running' }); return; }
+    const body = await parseBody(req);
+    const script = body.script;
+    if (script !== 'start' && script !== 'dev') { sendJSON(req, res, 400, { error: 'Invalid script' }); return; }
+    const wd = conv.workingDirectory || STARTUP_CWD;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
+      if (!pkg.scripts || !pkg.scripts[script]) { sendJSON(req, res, 400, { error: `Script "${script}" not found` }); return; }
+    } catch { sendJSON(req, res, 400, { error: 'No package.json' }); return; }
+    const childEnv = { ...process.env, FORCE_COLOR: '1' };
+    delete childEnv.PORT;
+    delete childEnv.BASE_URL;
+    delete childEnv.HOT_RELOAD;
+    const isWindows = os.platform() === 'win32';
+    const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
+    activeScripts.set(conversationId, { process: child, script, startTime: Date.now() });
+    broadcastSync({ type: 'script_started', conversationId, script, timestamp: Date.now() });
+    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
+    child.stdout.on('data', onData('stdout'));
+    child.stderr.on('data', onData('stderr'));
+    child.stdout.on('error', () => {});
+    child.stderr.on('error', () => {});
+    child.on('error', (err) => { activeScripts.delete(conversationId); broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() }); });
+    child.on('close', (code) => { activeScripts.delete(conversationId); broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() }); });
+    sendJSON(req, res, 200, { ok: true, script, pid: child.pid });
+  }
+
+  async function handleStopScript(req, res, conversationId) {
+    const entry = activeScripts.get(conversationId);
+    if (!entry) { sendJSON(req, res, 404, { error: 'No running script' }); return; }
+    try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
+    sendJSON(req, res, 200, { ok: true });
+  }
+
+  async function handleScriptStatus(req, res, conversationId) {
+    const entry = activeScripts.get(conversationId);
+    sendJSON(req, res, 200, { running: !!entry, script: entry?.script || null });
+  }
+
+  async function handleCancel(req, res, conversationId) {
+    const entry = activeExecutions.get(conversationId);
+    if (!entry) { sendJSON(req, res, 404, { error: 'No active execution to cancel' }); return; }
+    const { pid, sessionId } = entry;
+    if (pid) {
+      try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} }
+    }
+    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
+    queries.setIsStreaming(conversationId, false);
+    activeExecutions.delete(conversationId);
+    broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+    sendJSON(req, res, 200, { ok: true, cancelled: true, conversationId, sessionId });
+  }
+
+  async function handleResume(req, res, conversationId) {
+    const conv = queries.getConversation(conversationId);
+    if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
+    if (activeExecutions.get(conversationId)) { sendJSON(req, res, 409, { error: 'Conversation already has an active execution' }); return; }
+    let body = '';
+    for await (const chunk of req) { body += chunk; }
+    let parsed = {};
+    try { parsed = body ? JSON.parse(body) : {}; } catch {}
+    const { content, agentId } = parsed;
+    if (!content) { sendJSON(req, res, 400, { error: 'Missing content in request body' }); return; }
+    const resolvedAgentId = agentId || conv.agentId || 'claude-code';
+    const resolvedModel = parsed.model || conv.model || null;
+    const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
+    const message = queries.createMessage(conversationId, 'user', content);
+    processMessageWithStreaming(conversationId, message.id, session.id, content, resolvedAgentId, resolvedModel);
+    sendJSON(req, res, 200, { ok: true, conversationId, sessionId: session.id, messageId: message.id, resumed: true });
+  }
+
+  async function handleInject(req, res, conversationId) {
+    const conv = queries.getConversation(conversationId);
+    if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
+    let body = '';
+    for await (const chunk of req) { body += chunk; }
+    let parsed = {};
+    try { parsed = body ? JSON.parse(body) : {}; } catch {}
+    const { content, eager } = parsed;
+    if (!content) { sendJSON(req, res, 400, { error: 'Missing content in request body' }); return; }
+    const entry = activeExecutions.get(conversationId);
+    if (entry && eager) { sendJSON(req, res, 409, { error: 'Cannot eagerly inject while execution is running - message queued' }); return; }
+    const message = queries.createMessage(conversationId, 'user', '[INJECTED] ' + content);
+    if (!entry) {
+      const resolvedAgentId = conv.agentId || 'claude-code';
+      const resolvedModel = conv.model || null;
+      const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
+      processMessageWithStreaming(conversationId, message.id, session.id, message.content, resolvedAgentId, resolvedModel);
+    }
+    sendJSON(req, res, 200, { ok: true, injected: true, conversationId, messageId: message.id });
+  }
+
+  return routes;
+}

package/lib/routes-sessions.js

@@ -0,0 +1,144 @@
+export function register(deps) {
+  const { queries, sendJSON, activeExecutions, rateLimitState, debugLog } = deps;
+
+  const routes = {};
+
+  routes['_match'] = (method, pathOnly) => {
+    let m;
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/messages\/([^/]+)$/)))
+      return (req, res) => handleGetMessage(req, res, m[1], m[2]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/sessions\/([^/]+)$/)))
+      return (req, res) => handleGetSession(req, res, m[1]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/full$/)))
+      return (req, res) => handleFullLoad(req, res, m[1]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/chunks$/)))
+      return (req, res) => handleConvChunks(req, res, m[1]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/sessions\/([^/]+)\/chunks$/)))
+      return (req, res) => handleSessionChunks(req, res, m[1]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/conversations\/([^/]+)\/sessions\/latest$/)))
+      return (req, res) => handleLatestSession(req, res, m[1]);
+
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/sessions\/([^/]+)\/execution$/)))
+      return (req, res) => handleExecution(req, res, m[1]);
+
+    return null;
+  };
+
+  async function handleGetMessage(req, res, conversationId, msgId) {
+    const msg = queries.getMessage(msgId);
+    if (!msg || msg.conversationId !== conversationId) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    sendJSON(req, res, 200, { message: msg });
+  }
+
+  async function handleGetSession(req, res, sessionId) {
+    const sess = queries.getSession(sessionId);
+    if (!sess) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    const events = queries.getSessionEvents(sessionId);
+    sendJSON(req, res, 200, { session: sess, events });
+  }
+
+  async function handleFullLoad(req, res, conversationId) {
+    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);
+    const url = new URL(req.url, 'http://localhost');
+    const chunkLimit = Math.min(parseInt(url.searchParams.get('chunkLimit') || '500'), 5000);
+    const allChunks = url.searchParams.get('allChunks') === '1';
+    const totalChunks = queries.getConversationChunkCount(conversationId);
+    let chunks;
+    if (allChunks || totalChunks <= chunkLimit) {
+      chunks = queries.getConversationChunks(conversationId);
+    } else {
+      chunks = queries.getRecentConversationChunks(conversationId, chunkLimit);
+    }
+    const msgResult = queries.getPaginatedMessages(conversationId, 100, 0);
+    const rateLimitInfo = rateLimitState.get(conversationId) || null;
+    sendJSON(req, res, 200, {
+      conversation: conv,
+      isActivelyStreaming,
+      latestSession,
+      chunks,
+      totalChunks,
+      messages: msgResult.messages,
+      rateLimitInfo
+    });
+  }
+
+  async function handleConvChunks(req, res, conversationId) {
+    const conv = queries.getConversation(conversationId);
+    if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
+    const url = new URL(req.url, 'http://localhost');
+    const since = parseInt(url.searchParams.get('since') || '0');
+    const all = url.searchParams.get('all') === 'true';
+    const totalChunks = queries.getConversationChunkCount(conversationId);
+    let chunks;
+    if (since > 0) {
+      chunks = queries.getConversationChunksSince(conversationId, since);
+    } else if (all) {
+      chunks = queries.getConversationChunks(conversationId);
+    } else {
+      chunks = queries.getRecentConversationChunks(conversationId, 500);
+    }
+    debugLog(`[chunks] Conv ${conversationId}: ${chunks.length} chunks (total: ${totalChunks})`);
+    sendJSON(req, res, 200, { ok: true, chunks, totalChunks });
+  }
+
+  async function handleSessionChunks(req, res, sessionId) {
+    const sess = queries.getSession(sessionId);
+    if (!sess) { sendJSON(req, res, 404, { error: 'Session not found' }); return; }
+    const url = new URL(req.url, 'http://localhost');
+    const sinceSeq = parseInt(url.searchParams.get('sinceSeq') || '-1');
+    const since = parseInt(url.searchParams.get('since') || '0');
+    let chunks;
+    if (sinceSeq >= 0) {
+      chunks = queries.getChunksSinceSeq(sessionId, sinceSeq);
+    } else {
+      chunks = queries.getChunksSince(sessionId, since);
+    }
+    sendJSON(req, res, 200, { ok: true, chunks });
+  }
+
+  async function handleLatestSession(req, res, convId) {
+    const latestSession = queries.getLatestSession(convId);
+    if (!latestSession) { sendJSON(req, res, 200, { session: null }); return; }
+    const events = queries.getSessionEvents(latestSession.id);
+    sendJSON(req, res, 200, { session: latestSession, events });
+  }
+
+  async function handleExecution(req, res, sessionId) {
+    const url = new URL(req.url, 'http://localhost');
+    const limit = Math.min(parseInt(url.searchParams.get('limit') || '1000'), 5000);
+    const offset = Math.max(parseInt(url.searchParams.get('offset') || '0'), 0);
+    const filterType = url.searchParams.get('filterType');
+    try {
+      const session = queries.getSession(sessionId);
+      const allChunks = session ? (queries.getChunksSince(sessionId, 0) || []) : [];
+      const filtered = filterType ? allChunks.filter(e => e.type === filterType) : allChunks;
+      sendJSON(req, res, 200, {
+        sessionId,
+        events: filtered.slice(offset, offset + limit),
+        total: filtered.length,
+        limit,
+        offset,
+        hasMore: offset + limit < filtered.length,
+        metadata: {
+          status: session?.status || 'unknown',
+          startTime: session?.created_at || null,
+          duration: session?.completed_at && session?.created_at ? session.completed_at - session.created_at : 0,
+          eventCount: filtered.length
+        }
+      });
+    } catch (err) {
+      sendJSON(req, res, 400, { error: err.message });
+    }
+  }
+
+  return routes;
+}

package/lib/stream-event-handler.js

@@ -0,0 +1,115 @@
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
+  return function onEvent(parsed) {
+    batcherRef.eventCount++;
+    const entry = activeExecutions.get(conversationId);
+    if (entry) entry.lastActivity = Date.now();
+    if (parsed.session_id) {
+      ownedSessionIds.add(parsed.session_id);
+      if (!batcherRef.resumeSessionId || batcherRef.resumeSessionId !== parsed.session_id) {
+        batcherRef.resumeSessionId = parsed.session_id;
+        queries.setClaudeSessionId(conversationId, parsed.session_id, sessionId);
+      }
+    }
+    debugLog(`[stream] Event ${batcherRef.eventCount}: type=${parsed.type}`);
+
+    if (parsed.type === 'system') {
+      if (parsed.subtype === 'task_notification') return;
+      if (!parsed.model && !parsed.cwd && !parsed.tools) return;
+      const block = { type: 'system', subtype: parsed.subtype, model: parsed.model, cwd: parsed.cwd, tools: parsed.tools, session_id: parsed.session_id };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'system', block);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'system', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'assistant' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        allBlocksRef.val.push(block);
+        currentSequenceRef.val++;
+        batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, block.type || 'assistant', block);
+        broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'assistant', blockIndex: allBlocksRef.val.length - 1, seq: currentSequenceRef.val, timestamp: Date.now() });
+        if (block.type === 'text' && block.text) {
+          const rateLimitMatch = block.text.match(/you'?ve hit your limit|rate limit exceeded/i);
+          if (rateLimitMatch) {
+            debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
+            const retryAfterSec = parseRateLimitResetTime(block.text);
+            const entry2 = activeExecutions.get(conversationId);
+            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (e) {} }
+            const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
+            if (existingCount >= 3) {
+              batcherRef.batcher.drain();
+              activeExecutions.delete(conversationId);
+              queries.setIsStreaming(conversationId, false);
+              const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount + 1} attempts. Please try again later.`);
+              broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
+              broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+              return;
+            }
+            rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount + 1, isStreamDetected: true });
+            broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: 1, timestamp: Date.now() });
+            batcherRef.batcher.drain();
+            activeExecutions.delete(conversationId);
+            queries.setIsStreaming(conversationId, false);
+            setTimeout(() => {
+              rateLimitState.delete(conversationId);
+              broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+              scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+            }, retryAfterSec * 1000);
+            return;
+          }
+          eagerTTS(block.text, conversationId, sessionId);
+        }
+      }
+    } else if (parsed.type === 'user' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        if (block.type === 'tool_result') {
+          const toolResultBlock = { type: 'tool_result', tool_use_id: block.tool_use_id, content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content), is_error: block.is_error || false };
+          currentSequenceRef.val++;
+          batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'tool_result', toolResultBlock);
+          broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: toolResultBlock, blockRole: 'tool_result', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+        }
+      }
+    } else if (parsed.type === 'result') {
+      const resultBlock = { type: 'result', subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, num_turns: parsed.num_turns, is_error: parsed.is_error || false, result: parsed.result };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'result', resultBlock);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: resultBlock, blockRole: 'result', blockIndex: allBlocksRef.val.length, isResult: true, seq: currentSequenceRef.val, timestamp: Date.now() });
+      if (parsed.result) {
+        const resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
+        const rlMatch = resultText.match(/you'?ve hit your limit|rate limit exceeded/i);
+        if (rlMatch) {
+          debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
+          const retryAfterSec = parseRateLimitResetTime(resultText);
+          const entry3 = activeExecutions.get(conversationId);
+          if (entry3 && entry3.pid) { try { process.kill(entry3.pid); } catch (e) {} }
+          const existingCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
+          if (existingCount2 >= 3) {
+            batcherRef.batcher.drain();
+            activeExecutions.delete(conversationId);
+            queries.setIsStreaming(conversationId, false);
+            const errMsg2 = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount2 + 1} attempts. Please try again later.`);
+            broadcastSync({ type: 'message_created', conversationId, message: errMsg2, timestamp: Date.now() });
+            broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+            return;
+          }
+          rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount2 + 1, isStreamDetected: true });
+          broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: existingCount2 + 1, timestamp: Date.now() });
+          batcherRef.batcher.drain();
+          activeExecutions.delete(conversationId);
+          queries.setIsStreaming(conversationId, false);
+          setTimeout(() => {
+            rateLimitState.delete(conversationId);
+            broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+            scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+          }, retryAfterSec * 1000);
+          return;
+        }
+        if (resultText) eagerTTS(resultText, conversationId, sessionId);
+      }
+      if (parsed.result && allBlocksRef.val.length === 0) allBlocksRef.val.push({ type: 'text', text: String(parsed.result) });
+    } else if (parsed.type === 'tool_status') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'tool_status', tool_use_id: parsed.tool_use_id, status: parsed.status }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'usage') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'usage', usage: parsed.usage }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'plan') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'plan', entries: parsed.entries }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    }
+  };
+}

package/package.json

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

package/scripts/patch-fsbrowse.js

@@ -197,4 +197,4 @@ if (fs.existsSync(fsbrowseAppJSPath)) {
   } catch (err) {
     console.warn('[PATCH] Could not patch fsbrowse app.js:', err.message);
   }
-}
+}