agentgui 1.0.846 → 1.0.847

package/CHANGELOG.md

@@ -1,9 +1,10 @@
-## [Unreleased] - refactor: extract http handler + startup functions
+## [Unreleased] - refactor: extract routes registry + wire tool/debug routes
 
-- Extract HTTP request handler to lib/http-handler.js (createHttpHandler factory, 134L)
-- Extract startup functions to lib/server-startup.js (createOnServerReady, 117L) and lib/server-startup2.js (createAutoImport, createDbRecovery, createPluginLoader, 84L)
-- server.js reduced from ~575L to 337L; all lib files ≤200L
-- Route registrations populate _routes object for lazy getter pattern in http-handler
+- Extract all route and WS handler registrations from server.js L201-270 to lib/routes-registry.js (63L, createRegistry factory)
+- Move BROADCAST_TYPES set to lib/broadcast.js as exported const; server.js imports it
+- Refactor http-handler.js to accept routes object (routes.conv, routes.tools, routes.debug etc.) instead of individual named parameters; wire previously-unwired tool and debug routes
+- Inline _mqDeps object into createMessageQueue call; compact process.on error handlers
+- server.js reduced from 337L to 200L; all lib files ≤200L
 
 
 ## [Unreleased]

package/lib/broadcast.js

@@ -1,3 +1,20 @@
+export const BROADCAST_TYPES = new Set([
+  'message_created', 'conversation_created', 'conversation_updated',
+  'conversations_updated', 'conversation_deleted', 'all_conversations_deleted', 'queue_status', 'queue_updated', 'queue_item_dequeued',
+  'rate_limit_hit', 'rate_limit_clear',
+  'script_started', 'script_stopped', 'script_output',
+  'model_download_progress', 'stt_progress', 'tts_setup_progress', 'voice_list',
+  'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error',
+  'tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed',
+  'tool_update_progress', 'tool_update_complete', 'tool_update_failed',
+  'tool_status_update', 'tool_update_available',
+  'tools_update_started', 'tools_update_complete', 'tools_refresh_complete',
+  'pm2_monit_update', 'pm2_monitoring_started', 'pm2_monitoring_stopped',
+  'pm2_list_response', 'pm2_start_response', 'pm2_stop_response',
+  'pm2_restart_response', 'pm2_delete_response', 'pm2_logs_response',
+  'pm2_flush_logs_response', 'pm2_ping_response', 'pm2_unavailable'
+]);
+
 export function createBroadcast({ syncClients, subscriptionIndex, wsOptimizer, broadcastTypes, getSeq }) {
   return function broadcastSync(event) {
     try {

package/lib/http-handler.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 
-export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, convRoutes, messagesRoutes, sessionsRoutes, scriptsRoutes, runsRoutes, agentRoutes, oauthRoutes, agentActionsRoutes, authConfigRoutes, speechRoutes, utilRoutes, threadRoutes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }) {
+export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }) {
   return async function httpHandler(req, res) {
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
@@ -68,30 +68,34 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
         return;
       }
 
-      const convHandler = convRoutes._match(req.method, pathOnly);
+      const convHandler = routes.conv._match(req.method, pathOnly);
       if (convHandler) { await convHandler(req, res); return; }
-      const messagesHandler = messagesRoutes._match(req.method, pathOnly);
+      const messagesHandler = routes.messages._match(req.method, pathOnly);
       if (messagesHandler) { await messagesHandler(req, res); return; }
-      const sessionsHandler = sessionsRoutes._match(req.method, pathOnly);
+      const sessionsHandler = routes.sessions._match(req.method, pathOnly);
       if (sessionsHandler) { await sessionsHandler(req, res); return; }
-      const scriptsHandler = scriptsRoutes._match(req.method, pathOnly);
+      const scriptsHandler = routes.scripts._match(req.method, pathOnly);
       if (scriptsHandler) { await scriptsHandler(req, res); return; }
-      const runsHandler = runsRoutes._match(req.method, pathOnly);
+      const runsHandler = routes.runs._match(req.method, pathOnly);
       if (runsHandler) { await runsHandler(req, res); return; }
-      const agentHandler = agentRoutes._match(req.method, pathOnly);
+      const agentHandler = routes.agents._match(req.method, pathOnly);
       if (agentHandler) { await agentHandler(req, res); return; }
-      const oauthHandler = oauthRoutes._match(req.method, pathOnly);
+      const oauthHandler = routes.oauth._match(req.method, pathOnly);
       if (oauthHandler) { await oauthHandler(req, res); return; }
-      const agentActionsHandler = agentActionsRoutes._match(req.method, pathOnly);
+      const agentActionsHandler = routes.agentActions._match(req.method, pathOnly);
       if (agentActionsHandler) { await agentActionsHandler(req, res); return; }
-      const authConfigHandler = authConfigRoutes._match(req.method, pathOnly);
+      const authConfigHandler = routes.authConfig._match(req.method, pathOnly);
       if (authConfigHandler) { await authConfigHandler(req, res); return; }
-      const speechHandler = speechRoutes._match(req.method, pathOnly);
+      const speechHandler = routes.speech._match(req.method, pathOnly);
       if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
-      const utilHandler = utilRoutes._match(req.method, pathOnly);
+      const utilHandler = routes.util._match(req.method, pathOnly);
       if (utilHandler) { await utilHandler(req, res); return; }
-      const threadHandler = threadRoutes._match(req.method, pathOnly);
+      const threadHandler = routes.threads._match(req.method, pathOnly);
       if (threadHandler) { await threadHandler(req, res); return; }
+      const toolHandler = routes.tools._match(req.method, pathOnly);
+      if (toolHandler) { await toolHandler(req, res); return; }
+      const debugHandler = routes.debug._match(req.method, pathOnly);
+      if (debugHandler) { await debugHandler(req, res); return; }
       if (routePath.startsWith('/api/image/')) {
         const imagePath = routePath.slice('/api/image/'.length);
         const decodedPath = decodeURIComponent(imagePath);

package/lib/routes-registry.js

@@ -0,0 +1,62 @@
+import { register as registerSpeechRoutes } from './routes-speech.js';
+import { register as registerOAuthRoutes } from './routes-oauth.js';
+import { register as registerUtilRoutes } from './routes-util.js';
+import { register as registerToolRoutes } from './routes-tools.js';
+import { register as registerThreadRoutes } from './routes-threads.js';
+import { register as registerDebugRoutes } from './routes-debug.js';
+import { register as registerConvRoutes } from './routes-conversations.js';
+import { register as registerAgentRoutes } from './routes-agents.js';
+import { register as registerMessagesRoutes } from './routes-messages.js';
+import { register as registerSessionsRoutes } from './routes-sessions.js';
+import { register as registerRunsRoutes } from './routes-runs.js';
+import { register as registerScriptsRoutes } from './routes-scripts.js';
+import { register as registerAgentActionsRoutes } from './routes-agent-actions.js';
+import { register as registerAuthConfigRoutes } from './routes-auth-config.js';
+import { register as registerConvHandlers } from './ws-handlers-conv.js';
+import { register as registerConvHandlers2 } from './ws-handlers-conv2.js';
+import { register as registerSessionHandlers } from './ws-handlers-session.js';
+import { register as registerSessionHandlers2 } from './ws-handlers-session2.js';
+import { register as registerRunHandlers } from './ws-handlers-run.js';
+import { register as registerUtilHandlers } from './ws-handlers-util.js';
+import { register as registerOAuthHandlers } from './ws-handlers-oauth.js';
+import { register as registerScriptHandlers } from './ws-handlers-scripts.js';
+import { register as registerQueueHandlers } from './ws-handlers-queue.js';
+import { register as registerMsgHandlers } from './ws-handlers-msg.js';
+import { initSpeechManager, getSpeech, voiceCacheManager, modelDownloadState, ensureModelsDownloaded } from './speech-manager.js';
+import { getAgentDescriptor } from './agent-descriptors.js';
+import { startGeminiOAuth, exchangeGeminiOAuthCode, getGeminiOAuthState } from './oauth-gemini.js';
+import { startCodexOAuth, exchangeCodexOAuthCode, getCodexOAuthState } from './oauth-codex.js';
+import { getProviderConfigs, saveProviderConfig } from './provider-config.js';
+
+export function createRegistry(wsRouter, deps) {
+  const { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, toolManager, syncClients, wsOptimizer, errLogPath, getJsonlWatcher, routes } = deps;
+
+  initSpeechManager({ broadcastSync, syncClients, queries });
+  routes.speech = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync, debugLog });
+  routes.oauth = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL, rootDir });
+  routes.util = registerUtilRoutes({ sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION });
+  routes.tools = registerToolRoutes({ sendJSON, parseBody, queries, broadcastSync, logError, toolManager });
+  routes.threads = registerThreadRoutes({ sendJSON, parseBody, queries });
+  routes.debug = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath: errLogPath });
+  routes.conv = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
+  routes.agents = registerAgentRoutes({ sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog });
+  routes.messages = registerMessagesRoutes({ queries, sendJSON, parseBody, broadcastSync, processMessageWithStreaming, activeExecutions, messageQueues, debugLog, logError });
+  routes.sessions = registerSessionsRoutes({ queries, sendJSON, activeExecutions, rateLimitState, debugLog });
+  routes.runs = registerRunsRoutes({ sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD });
+  routes.scripts = registerScriptsRoutes({ sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD });
+  routes.agentActions = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir });
+  routes.authConfig = registerAuthConfigRoutes({ sendJSON, parseBody, getProviderConfigs, saveProviderConfig });
+
+  registerConvHandlers(wsRouter, { queries, activeExecutions, rateLimitState, broadcastSync, processMessageWithStreaming, cleanupExecution, getJsonlWatcher });
+  registerConvHandlers2(wsRouter, { queries, activeExecutions, rateLimitState, broadcastSync, processMessageWithStreaming, cleanupExecution, getJsonlWatcher });
+  registerMsgHandlers(wsRouter, { queries, activeExecutions, messageQueues, broadcastSync, processMessageWithStreaming, logError });
+  registerQueueHandlers(wsRouter, { queries, messageQueues, broadcastSync });
+  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 });
+  registerSessionHandlers2(wsRouter, { discoveredAgents, modelCache, activeScripts, broadcastSync, startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), geminiOAuthState: getGeminiOAuthState });
+  debugLog('[INIT] registerSessionHandlers completed');
+  registerRunHandlers(wsRouter, { queries, discoveredAgents, activeExecutions, activeProcessesByRunId, broadcastSync, processMessageWithStreaming, cleanupExecution });
+  registerUtilHandlers(wsRouter, { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded, broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig, STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents });
+  registerScriptHandlers(wsRouter, { queries, broadcastSync, STARTUP_CWD, activeScripts });
+  registerOAuthHandlers(wsRouter, { startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), exchangeGeminiOAuthCode, geminiOAuthState: getGeminiOAuthState, startCodexOAuth: (req) => startCodexOAuth(req, { PORT, BASE_URL }), exchangeCodexOAuthCode, codexOAuthState: getCodexOAuthState });
+}

