agentgui 1.0.845 → 1.0.847

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [Unreleased] - refactor: extract routes registry + wire tool/debug routes
+
+- 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]
 
 ### Refactor

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

@@ -0,0 +1,137 @@
+import fs from 'fs';
+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, 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');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
+    if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') return;
+
+    const clientIp = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || req.socket.remoteAddress;
+    const hits = (rateLimitMap.get(clientIp) || 0) + 1;
+    rateLimitMap.set(clientIp, hits);
+    res.setHeader('X-RateLimit-Limit', RATE_LIMIT_MAX);
+    res.setHeader('X-RateLimit-Remaining', Math.max(0, RATE_LIMIT_MAX - hits));
+    if (hits > RATE_LIMIT_MAX) { res.writeHead(429, { 'Retry-After': '60' }); res.end('Too Many Requests'); return; }
+
+    const _pwd = process.env.PASSWORD;
+    if (_pwd) {
+      const _auth = req.headers['authorization'] || '';
+      let _ok = false;
+      if (_auth.startsWith('Basic ')) {
+        try {
+          const _decoded = Buffer.from(_auth.slice(6), 'base64').toString('utf8');
+          const _ci = _decoded.indexOf(':');
+          if (_ci !== -1) { const _p = _decoded.slice(_ci + 1); try { _ok = _p.length === _pwd.length && crypto.timingSafeEqual(Buffer.from(_p), Buffer.from(_pwd)); } catch { _ok = false; } }
+        } catch (_) {}
+      }
+      if (!_ok) { res.writeHead(401, { 'WWW-Authenticate': 'Basic realm="agentgui"' }); res.end('Unauthorized'); return; }
+    }
+
+    const pathOnly = req.url.split('?')[0];
+    if (pathOnly.startsWith(BASE_URL + '/api/upload/') || pathOnly.startsWith(BASE_URL + '/files/')) return expressApp(req, res);
+
+    if (req.url === '/favicon.ico' || req.url === BASE_URL + '/favicon.ico') {
+      const svg = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><rect width="100" height="100" rx="20" fill="#3b82f6"/><text x="50" y="68" font-size="50" font-family="sans-serif" font-weight="bold" fill="white" text-anchor="middle">G</text></svg>';
+      res.writeHead(200, { 'Content-Type': 'image/svg+xml', 'Cache-Control': 'public, max-age=86400' });
+      res.end(svg); return;
+    }
+
+    if (req.url === '/') { res.writeHead(302, { Location: BASE_URL + '/' }); res.end(); return; }
+
+    let routePath = req.url;
+    if (req.url.startsWith(BASE_URL + '/')) { routePath = req.url.slice(BASE_URL.length); }
+    else if (req.url === BASE_URL) { routePath = '/'; }
+    else if (req.url.startsWith('/api/') || req.url.startsWith('/js/') || req.url.startsWith('/css/') ||
+             req.url.startsWith('/vendor/') || req.url.startsWith('/sync') || req.url === '/' ||
+             req.url.startsWith('/conversations/')) { routePath = req.url; }
+    else { res.writeHead(404); res.end('Not found'); return; }
+
+    routePath = routePath || '/';
+
+    try {
+      const pathOnly = routePath.split('?')[0];
+
+      if (pathOnly === '/oauth2callback' && req.method === 'GET') { await handleGeminiOAuthCallback(req, res, PORT); return; }
+      if (pathOnly === '/codex-oauth2callback' && req.method === 'GET') { await handleCodexOAuthCallback(req, res, PORT); return; }
+
+      if (pathOnly === '/api/health' && req.method === 'GET') {
+        let dbStatus = { ok: true };
+        try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
+        const queueSizes = {};
+        for (const [k, v] of messageQueues) queueSizes[k] = v.length;
+        sendJSON(req, res, 200, { status: 'ok', version: PKG_VERSION, uptime: process.uptime(), agents: discoveredAgents.length, activeExecutions: activeExecutions.size, wsClients: wss.clients.size, memory: process.memoryUsage(), acp: getACPStatus(), db: dbStatus, queueSizes });
+        return;
+      }
+
+      const convHandler = routes.conv._match(req.method, pathOnly);
+      if (convHandler) { await convHandler(req, res); return; }
+      const messagesHandler = routes.messages._match(req.method, pathOnly);
+      if (messagesHandler) { await messagesHandler(req, res); return; }
+      const sessionsHandler = routes.sessions._match(req.method, pathOnly);
+      if (sessionsHandler) { await sessionsHandler(req, res); return; }
+      const scriptsHandler = routes.scripts._match(req.method, pathOnly);
+      if (scriptsHandler) { await scriptsHandler(req, res); return; }
+      const runsHandler = routes.runs._match(req.method, pathOnly);
+      if (runsHandler) { await runsHandler(req, res); return; }
+      const agentHandler = routes.agents._match(req.method, pathOnly);
+      if (agentHandler) { await agentHandler(req, res); return; }
+      const oauthHandler = routes.oauth._match(req.method, pathOnly);
+      if (oauthHandler) { await oauthHandler(req, res); return; }
+      const agentActionsHandler = routes.agentActions._match(req.method, pathOnly);
+      if (agentActionsHandler) { await agentActionsHandler(req, res); return; }
+      const authConfigHandler = routes.authConfig._match(req.method, pathOnly);
+      if (authConfigHandler) { await authConfigHandler(req, res); return; }
+      const speechHandler = routes.speech._match(req.method, pathOnly);
+      if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
+      const utilHandler = routes.util._match(req.method, pathOnly);
+      if (utilHandler) { await utilHandler(req, res); return; }
+      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);
+        const expandedPath = decodedPath.startsWith('~') ? decodedPath.replace('~', os.homedir()) : decodedPath;
+        const normalizedPath = path.normalize(expandedPath);
+        const isWindows = os.platform() === 'win32';
+        const isAbsolute = isWindows ? /^[A-Za-z]:[\\\/]/.test(normalizedPath) : normalizedPath.startsWith('/');
+        if (!isAbsolute || normalizedPath.includes('..')) { res.writeHead(403); res.end('Forbidden'); return; }
+        try {
+          if (!fs.existsSync(normalizedPath)) { res.writeHead(404); res.end('Not found'); return; }
+          const ext = path.extname(normalizedPath).toLowerCase();
+          const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml' };
+          const contentType = mimeTypes[ext] || 'application/octet-stream';
+          res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-cache' });
+          res.end(fs.readFileSync(normalizedPath));
+        } catch (err) { sendJSON(req, res, 400, { error: err.message }); }
+        return;
+      }
+
+      if (pathOnly.match(/^\/conversations\/[^\/]+$/)) { serveFile(path.join(staticDir, 'index.html'), res, req); return; }
+
+      let filePath = routePath === '/' ? '/index.html' : routePath;
+      filePath = path.join(staticDir, filePath);
+      const normalizedPath = path.normalize(filePath);
+      if (!normalizedPath.startsWith(staticDir)) { res.writeHead(403); res.end('Forbidden'); return; }
+
+      fs.stat(filePath, (err, stats) => {
+        if (err) { res.writeHead(404); res.end('Not found'); return; }
+        if (stats.isDirectory()) {
+          filePath = path.join(filePath, 'index.html');
+          fs.stat(filePath, (err2) => { if (err2) { res.writeHead(404); res.end('Not found'); return; } serveFile(filePath, res, req); });
+        } else { serveFile(filePath, res, req); }
+      });
+    } catch (e) {
+      console.error('Server error:', e.message);
+      sendJSON(req, res, 500, { error: e.message });
+    }
+  };
+}

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/lib/server-startup.js

