agentgui 1.0.759 → 1.0.761

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/lib/routes-util.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+export function register(deps) {
+  const { sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION } = deps;
+  const routes = {};
+
+  routes['GET /api/import/claude-code'] = async (req, res) => {
+    const result = queries.importClaudeCodeConversations();
+    sendJSON(req, res, 200, { imported: result });
+  };
+
+  routes['GET /api/discover/claude-code'] = async (req, res) => {
+    const discovered = queries.discoverClaudeCodeConversations();
+    sendJSON(req, res, 200, { discovered });
+  };
+
+  routes['GET /api/home'] = async (req, res) => {
+    sendJSON(req, res, 200, { home: os.homedir(), cwd: STARTUP_CWD });
+  };
+
+  routes['GET /api/version'] = async (req, res) => {
+    sendJSON(req, res, 200, { version: PKG_VERSION });
+  };
+
+  routes['POST /api/clone'] = async (req, res) => {
+    const body = await parseBody(req);
+    const repo = (body.repo || '').trim();
+    if (!repo || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
+      sendJSON(req, res, 400, { error: 'Invalid repo format. Use org/repo or user/repo' });
+      return;
+    }
+    const cloneDir = STARTUP_CWD || os.homedir();
+    const repoName = repo.split('/')[1];
+    const targetPath = path.join(cloneDir, repoName);
+    if (fs.existsSync(targetPath)) {
+      sendJSON(req, res, 409, { error: `Directory already exists: ${repoName}`, path: targetPath });
+      return;
+    }
+    try {
+      const isWindows = os.platform() === 'win32';
+      execSync('git clone https://github.com/' + repo + '.git', {
+        cwd: cloneDir, encoding: 'utf-8', timeout: 120000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        shell: isWindows
+      });
+      sendJSON(req, res, 200, { ok: true, repo, path: targetPath, name: repoName });
+    } catch (err) {
+      sendJSON(req, res, 500, { error: (err.stderr || err.message || 'Clone failed').trim() });
+    }
+  };
+
+  routes['POST /api/folders'] = async (req, res) => {
+    const body = await parseBody(req);
+    const folderPath = body.path || STARTUP_CWD;
+    try {
+      const expandedPath = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
+      const entries = fs.readdirSync(expandedPath, { withFileTypes: true });
+      const folders = entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+        .map(e => ({ name: e.name }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+      sendJSON(req, res, 200, { folders });
+    } catch (err) {
+      sendJSON(req, res, 400, { error: err.message });
+    }
+  };
+
+  routes['GET /api/git/check-remote-ownership'] = async (req, res) => {
+    try {
+      const isWindows = os.platform() === 'win32';
+      const result = execSync('git remote get-url origin' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const remoteUrl = result.trim();
+      const statusResult = execSync('git status --porcelain' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasChanges = statusResult.trim().length > 0;
+      const unpushedResult = execSync('git rev-list --count --not --remotes' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
+      const ownsRemote = !remoteUrl.includes('github.com/') || remoteUrl.includes(process.env.GITHUB_USER || '');
+      sendJSON(req, res, 200, { ownsRemote, hasChanges, hasUnpushed, remoteUrl });
+    } catch {
+      sendJSON(req, res, 200, { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' });
+    }
+  };
+
+  routes['POST /api/git/push'] = async (req, res) => {
+    try {
+      const isWindows = os.platform() === 'win32';
+      const gitCommand = isWindows
+        ? 'git add -A & git commit -m "Auto-commit" & git push'
+        : 'git add -A && git commit -m "Auto-commit" && git push';
+      execSync(gitCommand, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      sendJSON(req, res, 200, { success: true });
+    } catch (err) {
+      sendJSON(req, res, 500, { error: err.message });
+    }
+  };
+
+  routes['_match'] = (method, pathOnly) => {
+    return routes[`${method} ${pathOnly}`] || null;
+  };
+
+  return routes;
+}

package/package.json

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

package/server.js

@@ -21,6 +21,8 @@ import { getGeminiOAuthCreds, startGeminiOAuth, exchangeGeminiOAuthCode, handleG
 import { initSpeechManager, getSpeech, ensurePocketTtsSetup, voiceCacheManager, modelDownloadState, broadcastModelProgress, ensureModelsDownloaded, eagerTTS } from './lib/speech-manager.js';
 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';
@@ -1277,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();
@@ -2175,113 +1921,12 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/import/claude-code' && req.method === 'GET') {
-      const result = queries.importClaudeCodeConversations();
-            sendJSON(req, res, 200, { imported: result });
-      return;
-    }
-
-    if (pathOnly === '/api/discover/claude-code' && req.method === 'GET') {
-      const discovered = queries.discoverClaudeCodeConversations();
-            sendJSON(req, res, 200, { discovered });
-      return;
-    }
-
-    if (pathOnly === '/api/home' && req.method === 'GET') {
-            sendJSON(req, res, 200, { home: os.homedir(), cwd: STARTUP_CWD });
-      return;
-    }
-
-    if (pathOnly === '/api/version' && req.method === 'GET') {
-      sendJSON(req, res, 200, { version: PKG_VERSION });
-      return;
-    }
-
     const speechHandler = _speechRoutes._match(req.method, pathOnly);
     if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
 
-    if (pathOnly === '/api/clone' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const repo = (body.repo || '').trim();
-      if (!repo || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
-        sendJSON(req, res, 400, { error: 'Invalid repo format. Use org/repo or user/repo' });
-        return;
-      }
-      const cloneDir = STARTUP_CWD || os.homedir();
-      const repoName = repo.split('/')[1];
-      const targetPath = path.join(cloneDir, repoName);
-      if (fs.existsSync(targetPath)) {
-        sendJSON(req, res, 409, { error: `Directory already exists: ${repoName}`, path: targetPath });
-        return;
-      }
-      try {
-        const isWindows = os.platform() === 'win32';
-        execSync('git clone https://github.com/' + repo + '.git', {
-          cwd: cloneDir,
-          encoding: 'utf-8',
-          timeout: 120000,
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-          shell: isWindows
-        });
-        sendJSON(req, res, 200, { ok: true, repo, path: targetPath, name: repoName });
-      } catch (err) {
-        const stderr = err.stderr || err.message || 'Clone failed';
-        sendJSON(req, res, 500, { error: stderr.trim() });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/folders' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const folderPath = body.path || STARTUP_CWD;
-      try {
-        const expandedPath = folderPath.startsWith('~') ?
-          folderPath.replace('~', os.homedir()) : folderPath;
-        const entries = fs.readdirSync(expandedPath, { withFileTypes: true });
-        const folders = entries
-          .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-          .map(e => ({ name: e.name }))
-          .sort((a, b) => a.name.localeCompare(b.name));
-                sendJSON(req, res, 200, { folders });
-      } catch (err) {
-                sendJSON(req, res, 400, { error: err.message });
-      }
-      return;
-    }
+    const utilHandler = _utilRoutes._match(req.method, pathOnly);
+    if (utilHandler) { await utilHandler(req, res); return; }
 
-    if (pathOnly === '/api/git/check-remote-ownership' && req.method === 'GET') {
-      try {
-        const isWindows = os.platform() === 'win32';
-        const result = execSync('git remote get-url origin' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-        const remoteUrl = result.trim();
-        const statusResult = execSync('git status --porcelain' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-        const hasChanges = statusResult.trim().length > 0;
-        const unpushedResult = execSync('git rev-list --count --not --remotes' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-        const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
-        const ownsRemote = !remoteUrl.includes('github.com/') || remoteUrl.includes(process.env.GITHUB_USER || '');
-        sendJSON(req, res, 200, { ownsRemote, hasChanges, hasUnpushed, remoteUrl });
-      } catch {
-        sendJSON(req, res, 200, { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/git/push' && req.method === 'POST') {
-      try {
-        const isWindows = os.platform() === 'win32';
-        const gitCommand = isWindows
-          ? 'git add -A & git commit -m "Auto-commit" & git push'
-          : 'git add -A && git commit -m "Auto-commit" && git push';
-        execSync(gitCommand, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-        sendJSON(req, res, 200, { success: true });
-      } catch (err) {
-        sendJSON(req, res, 500, { error: err.message });
-      }
-      return;
-    }
-
-    // ============================================================
     // THREAD API ENDPOINTS (ACP v0.2.3)
     // ============================================================
 
@@ -3425,6 +3070,8 @@ const wsRouter = new WsRouter();
 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,