package/package.json

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

package/server.js

@@ -11,20 +11,8 @@ import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descripto
 import { discoverExternalACPServers, initializeAgentDiscovery } from './lib/agent-discovery.js';
 import { startGeminiOAuth, exchangeGeminiOAuthCode, handleGeminiOAuthCallback, getGeminiOAuthStatus, getGeminiOAuthState } from './lib/oauth-gemini.js';
 import { initSpeechManager, getSpeech, voiceCacheManager, modelDownloadState, 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 { register as registerThreadRoutes } from './lib/routes-threads.js';
-import { register as registerDebugRoutes } from './lib/routes-debug.js';
-import { register as registerConvRoutes } from './lib/routes-conversations.js';
-import { register as registerAgentRoutes } from './lib/routes-agents.js';
-import { register as registerMessagesRoutes } from './lib/routes-messages.js';
-import { register as registerSessionsRoutes } from './lib/routes-sessions.js';
-import { register as registerRunsRoutes } from './lib/routes-runs.js';
-import { register as registerScriptsRoutes } from './lib/routes-scripts.js';
-import { register as registerAgentActionsRoutes } from './lib/routes-agent-actions.js';
-import { register as registerAuthConfigRoutes } from './lib/routes-auth-config.js';
+import { createRegistry } from './lib/routes-registry.js';
+import { BROADCAST_TYPES } from './lib/broadcast.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';
@@ -35,16 +23,6 @@ import { createHttpHandler } from './lib/http-handler.js';
 import { createOnServerReady } from './lib/server-startup.js';
 import { createAutoImport, createDbRecovery, createPluginLoader } from './lib/server-startup2.js';
 const sendWs = (ws, obj) => { if (ws.readyState === 1) ws.send(wsEncode(obj)); };
-import { register as registerConvHandlers } from './lib/ws-handlers-conv.js';
-import { register as registerConvHandlers2 } from './lib/ws-handlers-conv2.js';
-import { register as registerSessionHandlers } from './lib/ws-handlers-session.js';
-import { register as registerSessionHandlers2 } from './lib/ws-handlers-session2.js';
-import { register as registerRunHandlers } from './lib/ws-handlers-run.js';
-import { register as registerUtilHandlers } from './lib/ws-handlers-util.js';
-import { register as registerOAuthHandlers } from './lib/ws-handlers-oauth.js';
-import { register as registerScriptHandlers } from './lib/ws-handlers-scripts.js';
-import { register as registerQueueHandlers } from './lib/ws-handlers-queue.js';
-import { register as registerMsgHandlers } from './lib/ws-handlers-msg.js';
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
 import * as toolInstallMachine from './lib/tool-install-machine.js';
@@ -63,15 +41,9 @@ import { buildSystemPrompt, getProviderConfigs, saveProviderConfig } from './lib
 import { logError, errLogPath, makeCleanupExecution, makeGetModelsForAgent } from './lib/server-utils.js';
 
 
-process.on('uncaughtException', (err, origin) => {
-  console.error('[FATAL] Uncaught exception (contained):', err.message, '| origin:', origin);
-  console.error(err.stack);
-});
+process.on('uncaughtException', (err, origin) => { console.error('[FATAL] Uncaught exception:', err.message, '| origin:', origin); console.error(err.stack); });
 
-process.on('unhandledRejection', (reason, promise) => {
-  console.error('[FATAL] Unhandled rejection (contained):', reason instanceof Error ? reason.message : reason);
-  if (reason instanceof Error) console.error(reason.stack);
-});
+process.on('unhandledRejection', (reason) => { console.error('[FATAL] Unhandled rejection:', reason instanceof Error ? reason.message : reason); if (reason instanceof Error) console.error(reason.stack); });
 
 process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - uncrashable)'); });
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
@@ -86,7 +58,6 @@ const activeProcessesByRunId = new Map();
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 1800000;
 const NO_PID_GRACE_PERIOD_MS = 60000;