@@ -0,0 +1,116 @@
+import { JsonlWatcher } from './jsonl-watcher.js';
+
+export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, ownedSessionIds, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
+  let jsonlWatcher = null;
+
+  function getJsonlWatcher() { return jsonlWatcher; }
+
+  function onServerReady() {
+    toolManager.clearStatusCache();
+    console.log(`GMGUI running on http://localhost:${PORT}${BASE_URL}/`);
+    console.log(`Agents: ${discoveredAgents.map(a => a.name).join(', ') || 'none'}`);
+    console.log(`Hot reload: ${watch ? 'on' : 'off'}`);
+
+    const deletedCount = queries.cleanupEmptyConversations();
+    if (deletedCount > 0) console.log(`Cleaned up ${deletedCount} empty conversation(s) on startup`);
+
+    recoverStaleSessions();
+    warmAssetCache(staticDir);
+
+    try { queries.cleanup(); console.log('[cleanup] Initial DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }
+    setInterval(() => {
+      try { queries.cleanup(); console.log('[cleanup] Scheduled DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }
+    }, 6 * 60 * 60 * 1000);
+
+    try {
+      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
+      jsonlWatcher.start();
+      console.log('[JSONL] Watcher started');
+    } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }
+
+    resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
+
+    setInterval(() => {
+      try {
+        const streaming = queries.getStreamingConversations();
+        let cleared = 0;
+        for (const c of streaming) { if (!activeExecutions.has(c.id)) { queries.setIsStreaming(c.id, false); cleared++; } }
+        if (cleared > 0) debugLog(`[HEALTH] Cleared ${cleared} stale streaming flag(s)`);
+      } catch (e) { debugLog(`[HEALTH] Error: ${e.message}`); }
+    }, 5 * 60 * 1000);
+
+    installGMAgentConfigs().catch(err => console.error('[GM-CONFIG] Startup error:', err.message));
+
+    startACPTools().then(() => {
+      console.log('[ACP] On-demand startup enabled (ACP tools start when first used)');
+      setTimeout(() => {
+        const acpStatus = getACPStatus();
+        for (const s of acpStatus) { if (s.healthy) { const agent = discoveredAgents.find(a => a.id === s.id); if (agent) agent.acpPort = s.port; } }
+        if (acpStatus.length > 0) console.log(`[ACP] Tools ready: ${acpStatus.filter(s => s.healthy).map(s => s.id + ':' + s.port).join(', ') || 'none healthy yet'}`);
+      }, 6000);
+    }).catch(err => console.error('[ACP] Startup error:', err.message));
+
+    const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
+    queries.initializeToolInstallations(toolIds.map(id => ({ id })));
+    console.log('[TOOLS] Starting background provisioning...');
+
+    const toolBroadcaster = (evt) => {
+      broadcastSync(evt);
+      if (evt.type === 'tool_install_complete' || evt.type === 'tool_update_complete') {
+        const d = evt.data || {};
+        queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.version || null, installed_at: Date.now() });
+        queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'success', null);
+      } else if (evt.type === 'tool_install_failed' || evt.type === 'tool_update_failed') {
+        queries.updateToolStatus(evt.toolId, { status: 'failed', error_message: evt.data?.error });
+        queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'failed', evt.data?.error);
+      } else if (evt.type === 'tool_status_update') {
+        const d = evt.data || {};
+        if (d.installed) queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.installedVersion || null, installed_at: Date.now() });
+      }
+    };
+
+    toolManager.autoProvision(toolBroadcaster)
+      .catch(err => console.error('[TOOLS] Auto-provision error:', err.message))
+      .then(() => {
+        const acpActors = ['opencode', 'kilo', 'codex'];
+        console.log(`[MACHINES] tool-install: ${toolInstallMachine.getMachineActors().size} actors, acp-server: ${acpActors.length} configured`);
+        console.log('[TOOLS] Starting periodic update checker...');
+        toolManager.startPeriodicUpdateCheck(toolBroadcaster);
+      });
+
+    ensureModelsDownloaded().then(async ok => {
+      if (ok) console.log('[MODELS] Speech models ready');
+      else console.log('[MODELS] Speech model download failed');
+      try { const { getVoices } = await getSpeech(); broadcastSync({ type: 'voice_list', voices: getVoices() }); }
+      catch (err) { debugLog('[VOICE] Failed to broadcast voices: ' + err.message); broadcastSync({ type: 'voice_list', voices: [] }); }
+    }).catch(async err => {
+      console.error('[MODELS] Download error:', err.message);
+      try { const { getVoices } = await getSpeech(); broadcastSync({ type: 'voice_list', voices: getVoices() }); }
+      catch (err2) { debugLog('[VOICE] Failed to broadcast voices: ' + err2.message); broadcastSync({ type: 'voice_list', voices: [] }); }
+    });
+
+    getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
+    performAutoImport();
+    setInterval(performAutoImport, 30000);
+    setInterval(performAgentHealthCheck, 30000);
+
+    const broadcastPM2 = (update) => {
+      const msg = JSON.stringify(update);
+      for (const client of pm2Subscribers) { if (client.readyState === 1) { try { client.send(msg); } catch (_) {} } }
+    };
+
+    const startPM2Monitoring = async () => {
+      try { await pm2Manager.connect(); await pm2Manager.startMonitoring(broadcastPM2); console.log('[PM2] Monitoring started'); }
+      catch (err) { console.log('[PM2] Not available:', err.message); broadcastPM2({ type: 'pm2_unavailable', reason: err.message, timestamp: Date.now() }); }
+    };
+
+    setTimeout(startPM2Monitoring, 2000);
+    setInterval(async () => {
+      if (!pm2Manager.connected && !pm2Manager.monitoring) {
+        try { const healed = await pm2Manager.heal(); if (healed.success) await pm2Manager.startMonitoring(broadcastPM2); } catch (_) {}
+      }
+    }, 30000);
+  }
+
+  return { onServerReady, getJsonlWatcher };
+}

