agentgui 1.0.762 → 1.0.764

package/CLAUDE.md

@@ -50,6 +50,7 @@ lib/routes-speech.js   Speech/TTS HTTP route handlers (stt, tts, voices, speech-
 lib/routes-oauth.js    OAuth HTTP route handlers (gemini-oauth/*, codex-oauth/*)
 lib/routes-tools.js    Tool management HTTP route handlers (list, install, update, history, refresh)
 lib/routes-util.js     Utility HTTP route handlers (clone, folders, git, home, version, import)
+lib/routes-threads.js  Thread CRUD HTTP route handlers (ACP v0.2.3 thread API)
 lib/ws-protocol.js     WebSocket RPC router (WsRouter class)
 lib/ws-optimizer.js    Per-client priority queue for WS event batching
 lib/ws-handlers-conv.js  Conversation CRUD, chunks, cancel, steer, inject RPC handlers

package/lib/routes-threads.js

@@ -0,0 +1,99 @@
+export function register(deps) {
+  const { sendJSON, parseBody, queries } = deps;
+  const routes = {};
+
+  routes['POST /api/threads'] = async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      sendJSON(req, res, 201, queries.createThread(body.metadata || {}));
+    } catch (err) {
+      sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+    }
+  };
+
+  routes['POST /api/threads/search'] = async (req, res) => {
+    try {
+      sendJSON(req, res, 200, queries.searchThreads(await parseBody(req)));
+    } catch (err) {
+      sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+    }
+  };
+
+  routes['_match'] = (method, pathOnly) => {
+    const key = `${method} ${pathOnly}`;
+    if (routes[key]) return routes[key];
+    let m;
+    if ((m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})$/))) {
+      if (method === 'GET') return (req, res) => handleGetThread(req, res, m[1]);
+      if (method === 'PATCH') return (req, res) => handlePatchThread(req, res, m[1]);
+      if (method === 'DELETE') return (req, res) => handleDeleteThread(req, res, m[1]);
+    }
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/history$/)))
+      return (req, res) => handleThreadHistory(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/copy$/)))
+      return (req, res) => handleThreadCopy(req, res, m[1]);
+    if (method === 'POST' && pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/stream$/))
+      return (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
+    if (method === 'GET' && pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/stream$/))
+      return (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
+    return null;
+  };
+
+  async function handleGetThread(req, res, threadId) {
+    try {
+      const thread = queries.getThread(threadId);
+      if (!thread) sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
+      else sendJSON(req, res, 200, thread);
+    } catch (err) {
+      sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
+    }
+  }
+
+  async function handlePatchThread(req, res, threadId) {
+    try {
+      sendJSON(req, res, 200, queries.patchThread(threadId, await parseBody(req)));
+    } catch (err) {
+      const code = err.message.includes('not found') ? 404 : 422;
+      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'validation_error' });
+    }
+  }
+
+  async function handleDeleteThread(req, res, threadId) {
+    try {
+      queries.deleteThread(threadId);
+      res.writeHead(204); res.end();
+    } catch (err) {
+      if (err.message.includes('not found')) sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
+      else if (err.message.includes('pending runs')) sendJSON(req, res, 409, { error: err.message, type: 'conflict' });
+      else sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
+    }
+  }
+
+  async function handleThreadHistory(req, res, threadId) {
+    try {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+      const before = url.searchParams.get('before') || null;
+      let offset = before ? parseInt(before, 10) : 0;
+      const result = queries.getThreadHistory(threadId, limit, offset);
+      sendJSON(req, res, 200, { states: result.states, next_cursor: result.hasMore ? String(offset + limit) : null });
+    } catch (err) {
+      const code = err.message.includes('not found') ? 404 : 422;
+      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'validation_error' });
+    }
+  }
+
+  async function handleThreadCopy(req, res, sourceThreadId) {
+    try {
+      const body = await parseBody(req);
+      const newThread = queries.copyThread(sourceThreadId);
+      if (body.metadata) sendJSON(req, res, 201, queries.patchThread(newThread.thread_id, { metadata: body.metadata }));
+      else sendJSON(req, res, 201, newThread);
+    } catch (err) {
+      const code = err.message.includes('not found') ? 404 : 500;
+      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'internal_error' });
+    }
+  }
+
+  return routes;
+}

package/package.json

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

package/server.js

@@ -23,6 +23,7 @@ import { register as registerSpeechRoutes } from './lib/routes-speech.js';
 import { register as registerOAuthRoutes } from './lib/routes-oauth.js';
 import { register as registerUtilRoutes } from './lib/routes-util.js';
 import { register as registerToolRoutes } from './lib/routes-tools.js';
+import { register as registerThreadRoutes } from './lib/routes-threads.js';
 import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getCodexOAuthStatus, getCodexOAuthState, CODEX_HOME, CODEX_AUTH_FILE } from './lib/oauth-codex.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
@@ -526,6 +527,10 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (pathOnly === '/api/health' && req.method === 'GET') {
+      let dbStatus = { ok: true };
+      try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
+      const queueSizes = {};
+      for (const [k, v] of messageQueues) queueSizes[k] = v.length;
       sendJSON(req, res, 200, {
         status: 'ok',
         version: PKG_VERSION,
@@ -534,7 +539,9 @@ const server = http.createServer(async (req, res) => {
         activeExecutions: activeExecutions.size,
         wsClients: wss.clients.size,
         memory: process.memoryUsage(),
-        acp: getACPStatus()
+        acp: getACPStatus(),
+        db: dbStatus,
+        queueSizes
       });
       return;
     }
@@ -1188,7 +1195,7 @@ const server = http.createServer(async (req, res) => {
     }
 
     if (pathOnly === '/api/agents' && req.method === 'GET') {
-      console.log(`[API /api/agents] Returning ${discoveredAgents.length} agents:`, discoveredAgents.map(a => a.id).join(', '));
+      debugLog(`[API /api/agents] Returning ${discoveredAgents.length} agents`);
             sendJSON(req, res, 200, { agents: discoveredAgents });
       return;
     }
@@ -1198,21 +1205,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/health' && req.method === 'GET') {
-      let dbStatus = { ok: true };
-      try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
-      const queueSizes = {};
-      for (const [k, v] of messageQueues) queueSizes[k] = v.length;
-      sendJSON(req, res, 200, {
-        uptime: process.uptime(),
-        db: dbStatus,
-        activeExecutionCount: activeExecutions.size,
-        queueSizes,
-        wsClientCount: syncClients.size,
-        memory: process.memoryUsage()
-      });
-      return;
-    }
 
     if (pathOnly === '/api/debug' && req.method === 'GET') {
       const execSnap = {};
@@ -1927,161 +1919,8 @@ const server = http.createServer(async (req, res) => {
     const utilHandler = _utilRoutes._match(req.method, pathOnly);
     if (utilHandler) { await utilHandler(req, res); return; }
 
-    // THREAD API ENDPOINTS (ACP v0.2.3)
-    // ============================================================
-
-    // POST /threads - Create empty thread
-    if (pathOnly === '/api/threads' && req.method === 'POST') {
-      console.log('[ACP] POST /api/threads HIT');
-      try {
-        const body = await parseBody(req);
-        const metadata = body.metadata || {};
-        const thread = queries.createThread(metadata);
-        sendJSON(req, res, 201, thread);
-      } catch (err) {
-        sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-      }
-      return;
-    }
-
-    // POST /threads/search - Search threads
-    if (pathOnly === '/api/threads/search' && req.method === 'POST') {
-      try {
-        const body = await parseBody(req);
-        const result = queries.searchThreads(body);
-        sendJSON(req, res, 200, result);
-      } catch (err) {
-        sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-      }
-      return;
-    }
-
-    // GET /threads/{thread_id} - Get thread by ID
-    const acpThreadMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})$/);
-    if (acpThreadMatch && req.method === 'GET') {
-      const threadId = acpThreadMatch[1];
-      try {
-        const thread = queries.getThread(threadId);
-        if (!thread) {
-          sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
-        } else {
-          sendJSON(req, res, 200, thread);
-        }
-      } catch (err) {
-        sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-      }
-      return;
-    }
-
-    // PATCH /threads/{thread_id} - Update thread metadata
-    if (acpThreadMatch && req.method === 'PATCH') {
-      const threadId = acpThreadMatch[1];
-      try {
-        const body = await parseBody(req);
-        const thread = queries.patchThread(threadId, body);
-        sendJSON(req, res, 200, thread);
-      } catch (err) {
-        if (err.message.includes('not found')) {
-          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
-        } else {
-          sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-        }
-      }
-      return;
-    }
-
-    // DELETE /threads/{thread_id} - Delete thread (fail if pending runs exist)
-    if (acpThreadMatch && req.method === 'DELETE') {
-      const threadId = acpThreadMatch[1];
-      try {
-        queries.deleteThread(threadId);
-        res.writeHead(204);
-        res.end();
-      } catch (err) {
-        if (err.message.includes('not found')) {
-          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
-        } else if (err.message.includes('pending runs')) {
-          sendJSON(req, res, 409, { error: err.message, type: 'conflict' });
-        } else {
-          sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-        }
-      }
-      return;
-    }
-
-    // GET /threads/{thread_id}/history - Get thread state history with pagination
-    const threadHistoryMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/history$/);
-    if (threadHistoryMatch && req.method === 'GET') {
-      const threadId = threadHistoryMatch[1];
-      try {
-        const url = new URL(req.url, `http://${req.headers.host}`);
-        const limit = parseInt(url.searchParams.get('limit') || '50', 10);
-        const before = url.searchParams.get('before') || null;
-
-        // Convert 'before' cursor to offset if needed
-        let offset = 0;
-        if (before) {
-          // Simple cursor-based pagination: before is an offset value
-          offset = parseInt(before, 10);
-        }
-
-        const result = queries.getThreadHistory(threadId, limit, offset);
-
-        // Generate next_cursor if there are more results
-        const response = {
-          states: result.states,
-          next_cursor: result.hasMore ? String(offset + limit) : null
-        };
-
-        sendJSON(req, res, 200, response);
-      } catch (err) {
-        if (err.message.includes('not found')) {
-          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
-        } else {
-          sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-        }
-      }
-      return;
-    }
-
-    // POST /threads/{thread_id}/copy - Copy thread with all states/checkpoints
-    const threadCopyMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/copy$/);
-    if (threadCopyMatch && req.method === 'POST') {
-      const sourceThreadId = threadCopyMatch[1];
-      try {
-        const body = await parseBody(req);
-        const newThread = queries.copyThread(sourceThreadId);
-
-        // Update metadata if provided
-        if (body.metadata) {
-          const updated = queries.patchThread(newThread.thread_id, { metadata: body.metadata });
-          sendJSON(req, res, 201, updated);
-        } else {
-          sendJSON(req, res, 201, newThread);
-        }
-      } catch (err) {
-        if (err.message.includes('not found')) {
-          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
-        } else {
-          sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-        }
-      }
-      return;
-    }
-
-    // POST /threads/{thread_id}/runs/stream - SSE removed, use WebSocket
-    const threadRunsStreamMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/stream$/);
-    if (threadRunsStreamMatch && req.method === 'POST') {
-      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
-      return;
-    }
-
-    // GET /threads/{thread_id}/runs/{run_id}/stream - SSE removed, use WebSocket
-    const threadRunStreamMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/stream$/);
-    if (threadRunStreamMatch && req.method === 'GET') {
-      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
-      return;
-    }
+    const threadHandler = _threadRoutes._match(req.method, pathOnly);
+    if (threadHandler) { await threadHandler(req, res); return; }
 
     if (routePath.startsWith('/api/image/')) {
       const imagePath = routePath.slice('/api/image/'.length);
@@ -2245,7 +2084,8 @@ function serveFile(filePath, res, req) {
     fs.readFile(filePath, (err2, data) => {
       if (err2) { res.writeHead(500); res.end('Server error'); return; }
       let content = data.toString();
-      const baseTag = `<script>window.__BASE_URL='${BASE_URL}';window.__SERVER_VERSION='${PKG_VERSION}';</script>`;
+      const wsToken = process.env.PASSWORD ? `window.__WS_TOKEN='${process.env.PASSWORD.replace(/'/g, "\\'")}';` : '';
+      const baseTag = `<script>window.__BASE_URL='${BASE_URL}';window.__SERVER_VERSION='${PKG_VERSION}';${wsToken}</script>`;
       content = content.replace('<head>', `<head>\n  <base href="${BASE_URL}/">\n  ` + baseTag);
       content = content.replace(/(href|src)="vendor\//g, `$1="${BASE_URL}/vendor/`);
       content = content.replace(/(src)="\/gm\/js\//g, `$1="${BASE_URL}/js/`);
@@ -2973,12 +2813,18 @@ const subscriptionIndex = new Map();
 const pm2Subscribers = new Set();
 
 wss.on('connection', (ws, req) => {
-  // req.url in WebSocket is just the path (e.g., '/gm/sync'), not a full URL
-  const wsPath = req.url.startsWith(BASE_URL) ? req.url.slice(BASE_URL.length) : req.url;
-  if (wsPath === '/hot-reload') {
+  const _pwd = process.env.PASSWORD;
+  if (_pwd) {
+    const url = new URL(req.url, 'http://localhost');
+    const token = url.searchParams.get('token');
+    if (token !== _pwd) { ws.close(4001, 'Unauthorized'); return; }
+  }
+  const wsPath = req.url.split('?')[0];
+  const wsRoute = wsPath.startsWith(BASE_URL) ? wsPath.slice(BASE_URL.length) : wsPath;
+  if (wsRoute === '/hot-reload') {
     hotReloadClients.push(ws);
     ws.on('close', () => { const i = hotReloadClients.indexOf(ws); if (i > -1) hotReloadClients.splice(i, 1); });
-  } else if (wsPath === '/sync') {
+  } else if (wsRoute === '/sync') {
     syncClients.add(ws);
     ws.isAlive = true;
     ws.subscriptions = new Set();
@@ -3009,7 +2855,7 @@ wss.on('connection', (ws, req) => {
        if (ws.pm2Subscribed) {
          pm2Subscribers.delete(ws);
        }
-       console.log(`[WebSocket] Client ${ws.clientId} disconnected`);
+       debugLog(`[WebSocket] Client ${ws.clientId} disconnected`);
      });
   }
 });
@@ -3072,6 +2918,7 @@ const _speechRoutes = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync,
 const _oauthRoutes = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL, rootDir });
 const _utilRoutes = registerUtilRoutes({ sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION });
 const _toolRoutes = registerToolRoutes({ sendJSON, parseBody, queries, broadcastSync, logError, toolManager });
+const _threadRoutes = registerThreadRoutes({ sendJSON, parseBody, queries });
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,
@@ -3086,13 +2933,13 @@ registerMsgHandlers(wsRouter, {
 
 registerQueueHandlers(wsRouter, { queries, messageQueues, broadcastSync });
 
-console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
+debugLog('[INIT] registerSessionHandlers, agents: ' + discoveredAgents.length);
 registerSessionHandlers(wsRouter, {
   db: queries, discoveredAgents, modelCache,
   getAgentDescriptor, activeScripts, broadcastSync,
   startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), geminiOAuthState: getGeminiOAuthState
 });
-console.log('[INIT] registerSessionHandlers completed');
+debugLog('[INIT] registerSessionHandlers completed');
 
 registerRunHandlers(wsRouter, {
   queries, discoveredAgents, activeExecutions, activeProcessesByRunId,
@@ -3165,7 +3012,7 @@ wsRouter.onLegacy((data, ws) => {
     if (data.conversationId && checkpointManager.hasPendingCheckpoint(data.conversationId)) {
       const checkpoint = checkpointManager.getPendingCheckpoint(data.conversationId);
       if (checkpoint) {
-        console.log(`[checkpoint] Injecting ${checkpoint.events.length} events to client for ${data.conversationId}`);
+        debugLog(`[checkpoint] Injecting ${checkpoint.events.length} events to client for ${data.conversationId}`);
 
         const latestSession = queries.getLatestSession(data.conversationId);
         if (latestSession) {

package/static/js/websocket-manager.js

@@ -113,7 +113,9 @@ class WebSocketManager {
   getWebSocketURL() {
     const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
     const baseURL = window.__BASE_URL || '/gm';
-    return `${protocol}//${window.location.host}${baseURL}/sync`;
+    let url = `${protocol}//${window.location.host}${baseURL}/sync`;
+    if (window.__WS_TOKEN) url += `?token=${encodeURIComponent(window.__WS_TOKEN)}`;
+    return url;
   }
 
   async connect() {