-const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 60000;
 
 const debugLog = (msg) => {
   const timestamp = new Date().toISOString();
@@ -127,47 +98,13 @@ const _assetDeps = { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERS
 function serveFile(filePath, res, req) { return _serveFile(filePath, res, req, _assetDeps); }
 
 const _routes = {};
-const server = http.createServer(createHttpHandler({
-  BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues,
-  get wss() { return wss; }, activeExecutions, getACPStatus, discoveredAgents,
-  PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap,
-  get convRoutes() { return _routes.conv; },
-  get messagesRoutes() { return _routes.messages; },
-  get sessionsRoutes() { return _routes.sessions; },
-  get scriptsRoutes() { return _routes.scripts; },
-  get runsRoutes() { return _routes.runs; },
-  get agentRoutes() { return _routes.agents; },
-  get oauthRoutes() { return _routes.oauth; },
-  get agentActionsRoutes() { return _routes.agentActions; },
-  get authConfigRoutes() { return _routes.authConfig; },
-  get speechRoutes() { return _routes.speech; },
-  get utilRoutes() { return _routes.util; },
-  get threadRoutes() { return _routes.threads; },
-  handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT
-}));
+const server = http.createServer(createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, get wss() { return wss; }, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap, routes: _routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }));
 
 let broadcastSeq = 0;
 const syncClients = new Set();
 const subscriptionIndex = new Map();
 const pm2Subscribers = new Set();
 
