agentgui 1.0.760 → 1.0.762

package/CLAUDE.md

@@ -46,6 +46,10 @@ 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/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 +160,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 +275,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-tools.js

@@ -0,0 +1,185 @@
+import * as toolInstallMachine from './tool-install-machine.js';
+
+export function register(deps) {
+  const { sendJSON, parseBody, queries, broadcastSync, logError, toolManager } = deps;
+
+  function mapTool(t) {
+    return {
+      id: t.id, name: t.name, pkg: t.pkg,
+      category: t.category || 'plugin',
+      installed: t.installed || false,
+      status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
+      isUpToDate: t.isUpToDate || false,
+      upgradeNeeded: t.upgradeNeeded || false,
+      hasUpdate: (t.upgradeNeeded && t.installed) || false,
+      installedVersion: t.installedVersion || null,
+      publishedVersion: t.publishedVersion || null,
+      machineState: toolInstallMachine.getState(t.id),
+    };
+  }
+
+  const routes = {};
+
+  routes['GET /api/tools'] = async (req, res) => {
+    try {
+      const tools = await Promise.race([
+        toolManager.getAllToolsAsync(true),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000))
+      ]);
+      sendJSON(req, res, 200, { tools: tools.map(mapTool) });
+    } catch (err) {
+      sendJSON(req, res, 200, { tools: toolManager.getAllToolsSync().map(mapTool) });
+    }
+  };
+
+  routes['POST /api/tools/update'] = async (req, res) => {
+    const allToolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
+    sendJSON(req, res, 200, { updating: true, toolCount: allToolIds.length });
+    broadcastSync({ type: 'tools_update_started', tools: allToolIds });
+    setImmediate(async () => {
+      const results = {};
+      for (const toolId of allToolIds) {
+        try {
+          const result = await toolManager.update(toolId, (msg) => broadcastSync({ type: 'tool_update_progress', toolId, data: msg }));
+          results[toolId] = result;
+          if (result.success) {
+            const version = result.version || null;
+            queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
+            queries.addToolInstallHistory(toolId, 'update', 'success', null);
+            const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+            broadcastSync({ type: 'tool_update_complete', toolId, data: { ...result, ...freshStatus } });
+          } else {
+            queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+            queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
+            broadcastSync({ type: 'tool_update_failed', toolId, data: result });
+          }
+        } catch (err) {
+          queries.updateToolStatus(toolId, { status: 'failed', error_message: err.message });
+          queries.addToolInstallHistory(toolId, 'update', 'failed', err.message);
+          broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: err.message } });
+        }
+      }
+      broadcastSync({ type: 'tools_update_complete', data: results });
+    });
+  };
+
+  routes['POST /api/tools/refresh-all'] = async (req, res) => {
+    sendJSON(req, res, 200, { refreshing: true, toolCount: 4 });
+    broadcastSync({ type: 'tools_refresh_started' });
+    setImmediate(async () => {
+      const tools = toolManager.getAllTools();
+      for (const tool of tools) {
+        queries.updateToolStatus(tool.id, { status: tool.installed ? 'installed' : 'not_installed', version: tool.installedVersion, last_check_at: Date.now() });
+        if (tool.installed) {
+          const status = await toolManager.checkToolStatusAsync(tool.id);
+          if (status?.upgradeNeeded) queries.updateToolStatus(tool.id, { update_available: 1, latest_version: status.publishedVersion });
+        }
+      }
+      broadcastSync({ type: 'tools_refresh_complete', data: tools });
+    });
+  };
+
+  routes['_match'] = (method, pathOnly) => {
+    const key = `${method} ${pathOnly}`;
+    if (routes[key]) return routes[key];
+    let m;
+    if ((m = pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/))) return (req, res) => handleToolStatus(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/))) return (req, res) => handleToolInstall(req, res, m[1]);
+    if (method === 'POST' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/))) return (req, res) => handleToolUpdate(req, res, m[1]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/))) return (req, res) => handleToolHistory(req, res, m[1]);
+    return null;
+  };
+
+  async function handleToolStatus(req, res, toolId) {
+    const dbStatus = queries.getToolStatus(toolId);
+    const tmStatus = toolManager.checkToolStatus(toolId);
+    if (!tmStatus && !dbStatus) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
+    const status = {
+      toolId, installed: tmStatus?.installed || (dbStatus?.status === 'installed'),
+      isUpToDate: tmStatus?.isUpToDate || false, upgradeNeeded: tmStatus?.upgradeNeeded || false,
+      status: dbStatus?.status || (tmStatus?.installed ? 'installed' : 'not_installed'),
+      installedVersion: dbStatus?.version || tmStatus?.installedVersion || null,
+      timestamp: Date.now(), error_message: dbStatus?.error_message || null
+    };
+    if (status.installed) { const updates = await toolManager.checkForUpdates(toolId); status.hasUpdate = updates.needsUpdate || false; }
+    sendJSON(req, res, 200, status);
+  }
+
+  async function handleToolInstall(req, res, toolId) {
+    const tool = toolManager.getToolConfig(toolId);
+    if (!tool) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
+    const existing = queries.getToolStatus(toolId);
+    if (!existing) queries.insertToolInstallation(toolId, { status: 'not_installed' });
+    queries.updateToolStatus(toolId, { status: 'installing' });
+    sendJSON(req, res, 200, { success: true, installing: true, estimatedTime: 60000 });
+    let done = false;
+    const timeout = setTimeout(() => {
+      if (!done) { done = true; queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Install timeout after 6 minutes' }); broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error: 'Install timeout after 6 minutes' } }); queries.addToolInstallHistory(toolId, 'install', 'failed', 'Install timeout after 6 minutes'); }
+    }, 360000);
+    toolManager.install(toolId, (msg) => broadcastSync({ type: 'tool_install_progress', toolId, data: msg })).then(async (result) => {
+      clearTimeout(timeout); if (done) return; done = true;
+      if (result.success) {
+        const version = result.version || null;
+        queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
+        const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+        broadcastSync({ type: 'tool_install_complete', toolId, data: { success: true, version, ...freshStatus } });
+        queries.addToolInstallHistory(toolId, 'install', 'success', null);
+      } else {
+        queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+        broadcastSync({ type: 'tool_install_failed', toolId, data: result });
+        queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
+      }
+    }).catch((err) => {
+      clearTimeout(timeout); if (done) return; done = true;
+      const error = err?.message || 'Unknown error';
+      logError('toolInstall', err, { toolId });
+      queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
+      broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error } });
+      queries.addToolInstallHistory(toolId, 'install', 'failed', error);
+    });
+  }
+
+  async function handleToolUpdate(req, res, toolId) {
+    const body = await parseBody(req);
+    const tool = toolManager.getToolConfig(toolId);
+    if (!tool) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
+    const current = await toolManager.checkToolStatusAsync(toolId);
+    if (!current || !current.installed) { sendJSON(req, res, 400, { error: 'Tool not installed' }); return; }
+    queries.updateToolStatus(toolId, { status: 'updating' });
+    sendJSON(req, res, 200, { success: true, updating: true });
+    let done = false;
+    const timeout = setTimeout(() => {
+      if (!done) { done = true; queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Update timeout after 6 minutes' }); broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: 'Update timeout after 6 minutes' } }); queries.addToolInstallHistory(toolId, 'update', 'failed', 'Update timeout after 6 minutes'); }
+    }, 360000);
+    toolManager.update(toolId, (msg) => broadcastSync({ type: 'tool_update_progress', toolId, data: msg })).then(async (result) => {
+      clearTimeout(timeout); if (done) return; done = true;
+      if (result.success) {
+        const version = result.version || null;
+        queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
+        const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+        broadcastSync({ type: 'tool_update_complete', toolId, data: { success: true, version, ...freshStatus } });
+        queries.addToolInstallHistory(toolId, 'update', 'success', null);
+      } else {
+        queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+        broadcastSync({ type: 'tool_update_failed', toolId, data: result });
+        queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
+      }
+    }).catch((err) => {
+      clearTimeout(timeout); if (done) return; done = true;
+      const error = err?.message || 'Unknown error';
+      logError('toolUpdate', err, { toolId });
+      queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
+      broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error } });
+      queries.addToolInstallHistory(toolId, 'update', 'failed', error);
+    });
+  }
+
+  async function handleToolHistory(req, res, toolId) {
+    const url = new URL(req.url, 'http://localhost');
+    const limit = Math.min(parseInt(url.searchParams.get('limit')) || 20, 100);
+    const offset = parseInt(url.searchParams.get('offset')) || 0;
+    sendJSON(req, res, 200, { history: queries.getToolInstallHistory(toolId, limit, offset) });
+  }
+
+  return routes;
+}