package/lib/server-startup2.js

@@ -0,0 +1,83 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import PluginLoader from './plugin-loader.js';
+
+export function createAutoImport({ queries, broadcastSync }) {
+  const importMtimeCache = new Map();
+
+  function hasIndexFilesChanged() {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(projectsDir)) return false;
+    let changed = false;
+    try {
+      const dirs = fs.readdirSync(projectsDir);
+      for (const d of dirs) {
+        const indexPath = path.join(projectsDir, d, 'sessions-index.json');
+        try {
+          const stat = fs.statSync(indexPath);
+          const cached = importMtimeCache.get(indexPath);
+          if (!cached || cached < stat.mtimeMs) { importMtimeCache.set(indexPath, stat.mtimeMs); changed = true; }
+        } catch (_) {}
+      }
+    } catch (_) {}
+    return changed;
+  }
+
+  function performAutoImport() {
+    try {
+      if (!hasIndexFilesChanged()) return;
+      const imported = queries.importClaudeCodeConversations();
+      if (imported.length > 0) {
+        const importedCount = imported.filter(i => i.status === 'imported').length;
+        if (importedCount > 0) {
+          console.log(`[AUTO-IMPORT] Imported ${importedCount} new Claude Code conversations`);
+          broadcastSync({ type: 'conversations_updated', count: importedCount });
+        }
+      }
+    } catch (err) { console.error('[AUTO-IMPORT] Error:', err.message); }
+  }
+
+  return { performAutoImport };
+}
+
+export function createDbRecovery({ queries, debugLog }) {
+  function performDbRecovery() {
+    try {
+      const cleanedUp = queries.cleanupOrphanedSessions(7);
+      if (cleanedUp > 0) debugLog(`[RECOVERY] Cleaned up ${cleanedUp} orphaned sessions`);
+      const longRunning = queries.getSessionsProcessingLongerThan(120);
+      if (longRunning.length > 0) {
+        for (const session of longRunning) queries.markSessionIncomplete(session.id, 'Timeout: processing exceeded 2 hours');
+        debugLog(`[RECOVERY] Marked ${longRunning.length} long-running sessions as incomplete`);
+      }
+    } catch (err) { console.error('[RECOVERY] Error:', err.message); }
+  }
+
+  return { performDbRecovery };
+}
+
+export function createPluginLoader({ pluginsDir, expressApp, BASE_URL }) {
+  const pluginLoader = new PluginLoader(pluginsDir);
+
+  async function loadPluginExtensions() {
+    try {
+      await pluginLoader.loadAllPlugins({ router: expressApp, baseUrl: BASE_URL, logger: console, env: process.env });
+      const names = Array.from(pluginLoader.registry.keys());
+      if (names.length > 0) {
+        for (const name of names) {
+          const state = pluginLoader.get(name);
+          if (!state || !state.routes) continue;
+          for (const route of state.routes) {
+            const fullPath = BASE_URL + route.path;
+            const method = (route.method || 'GET').toLowerCase();
+            if (expressApp[method]) expressApp[method](fullPath, route.handler);
+          }
+        }
+        console.log(`[PLUGINS] Loaded extensions: ${names.join(', ')}`);
+      }
+    } catch (err) { console.error('[PLUGINS] Extension loading failed (non-fatal):', err.message); }
+  }
+
+  return { loadPluginExtensions };
+}