-const BROADCAST_TYPES = new Set([
-  'message_created', 'conversation_created', 'conversation_updated',
-  'conversations_updated', 'conversation_deleted', 'all_conversations_deleted', 'queue_status', 'queue_updated', 'queue_item_dequeued',
-  'rate_limit_hit', 'rate_limit_clear',
-  'script_started', 'script_stopped', 'script_output',
-  'model_download_progress', 'stt_progress', 'tts_setup_progress', 'voice_list',
-  'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error',
-  'tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed',
-  'tool_update_progress', 'tool_update_complete', 'tool_update_failed',
-  'tool_status_update', 'tool_update_available',
-  'tools_update_started', 'tools_update_complete', 'tools_refresh_complete',
-  'pm2_monit_update', 'pm2_monitoring_started', 'pm2_monitoring_stopped',
-  'pm2_list_response', 'pm2_start_response', 'pm2_stop_response',
-  'pm2_restart_response', 'pm2_delete_response', 'pm2_logs_response',
-  'pm2_flush_logs_response', 'pm2_ping_response', 'pm2_unavailable'
-]);
-
 const wsOptimizer = new WSOptimizer();
 
 const broadcastSync = createBroadcast({
@@ -179,13 +116,7 @@ const broadcastSync = createBroadcast({
 });
 
 const cleanupExecution = makeCleanupExecution({ execMachine, activeExecutions, queries, broadcastSync, debugLog });
-
-const _mqDeps = {
-  queries, messageQueues, activeExecutions, rateLimitState, execMachine,
-  broadcastSync, cleanupExecution, debugLog,
-  getProcessMessageWithStreaming: () => processMessageWithStreaming
-};
-const { scheduleRetry, drainMessageQueue } = createMessageQueue(_mqDeps);
+const { scheduleRetry, drainMessageQueue } = createMessageQueue({ queries, messageQueues, activeExecutions, rateLimitState, execMachine, broadcastSync, cleanupExecution, debugLog, getProcessMessageWithStreaming: () => processMessageWithStreaming });
 
 const { processMessageWithStreaming } = createProcessMessage({
   queries, activeExecutions, rateLimitState, execMachine,
@@ -197,76 +128,8 @@ const { processMessageWithStreaming } = createProcessMessage({
 });
 
 const wsRouter = new WsRouter();
+createRegistry(wsRouter, { queries, sendJSON, parseBody, broadcastSync, debugLog, PORT, BASE_URL, rootDir, STARTUP_CWD, PKG_VERSION, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, activeScripts, messageQueues, rateLimitState, cleanupExecution, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, logError, toolManager, syncClients, wsOptimizer, errLogPath, getJsonlWatcher: () => getJsonlWatcher(), routes: _routes });
 
-initSpeechManager({ broadcastSync, syncClients, queries });
-_routes.speech = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync, debugLog });
-_routes.oauth = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL, rootDir });
-_routes.util = registerUtilRoutes({ sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION });
-const _toolRoutes = registerToolRoutes({ sendJSON, parseBody, queries, broadcastSync, logError, toolManager });
-_routes.threads = registerThreadRoutes({ sendJSON, parseBody, queries });
-const _debugRoutes = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath: errLogPath });
-_routes.conv = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
-_routes.agents = registerAgentRoutes({ sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog });
-_routes.messages = registerMessagesRoutes({ queries, sendJSON, parseBody, broadcastSync, processMessageWithStreaming, activeExecutions, messageQueues, debugLog, logError });
-_routes.sessions = registerSessionsRoutes({ queries, sendJSON, activeExecutions, rateLimitState, debugLog });
-_routes.runs = registerRunsRoutes({ sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD });
-_routes.scripts = registerScriptsRoutes({ sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD });
-_routes.agentActions = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir });
-_routes.authConfig = registerAuthConfigRoutes({ sendJSON, parseBody, getProviderConfigs, saveProviderConfig });
-
-registerConvHandlers(wsRouter, {
-  queries, activeExecutions, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution,
-  getJsonlWatcher
-});
-registerConvHandlers2(wsRouter, {
-  queries, activeExecutions, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution,
-  getJsonlWatcher
-});
-
-registerMsgHandlers(wsRouter, {
-  queries, activeExecutions, messageQueues,
-  broadcastSync, processMessageWithStreaming, logError
-});
-
-registerQueueHandlers(wsRouter, { queries, messageQueues, broadcastSync });
-
-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
-});
-registerSessionHandlers2(wsRouter, {
-  discoveredAgents, modelCache, activeScripts, broadcastSync,
-  startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }), geminiOAuthState: getGeminiOAuthState
-});
-debugLog('[INIT] registerSessionHandlers completed');
-
-registerRunHandlers(wsRouter, {
-  queries, discoveredAgents, activeExecutions, activeProcessesByRunId,
-  broadcastSync, processMessageWithStreaming, cleanupExecution
-});
-
-registerUtilHandlers(wsRouter, {
-  queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
-  broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
-  STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents
-});
-
-registerScriptHandlers(wsRouter, {
-  queries, broadcastSync, STARTUP_CWD, activeScripts
-});
-
-registerOAuthHandlers(wsRouter, {
-  startGeminiOAuth: (req) => startGeminiOAuth(req, { PORT, BASE_URL, rootDir }),
-  exchangeGeminiOAuthCode,
-  geminiOAuthState: getGeminiOAuthState,
-  startCodexOAuth: (req) => startCodexOAuth(req, { PORT, BASE_URL }),
-  exchangeCodexOAuthCode,
-  codexOAuthState: getCodexOAuthState,
-});
 
 const { wss, hotReloadClients } = createWsSetup(server, {
   BASE_URL, watch, staticDir, _assetCache, htmlState, sendWs, wsRouter, debugLog,