agentgui 1.0.761 → 1.0.763

package/CLAUDE.md

@@ -46,6 +46,11 @@ lib/tool-manager.js    Tool facade - re-exports from tool-version, tool-spawner,
 lib/tool-version.js    Version detection for CLI tools and plugins (data-driven framework paths)
 lib/tool-spawner.js    npm/bun install/update spawn with timeout and heartbeat
 lib/tool-provisioner.js  Auto-provisioning and periodic update checking
+lib/routes-speech.js   Speech/TTS HTTP route handlers (stt, tts, voices, speech-status)
+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
@@ -156,6 +161,9 @@ All routes are prefixed with `BASE_URL` (default `/gm`).
 - `GET /api/conversations/:id` - Get conversation with streaming status
 - `POST /api/conversations/:id` - Update conversation
 - `DELETE /api/conversations/:id` - Delete conversation
+- `POST /api/conversations/:id/archive` - Archive conversation (soft-delete)
+- `POST /api/conversations/:id/restore` - Restore archived conversation
+- `GET /api/conversations/archived` - List archived conversations
 - `GET /api/conversations/:id/messages` - Get messages (query: limit, offset)
 - `POST /api/conversations/:id/messages` - Send message (body: content, agentId)
 - `POST /api/conversations/:id/stream` - Start streaming execution
@@ -268,12 +276,12 @@ Server broadcasts:
 
 **WSOptimizer** (`lib/ws-optimizer.js`): Per-client priority queue. High-priority events flush immediately; normal/low batch by latency tier (16ms excellent → 200ms bad). Rate limit: 100 msg/sec — overflow is re-queued (not dropped). No `lastKey` deduplication (was removed — caused valid event drops).
 
-### WS RPC Methods (85 total)
+### WS RPC Methods (86 total)
 
 **agent:** `agent.auth`, `agent.authstat`, `agent.desc`, `agent.get`, `agent.ls`, `agent.models`, `agent.search`, `agent.subagents`, `agent.update`
 **auth:** `auth.configs`, `auth.save`
 **codex:** `codex.complete`, `codex.relay`, `codex.start`, `codex.status`
-**conv:** `conv.cancel`, `conv.chunks`, `conv.chunks.earlier`, `conv.del`, `conv.del.all`, `conv.export`, `conv.full`, `conv.get`, `conv.inject`, `conv.ls`, `conv.new`, `conv.prune`, `conv.run-script`, `conv.scripts`, `conv.search`, `conv.steer`, `conv.stop-script`, `conv.sync`, `conv.tags`, `conv.upd`
+**conv:** `conv.cancel`, `conv.chunks`, `conv.chunks.earlier`, `conv.del`, `conv.del.all`, `conv.export`, `conv.full`, `conv.get`, `conv.import`, `conv.inject`, `conv.ls`, `conv.new`, `conv.prune`, `conv.run-script`, `conv.scripts`, `conv.search`, `conv.steer`, `conv.stop-script`, `conv.sync`, `conv.tags`, `conv.upd`
 **gemini:** `gemini.complete`, `gemini.relay`, `gemini.start`, `gemini.status`
 **git:** `git.check`, `git.push`
 **msg:** `msg.get`, `msg.ls`, `msg.ls.earlier`, `msg.send`, `msg.stream`

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.761",
+  "version": "1.0.763",
   "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';
@@ -1927,161 +1928,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);
@@ -3072,6 +2920,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,