package/package.json

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

package/server.js

@@ -1,10 +1,8 @@
 import http from 'http';
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import { fileURLToPath } from 'url';
 import { LRUCache } from 'lru-cache';
-import crypto from 'crypto';
 const PKG_VERSION = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version;
 import { createExpressApp } from './lib/routes-upload.js';
 import { queries } from './database.js';
@@ -13,37 +11,18 @@ 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';
 import { encode as wsEncode } from './lib/codec.js';
 import { parseBody, acceptsEncoding, compressAndSend, sendJSON } from './lib/http-utils.js';
 import { createWsSetup } from './lib/ws-setup.js';
+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';
@@ -52,7 +31,6 @@ import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
 import * as toolManager from './lib/tool-manager.js';
 import { pm2Manager } from './lib/pm2-manager.js';
 import CheckpointManager from './lib/checkpoint-manager.js';
-import { JsonlWatcher } from './lib/jsonl-watcher.js';
 import { createBroadcast } from './lib/broadcast.js';
 import { createRecovery } from './lib/recovery.js';
 import { parseRateLimitResetTime } from './lib/process-message-rate-limit.js';
@@ -63,17 +41,10 @@ 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); });
 
-// Signal handlers registered after server initialization (see bottom of file)
 process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - uncrashable)'); });
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
 process.on('exit', (code) => { console.log('[PROCESS] exit with code:', code); });