package/package.json

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

package/server.js

@@ -22,6 +22,7 @@ import { initSpeechManager, getSpeech, ensurePocketTtsSetup, voiceCacheManager,
 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 { 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';
@@ -1278,264 +1279,8 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/tools' && req.method === 'GET') {
-      console.log('[TOOLS-API] Handling GET /api/tools');
-      try {
-        // Return immediately with cached data (non-blocking) - skip network version checks
-        const tools = await Promise.race([
-          toolManager.getAllToolsAsync(true), // skipPublishedVersion=true for fast response
-          new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000))
-        ]);
-        const result = tools.map((t) => ({
-          id: t.id,
-          name: t.name,
-          pkg: t.pkg,
-          category: t.category || 'plugin',
-          installed: t.installed,
-          status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
-          isUpToDate: t.isUpToDate,
-          upgradeNeeded: t.upgradeNeeded,
-          hasUpdate: t.upgradeNeeded && t.installed,
-          installedVersion: t.installedVersion,
-          publishedVersion: t.publishedVersion,
-          machineState: toolInstallMachine.getState(t.id),
-        }));
-        sendJSON(req, res, 200, { tools: result });
-      } catch (err) {
-        console.log('[TOOLS-API] Error getting tools, returning cached status:', err.message);
-        const tools = toolManager.getAllToolsSync().map((t) => ({
-          id: t.id,
-          name: t.name,
-          pkg: t.pkg,
-          category: t.category || 'plugin',
-          installed: t.installed || false,
-          status: (t.installed) ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
-          isUpToDate: t.isUpToDate || false,
-          upgradeNeeded: t.upgradeNeeded || false,
-          hasUpdate: (t.upgradeNeeded && t.installed) || false,
-          installedVersion: t.installedVersion || null,
-          publishedVersion: t.publishedVersion || null,
-          machineState: toolInstallMachine.getState(t.id),
-        }));
-        sendJSON(req, res, 200, { tools });
-      }
-      return;
-    }
-
-    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)) {
-      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)[1];
-      const dbStatus = queries.getToolStatus(toolId);
-      const tmStatus = toolManager.checkToolStatus(toolId);
-      if (!tmStatus && !dbStatus) {
-        sendJSON(req, res, 404, { error: 'Tool not found' });
-        return;
-      }
-
-      // Merge database status with tool manager status
-      const status = {
-        toolId,
-        installed: tmStatus?.installed || (dbStatus?.status === 'installed'),
-        isUpToDate: tmStatus?.isUpToDate || false,
-        upgradeNeeded: tmStatus?.upgradeNeeded || false,
-        status: dbStatus?.status || (tmStatus?.installed ? 'installed' : 'not_installed'),
-        installedVersion: dbStatus?.version || tmStatus?.installedVersion || null,
-        timestamp: Date.now(),
-        error_message: dbStatus?.error_message || null
-      };
-
-      if (status.installed) {
-        const updates = await toolManager.checkForUpdates(toolId);
-        status.hasUpdate = updates.needsUpdate || false;
-      }
-      sendJSON(req, res, 200, status);
-      return;
-    }
-
-    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/) && req.method === 'POST') {
-      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/)[1];
-      const tool = toolManager.getToolConfig(toolId);
-      if (!tool) {
-        sendJSON(req, res, 404, { error: 'Tool not found' });
-        return;
-      }
-      const existing = queries.getToolStatus(toolId);
-      if (!existing) {
-        queries.insertToolInstallation(toolId, { status: 'not_installed' });
-      }
-      queries.updateToolStatus(toolId, { status: 'installing' });
-      sendJSON(req, res, 200, { success: true, installing: true, estimatedTime: 60000 });
-
-      let installCompleted = false;
-      const installTimeout = setTimeout(() => {
-        if (!installCompleted) {
-          installCompleted = true;
-          queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Install timeout after 6 minutes' });
-          broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error: 'Install timeout after 6 minutes' } });
-          queries.addToolInstallHistory(toolId, 'install', 'failed', 'Install timeout after 6 minutes');
-        }
-      }, 360000);
-
-      toolManager.install(toolId, (msg) => {
-        broadcastSync({ type: 'tool_install_progress', toolId, data: msg });
-      }).then(async (result) => {
-        clearTimeout(installTimeout);
-        if (installCompleted) return;
-        installCompleted = true;
-        if (result.success) {
-          const version = result.version || null;
-          console.log(`[TOOLS-API] Install succeeded for ${toolId}, version: ${version}`);
-          queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-          const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-          console.log(`[TOOLS-API] Fresh status after install for ${toolId}:`, JSON.stringify(freshStatus));
-          broadcastSync({ type: 'tool_install_complete', toolId, data: { success: true, version, ...freshStatus } });
-          queries.addToolInstallHistory(toolId, 'install', 'success', null);
-        } else {
-          console.error(`[TOOLS-API] Install failed for ${toolId}:`, result.error);
-          queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-          broadcastSync({ type: 'tool_install_failed', toolId, data: result });
-          queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
-        }
-      }).catch((err) => {
-        clearTimeout(installTimeout);
-        if (installCompleted) return;
-        installCompleted = true;
-        const error = err?.message || 'Unknown error';
-        console.error(`[TOOLS-API] Install error for ${toolId}:`, error);
-        logError('toolInstall', err, { toolId });
-        queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-        broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error } });
-        queries.addToolInstallHistory(toolId, 'install', 'failed', error);
-      });
-      return;
-    }
-
-    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/) && req.method === 'POST') {
-      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/)[1];
-      const body = await parseBody(req);
-      const tool = toolManager.getToolConfig(toolId);
-      if (!tool) {
-        sendJSON(req, res, 404, { error: 'Tool not found' });
-        return;
-      }
-      const current = await toolManager.checkToolStatusAsync(toolId);
-      if (!current || !current.installed) {
-        sendJSON(req, res, 400, { error: 'Tool not installed' });
-        return;
-      }
-      queries.updateToolStatus(toolId, { status: 'updating' });
-      sendJSON(req, res, 200, { success: true, updating: true });
-
-      let updateCompleted = false;
-      const updateTimeout = setTimeout(() => {
-        if (!updateCompleted) {
-          updateCompleted = true;
-          queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Update timeout after 6 minutes' });
-          broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: 'Update timeout after 6 minutes' } });
-          queries.addToolInstallHistory(toolId, 'update', 'failed', 'Update timeout after 6 minutes');
-        }
-      }, 360000);
-
-      toolManager.update(toolId, (msg) => {
-        broadcastSync({ type: 'tool_update_progress', toolId, data: msg });
-      }).then(async (result) => {
-        clearTimeout(updateTimeout);
-        if (updateCompleted) return;
-        updateCompleted = true;
-        if (result.success) {
-          const version = result.version || null;
-          console.log(`[TOOLS-API] Update succeeded for ${toolId}, version: ${version}`);
-          queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-          const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-          console.log(`[TOOLS-API] Fresh status after update for ${toolId}:`, JSON.stringify(freshStatus));
-          broadcastSync({ type: 'tool_update_complete', toolId, data: { success: true, version, ...freshStatus } });
-          queries.addToolInstallHistory(toolId, 'update', 'success', null);
-        } else {
-          console.error(`[TOOLS-API] Update failed for ${toolId}:`, result.error);
-          queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-          broadcastSync({ type: 'tool_update_failed', toolId, data: result });
-          queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
-        }
-      }).catch((err) => {
-        clearTimeout(updateTimeout);
-        if (updateCompleted) return;
-        updateCompleted = true;
-        const error = err?.message || 'Unknown error';
-        console.error(`[TOOLS-API] Update error for ${toolId}:`, error);
-        logError('toolUpdate', err, { toolId });
-        queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-        broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error } });
-        queries.addToolInstallHistory(toolId, 'update', 'failed', error);
-      });
-      return;
-    }
-
-    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/) && req.method === 'GET') {
-      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/)[1];
-      const url = new URL(req.url, 'http://localhost');
-      const limit = Math.min(parseInt(url.searchParams.get('limit')) || 20, 100);
-      const offset = parseInt(url.searchParams.get('offset')) || 0;
-      const history = queries.getToolInstallHistory(toolId, limit, offset);
-      sendJSON(req, res, 200, { history });
-      return;
-    }
-
-    if (pathOnly === '/api/tools/update' && req.method === 'POST') {
-      const allToolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
-      sendJSON(req, res, 200, { updating: true, toolCount: allToolIds.length });
-      broadcastSync({ type: 'tools_update_started', tools: allToolIds });
-      setImmediate(async () => {
-        const toolIds = allToolIds;
-        const results = {};
-        for (const toolId of toolIds) {
-          try {
-            const result = await toolManager.update(toolId, (msg) => {
-              broadcastSync({ type: 'tool_update_progress', toolId, data: msg });
-            });
-            results[toolId] = result;
-            if (result.success) {
-              const version = result.version || null;
-              queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-              queries.addToolInstallHistory(toolId, 'update', 'success', null);
-              const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-              broadcastSync({ type: 'tool_update_complete', toolId, data: { ...result, ...freshStatus } });
-            } else {
-              queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-              queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
-              broadcastSync({ type: 'tool_update_failed', toolId, data: result });
-            }
-          } catch (err) {
-            queries.updateToolStatus(toolId, { status: 'failed', error_message: err.message });
-            queries.addToolInstallHistory(toolId, 'update', 'failed', err.message);
-            broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: err.message } });
-          }
-        }
-        broadcastSync({ type: 'tools_update_complete', data: results });
-      });
-      return;
-    }
-
-    if (pathOnly === '/api/tools/refresh-all' && req.method === 'POST') {
-      sendJSON(req, res, 200, { refreshing: true, toolCount: 4 });
-      broadcastSync({ type: 'tools_refresh_started' });
-      setImmediate(async () => {
-        const tools = toolManager.getAllTools();
-        for (const tool of tools) {
-          queries.updateToolStatus(tool.id, {
-            status: tool.installed ? 'installed' : 'not_installed',
-            version: tool.installedVersion,
-            last_check_at: Date.now()
-          });
-          if (tool.installed) {
-            const status = await toolManager.checkToolStatusAsync(tool.id);
-            if (status && status.upgradeNeeded) {
-              queries.updateToolStatus(tool.id, { update_available: 1, latest_version: status.publishedVersion });
-            }
-          }
-        }
-        broadcastSync({ type: 'tools_refresh_complete', data: tools });
-      });
-      return;
-    }
+    const toolHandler = _toolRoutes._match(req.method, pathOnly);
+    if (toolHandler) { await toolHandler(req, res); return; }
 
     if (pathOnly === '/api/ws-stats' && req.method === 'GET') {
       const stats = wsOptimizer.getStats();
@@ -3326,6 +3071,7 @@ initSpeechManager({ broadcastSync, syncClients, queries });
 const _speechRoutes = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync, debugLog });
 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 });
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,