@@ -87,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();
@@ -124,226 +94,17 @@ const getModelsForAgent = makeGetModelsForAgent({ modelCache, discoveredAgents,
 const _rateLimitMap = new LRUCache({ max: 1000, ttl: 60000 });
 const RATE_LIMIT_MAX = parseInt(process.env.RATE_LIMIT_MAX || '300', 10);
 
-const server = http.createServer(async (req, res) => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-  if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
-  if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') return;
-
-  const clientIp = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || req.socket.remoteAddress;
-  const hits = (_rateLimitMap.get(clientIp) || 0) + 1;
-  _rateLimitMap.set(clientIp, hits);
-  res.setHeader('X-RateLimit-Limit', RATE_LIMIT_MAX);
-  res.setHeader('X-RateLimit-Remaining', Math.max(0, RATE_LIMIT_MAX - hits));
-  if (hits > RATE_LIMIT_MAX) {
-    res.writeHead(429, { 'Retry-After': '60' });
-    res.end('Too Many Requests');
-    return;
-  }
-
-  const _pwd = process.env.PASSWORD;
-  if (_pwd) {
-    const _auth = req.headers['authorization'] || '';
-    let _ok = false;
-    if (_auth.startsWith('Basic ')) {
-      try {
-        const _decoded = Buffer.from(_auth.slice(6), 'base64').toString('utf8');
-        const _ci = _decoded.indexOf(':');
-        if (_ci !== -1) { const _p = _decoded.slice(_ci + 1); try { _ok = _p.length === _pwd.length && crypto.timingSafeEqual(Buffer.from(_p), Buffer.from(_pwd)); } catch { _ok = false; } }
-      } catch (_) {}
-    }
-    if (!_ok) {
-      res.writeHead(401, { 'WWW-Authenticate': 'Basic realm="agentgui"' });
-      res.end('Unauthorized');
-      return;
-    }
-  }
-
-  const pathOnly = req.url.split('?')[0];
-
-  // Route file upload and fsbrowse requests through Express sub-app
-  if (pathOnly.startsWith(BASE_URL + '/api/upload/') || pathOnly.startsWith(BASE_URL + '/files/')) {
-    return expressApp(req, res);
-  }
-
-  if (req.url === '/favicon.ico' || req.url === BASE_URL + '/favicon.ico') {
-    const svg = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><rect width="100" height="100" rx="20" fill="#3b82f6"/><text x="50" y="68" font-size="50" font-family="sans-serif" font-weight="bold" fill="white" text-anchor="middle">G</text></svg>';
-    res.writeHead(200, { 'Content-Type': 'image/svg+xml', 'Cache-Control': 'public, max-age=86400' });
-    res.end(svg);
-    return;
-  }
-
-  if (req.url === '/') { res.writeHead(302, { Location: BASE_URL + '/' }); res.end(); return; }
-
-  // Handle requests with or without BASE_URL prefix (for reverse proxy compatibility)
-  let routePath = req.url;
-  if (req.url.startsWith(BASE_URL + '/')) {
-    routePath = req.url.slice(BASE_URL.length);
-  } else if (req.url === BASE_URL) {
-    routePath = '/';
-  } else if (req.url.startsWith('/api/') || req.url.startsWith('/js/') || req.url.startsWith('/css/') ||
-             req.url.startsWith('/vendor/') || req.url.startsWith('/sync') || req.url === '/' ||
-             req.url.startsWith('/conversations/')) {
-    // Allow requests without BASE_URL prefix for static files and known routes
-    // This supports reverse proxies that strip the BASE_URL prefix
-    routePath = req.url;
-  } else {
-    res.writeHead(404); res.end('Not found'); return;
-  }
-
-  routePath = routePath || '/';
-
-  try {
-    // Remove query parameters from routePath for matching
-    const pathOnly = routePath.split('?')[0];
-
-    if (pathOnly === '/oauth2callback' && req.method === 'GET') {
-      await handleGeminiOAuthCallback(req, res, PORT);
-      return;
-    }
-
-    if (pathOnly === '/codex-oauth2callback' && req.method === 'GET') {
-      await handleCodexOAuthCallback(req, res, PORT);
-      return;
-    }
-
-    if (pathOnly === '/api/health' && req.method === 'GET') {
-      let dbStatus = { ok: true };
-      try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
-      const queueSizes = {};
-      for (const [k, v] of messageQueues) queueSizes[k] = v.length;
-      sendJSON(req, res, 200, {
-        status: 'ok',
-        version: PKG_VERSION,
-        uptime: process.uptime(),
-        agents: discoveredAgents.length,
-        activeExecutions: activeExecutions.size,
-        wsClients: wss.clients.size,
-        memory: process.memoryUsage(),
-        acp: getACPStatus(),
-        db: dbStatus,
-        queueSizes
-      });
-      return;
-    }
-
-    const convHandler = _convRoutes._match(req.method, pathOnly);
-    if (convHandler) { await convHandler(req, res); return; }
-
-    const messagesHandler = _messagesRoutes._match(req.method, pathOnly);
-    if (messagesHandler) { await messagesHandler(req, res); return; }
-
-    const sessionsHandler = _sessionsRoutes._match(req.method, pathOnly);
-    if (sessionsHandler) { await sessionsHandler(req, res); return; }
-
-    const scriptsHandler = _scriptsRoutes._match(req.method, pathOnly);
-    if (scriptsHandler) { await scriptsHandler(req, res); return; }
-
-    const runsHandlerA = _runsRoutes._match(req.method, pathOnly);
-    if (runsHandlerA) { await runsHandlerA(req, res); return; }
-
-    const agentHandler = _agentRoutes._match(req.method, pathOnly);
-    if (agentHandler) { await agentHandler(req, res); return; }
-
-    const oauthHandler = _oauthRoutes._match(req.method, pathOnly);
-    if (oauthHandler) { await oauthHandler(req, res); return; }
-
-    const agentActionsHandler = _agentActionsRoutes._match(req.method, pathOnly);
-    if (agentActionsHandler) { await agentActionsHandler(req, res); return; }
-
-    const authConfigHandler = _authConfigRoutes._match(req.method, pathOnly);
-    if (authConfigHandler) { await authConfigHandler(req, res); return; }
-
-    const speechHandler = _speechRoutes._match(req.method, pathOnly);
-    if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
-
-    const utilHandler = _utilRoutes._match(req.method, pathOnly);
-    if (utilHandler) { await utilHandler(req, res); 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);
-      const decodedPath = decodeURIComponent(imagePath);
-      const expandedPath = decodedPath.startsWith('~') ?
-        decodedPath.replace('~', os.homedir()) : decodedPath;
-      const normalizedPath = path.normalize(expandedPath);
-      const isWindows = os.platform() === 'win32';
-      const isAbsolute = isWindows ? /^[A-Za-z]:[\\\/]/.test(normalizedPath) : normalizedPath.startsWith('/');
-      if (!isAbsolute || normalizedPath.includes('..')) {
-        res.writeHead(403); res.end('Forbidden'); return;
-      }
-      try {
-        if (!fs.existsSync(normalizedPath)) { res.writeHead(404); res.end('Not found'); return; }
-        const ext = path.extname(normalizedPath).toLowerCase();
-        const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml' };
-        const contentType = mimeTypes[ext] || 'application/octet-stream';
-        const fileContent = fs.readFileSync(normalizedPath);
-        res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-cache' });
-        res.end(fileContent);
-      } catch (err) {
-                sendJSON(req, res, 400, { error: err.message });
-      }
-      return;
-    }
-
-    // Handle conversation detail routes - serve index.html for client-side routing
-    if (pathOnly.match(/^\/conversations\/[^\/]+$/)) {
-      const indexPath = path.join(staticDir, 'index.html');
-      serveFile(indexPath, res, req);
-      return;
-    }
-
-    let filePath = routePath === '/' ? '/index.html' : routePath;
-    filePath = path.join(staticDir, filePath);
-    const normalizedPath = path.normalize(filePath);
-    if (!normalizedPath.startsWith(staticDir)) { res.writeHead(403); res.end('Forbidden'); return; }
-
-    fs.stat(filePath, (err, stats) => {
-      if (err) { res.writeHead(404); res.end('Not found'); return; }
-      if (stats.isDirectory()) {
-        filePath = path.join(filePath, 'index.html');
-        fs.stat(filePath, (err2) => {
-          if (err2) { res.writeHead(404); res.end('Not found'); return; }
-          serveFile(filePath, res, req);
-        });
-      } else {
-        serveFile(filePath, res, req);
-      }
-    });
-  } catch (e) {
-    console.error('Server error:', e.message);
-        sendJSON(req, res, 500, { error: e.message });
-  }
-});
-
 const _assetDeps = { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERSION };
 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, 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({
@@ -355,14 +116,7 @@ const broadcastSync = createBroadcast({
 });
 
 const cleanupExecution = makeCleanupExecution({ execMachine, activeExecutions, queries, broadcastSync, debugLog });
-
-// Wire up process-message factories now that broadcastSync and all deps are available
-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,
@@ -373,78 +127,9 @@ const { processMessageWithStreaming } = createProcessMessage({
   scheduleRetry, drainMessageQueue, createEventHandler
 });
 
-// WebSocket protocol router
 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 });
-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 });
-const _threadRoutes = registerThreadRoutes({ sendJSON, parseBody, queries });
-const _debugRoutes = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath: errLogPath });
-const _convRoutes = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
-const _agentRoutes = registerAgentRoutes({ sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog });
-const _messagesRoutes = registerMessagesRoutes({ queries, sendJSON, parseBody, broadcastSync, processMessageWithStreaming, activeExecutions, messageQueues, debugLog, logError });
-const _sessionsRoutes = registerSessionsRoutes({ queries, sendJSON, activeExecutions, rateLimitState, debugLog });
-const _runsRoutes = registerRunsRoutes({ sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD });
-const _scriptsRoutes = registerScriptsRoutes({ sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD });
-const _agentActionsRoutes = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir });
-const _authConfigRoutes = registerAuthConfigRoutes({ sendJSON, parseBody, getProviderConfigs, saveProviderConfig });
-
-registerConvHandlers(wsRouter, {
-  queries, activeExecutions, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution,
-  getJsonlWatcher: () => jsonlWatcher
-});
-registerConvHandlers2(wsRouter, {
-  queries, activeExecutions, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution,
-  getJsonlWatcher: () => jsonlWatcher
-});
-
-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,
@@ -470,7 +155,7 @@ const { killActiveExecutions, recoverStaleSessions, resumeInterruptedStreams, is
 process.on('SIGTERM', () => {
   console.log('[SIGNAL] SIGTERM received - graceful shutdown');
   killActiveExecutions();
-  if (jsonlWatcher) try { jsonlWatcher.stop(); } catch (_) {}
+  const _jw = getJsonlWatcher(); if (_jw) try { _jw.stop(); } catch (_) {}
   try { pm2Manager.disconnect(); } catch (_) {}
   stopACPTools().catch(() => {}).finally(() => {
     try { wss.close(() => server.close(() => process.exit(0))); } catch (_) { process.exit(0); }
@@ -494,253 +179,19 @@ server.on('error', (err) => {
   }
 });
 
-let jsonlWatcher = null;
-
-function onServerReady() {
-  // Clear tool status cache on startup to ensure fresh detection
-  toolManager.clearStatusCache();
-
-  console.log(`GMGUI running on http://localhost:${PORT}${BASE_URL}/`);
-  console.log(`Agents: ${discoveredAgents.map(a => a.name).join(', ') || 'none'}`);
-  console.log(`Hot reload: ${watch ? 'on' : 'off'}`);
-
-  const deletedCount = queries.cleanupEmptyConversations();
-  if (deletedCount > 0) {
-    console.log(`Cleaned up ${deletedCount} empty conversation(s) on startup`);
-  }
-
-  recoverStaleSessions();
-  warmAssetCache(staticDir);
-
-  // Run DB cleanup on startup and every 6 hours
-  try { queries.cleanup(); console.log('[cleanup] Initial DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }
-  setInterval(() => {
-    try { queries.cleanup(); console.log('[cleanup] Scheduled DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }
-  }, 6 * 60 * 60 * 1000);
-
-  try {
-    jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
-    jsonlWatcher.start();
-    console.log('[JSONL] Watcher started');
-  } catch (err) {
-    console.error('[JSONL] Watcher failed to start:', err.message);
-  }
-
-  resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
-
-  setInterval(() => {
-    try {
-      const streaming = queries.getStreamingConversations();
-      let cleared = 0;
-      for (const c of streaming) {
-        if (!activeExecutions.has(c.id)) {
-          queries.setIsStreaming(c.id, false);
-          cleared++;
-        }
-      }
-      if (cleared > 0) debugLog(`[HEALTH] Cleared ${cleared} stale streaming flag(s)`);
-    } catch (e) { debugLog(`[HEALTH] Error: ${e.message}`); }
-  }, 5 * 60 * 1000);
-
-  installGMAgentConfigs().catch(err => console.error('[GM-CONFIG] Startup error:', err.message));
-
-  startACPTools().then(() => {
-    console.log('[ACP] On-demand startup enabled (ACP tools start when first used)');
-    setTimeout(() => {
-      const acpStatus = getACPStatus();
-      for (const s of acpStatus) {
-        if (s.healthy) {
-          const agent = discoveredAgents.find(a => a.id === s.id);
-          if (agent) { agent.acpPort = s.port; }
-        }
-      }
-      if (acpStatus.length > 0) {
-        console.log(`[ACP] Tools ready: ${acpStatus.filter(s => s.healthy).map(s => s.id + ':' + s.port).join(', ') || 'none healthy yet'}`);
-      }
-    }, 6000);
-  }).catch(err => console.error('[ACP] Startup error:', err.message));
-
-  const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
-  queries.initializeToolInstallations(toolIds.map(id => ({ id })));
-  console.log('[TOOLS] Starting background provisioning...');
-
-  // Create broadcast handler for tool events
-  const toolBroadcaster = (evt) => {
-    broadcastSync(evt);
-    if (evt.type === 'tool_install_complete' || evt.type === 'tool_update_complete') {
-      const d = evt.data || {};
-      queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.version || null, installed_at: Date.now() });
-      queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'success', null);
-    } else if (evt.type === 'tool_install_failed' || evt.type === 'tool_update_failed') {
-      queries.updateToolStatus(evt.toolId, { status: 'failed', error_message: evt.data?.error });
-      queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'failed', evt.data?.error);
-    } else if (evt.type === 'tool_status_update') {
-      const d = evt.data || {};
-      if (d.installed) {
-        queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.installedVersion || null, installed_at: Date.now() });
-      }
-    }
-  };
-
-  // Initial provisioning (blocks until complete)
-  toolManager.autoProvision(toolBroadcaster)
-    .catch(err => console.error('[TOOLS] Auto-provision error:', err.message))
-    .then(() => {
-      const acpActors = ['opencode', 'kilo', 'codex'];
-      const execActorCount = execMachine.stopAll ? 0 : 0;
-      console.log(`[MACHINES] tool-install: ${toolInstallMachine.getMachineActors().size} actors, acp-server: ${acpActors.length} configured`);
-      console.log('[TOOLS] Starting periodic update checker...');
-      toolManager.startPeriodicUpdateCheck(toolBroadcaster);
-    });
-
-  ensureModelsDownloaded().then(async ok => {
-    if (ok) console.log('[MODELS] Speech models ready');
-    else console.log('[MODELS] Speech model download failed');
-    try {
-      const { getVoices } = await getSpeech();
-      const voices = getVoices();
-      broadcastSync({ type: 'voice_list', voices });
-    } catch (err) {
-      debugLog('[VOICE] Failed to broadcast voices: ' + err.message);
-      broadcastSync({ type: 'voice_list', voices: [] });
-    }
-  }).catch(async err => {
-    console.error('[MODELS] Download error:', err.message);
-    try {
-      const { getVoices } = await getSpeech();
-      const voices = getVoices();
-      broadcastSync({ type: 'voice_list', voices });
-    } catch (err2) {
-      debugLog('[VOICE] Failed to broadcast voices: ' + err2.message);
-      broadcastSync({ type: 'voice_list', voices: [] });
-    }
-  });
-
-   getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
-
-   performAutoImport();
-
-   setInterval(performAutoImport, 30000);
-
-   setInterval(performAgentHealthCheck, 30000);
-
-    // Initialize PM2 monitoring - only when PM2 daemon is available
-    const broadcastPM2 = (update) => {
-      const msg = JSON.stringify(update);
-      for (const client of pm2Subscribers) {
-        if (client.readyState === 1) { try { client.send(msg); } catch (_) {} }
-      }
-    };
-
-    const startPM2Monitoring = async () => {
-      try {
-        await pm2Manager.connect();
-        await pm2Manager.startMonitoring(broadcastPM2);
-        console.log('[PM2] Monitoring started');
-      } catch (err) {
-        console.log('[PM2] Not available:', err.message);
-        broadcastPM2({ type: 'pm2_unavailable', reason: err.message, timestamp: Date.now() });
-      }
-    };
+const { performAutoImport } = createAutoImport({ queries, broadcastSync });
+const { performDbRecovery } = createDbRecovery({ queries, debugLog });
+const { loadPluginExtensions } = createPluginLoader({ pluginsDir: path.join(__dirname, 'lib', 'plugins'), expressApp, BASE_URL });
 
-    setTimeout(startPM2Monitoring, 2000);
+setInterval(performDbRecovery, 300000);
 
-    setInterval(async () => {
-      if (!pm2Manager.connected && !pm2Manager.monitoring) {
-        try {
-          const healed = await pm2Manager.heal();
-          if (healed.success) await pm2Manager.startMonitoring(broadcastPM2);
-        } catch (_) {}
-      }
-    }, 30000);
-  }
-
-const importMtimeCache = new Map();
-
-function hasIndexFilesChanged() {
-  const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-  if (!fs.existsSync(projectsDir)) return false;
-  let changed = false;
-  try {
-    const dirs = fs.readdirSync(projectsDir);
-    for (const d of dirs) {
-      const indexPath = path.join(projectsDir, d, 'sessions-index.json');
-      try {
-        const stat = fs.statSync(indexPath);
-        const cached = importMtimeCache.get(indexPath);
-        if (!cached || cached < stat.mtimeMs) {
-          importMtimeCache.set(indexPath, stat.mtimeMs);
-          changed = true;
-        }
-      } catch (_) {}
-    }
-  } catch (_) {}
-  return changed;
-}
-
-function performAutoImport() {
-  try {
-    if (!hasIndexFilesChanged()) return;
-    const imported = queries.importClaudeCodeConversations();
-    if (imported.length > 0) {
-      const importedCount = imported.filter(i => i.status === 'imported').length;
-      if (importedCount > 0) {
-        console.log(`[AUTO-IMPORT] Imported ${importedCount} new Claude Code conversations`);
-        broadcastSync({ type: 'conversations_updated', count: importedCount });
-      }
-    }
-  } catch (err) {
-    console.error('[AUTO-IMPORT] Error:', err.message);
-  }
-}
-
-function performRecovery() {
-  try {
-    // Cleanup orphaned sessions (older than 7 days)
-    const cleanedUp = queries.cleanupOrphanedSessions(7);
-    if (cleanedUp > 0) {
-      debugLog(`[RECOVERY] Cleaned up ${cleanedUp} orphaned sessions`);
-    }
-
-    // Mark sessions incomplete if they've been processing too long (>2 hours)
-    const longRunning = queries.getSessionsProcessingLongerThan(120);
-    if (longRunning.length > 0) {
-      for (const session of longRunning) {
-        queries.markSessionIncomplete(session.id, 'Timeout: processing exceeded 2 hours');
-      }
-      debugLog(`[RECOVERY] Marked ${longRunning.length} long-running sessions as incomplete`);
-    }
-  } catch (err) {
-    console.error('[RECOVERY] Error:', err.message);
-  }
-}
-
-// Run recovery every 5 minutes
-setInterval(performRecovery, 300000);
-
-// Load plugins as extensions (additive, not replacing core routes)
-import PluginLoader from './lib/plugin-loader.js';
-const pluginLoader = new PluginLoader(path.join(__dirname, 'lib', 'plugins'));
-async function loadPluginExtensions() {
-  try {
-    await pluginLoader.loadAllPlugins({ router: expressApp, baseUrl: BASE_URL, logger: console, env: process.env });
-    const names = Array.from(pluginLoader.registry.keys());
-    if (names.length > 0) {
-      for (const name of names) {
-        const state = pluginLoader.get(name);
-        if (!state || !state.routes) continue;
-        for (const route of state.routes) {
-          const fullPath = BASE_URL + route.path;
-          const method = (route.method || 'GET').toLowerCase();
-          if (expressApp[method]) expressApp[method](fullPath, route.handler);
-        }
-      }
-      console.log(`[PLUGINS] Loaded extensions: ${names.join(', ')}`);
-    }
-  } catch (err) {
-    console.error('[PLUGINS] Extension loading failed (non-fatal):', err.message);
-  }
-}
+const { onServerReady, getJsonlWatcher } = createOnServerReady({
+  queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents,
+  PORT, BASE_URL, watch, ownedSessionIds, resumeInterruptedStreams, activeExecutions,
+  debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine,
+  toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport,
+  performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions
+});
 
 server.listen(PORT, () => {
   onServerReady();