agentgui 1.0.844 → 1.0.846

package/server.js

@@ -1,13 +1,8 @@
 import http from 'http';
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import { fileURLToPath } from 'url';
-import { WebSocketServer } from 'ws';
-import { execSync, spawn } from 'child_process';
 import { LRUCache } from 'lru-cache';
-import { createRequire } from 'module';
-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';
@@ -35,6 +30,10 @@ 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';
@@ -54,7 +53,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';
@@ -75,7 +73,6 @@ process.on('unhandledRejection', (reason, promise) => {
   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); });
@@ -126,271 +123,34 @@ 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); }
 
-let broadcastSeq = 0;
-
+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 wss = new WebSocketServer({
-  server,
-  perMessageDeflate: false  // Disabled: msgpack binary doesn't compress well, and
-                             // synchronous zlib on every frame blocks the event loop.
-                             // HTTP-layer gzip already handles static assets; WS
-                             // streaming events are small and latency-sensitive.
-});
-wss.on('error', (err) => {
-  console.error('[WSS] WebSocket server error (contained):', err.message);
-});
-const hotReloadClients = [];
+let broadcastSeq = 0;
 const syncClients = new Set();
 const subscriptionIndex = new Map();
 const pm2Subscribers = new Set();
 
-wss.on('connection', (ws, req) => {
-  const _pwd = process.env.PASSWORD;
-  if (_pwd) {
-    const url = new URL(req.url, 'http://localhost');
-    const token = url.searchParams.get('token');
-    if (token !== _pwd) { ws.close(4001, 'Unauthorized'); return; }
-  }
-  const wsPath = req.url.split('?')[0];
-  const wsRoute = wsPath.startsWith(BASE_URL) ? wsPath.slice(BASE_URL.length) : wsPath;
-  if (wsRoute === '/hot-reload') {
-    hotReloadClients.push(ws);
-    ws.on('close', () => { const i = hotReloadClients.indexOf(ws); if (i > -1) hotReloadClients.splice(i, 1); });
-  } else if (wsRoute === '/sync') {
-    syncClients.add(ws);
-    ws.isAlive = true;
-    ws.subscriptions = new Set();
-    ws.clientId = `client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-
-    sendWs(ws, ({
-      type: 'sync_connected',
-      clientId: ws.clientId,
-      timestamp: Date.now()
-    }));
-
-    ws.on('error', (err) => {
-      console.error('[WS] Client error (contained):', ws.clientId, err.message);
-    });
-    ws.on('message', (msg) => {
-      try { wsRouter.onMessage(ws, msg); } catch (e) { console.error('[WS] Message handler error (contained):', e.message); }
-    });
-
-    ws.on('pong', () => { ws.isAlive = true; });
-     ws.on('close', () => {
-       if (ws.terminalProc) { try { ws.terminalProc.kill(); } catch(e) {} ws.terminalProc = null; }
-       syncClients.delete(ws);
-       wsOptimizer.removeClient(ws);
-       for (const sub of ws.subscriptions) {
-         const idx = subscriptionIndex.get(sub);
-         if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(sub); }
-       }
-       if (ws.pm2Subscribed) {
-         pm2Subscribers.delete(ws);
-       }
-       debugLog(`[WebSocket] Client ${ws.clientId} disconnected`);
-     });
-  }
-});
-
 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',
@@ -420,7 +180,6 @@ 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,
@@ -437,34 +196,33 @@ const { processMessageWithStreaming } = createProcessMessage({
   scheduleRetry, drainMessageQueue, createEventHandler
 });
 
-// WebSocket protocol router
 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 });
+_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 });
-const _threadRoutes = registerThreadRoutes({ sendJSON, parseBody, queries });
+_routes.threads = 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 });
+_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: () => jsonlWatcher
+  getJsonlWatcher
 });
 registerConvHandlers2(wsRouter, {
   queries, activeExecutions, rateLimitState,
   broadcastSync, processMessageWithStreaming, cleanupExecution,
-  getJsonlWatcher: () => jsonlWatcher
+  getJsonlWatcher
 });
 
 registerMsgHandlers(wsRouter, {
@@ -510,281 +268,16 @@ registerOAuthHandlers(wsRouter, {
   codexOAuthState: getCodexOAuthState,
 });
 
-wsRouter.onLegacy((data, ws) => {
-  try {
-  if (data.type === 'subscribe') {
-    if (data.sessionId) {
-      ws.subscriptions.add(data.sessionId);
-      if (!subscriptionIndex.has(data.sessionId)) subscriptionIndex.set(data.sessionId, new Set());
-      subscriptionIndex.get(data.sessionId).add(ws);
-    }
-    if (data.conversationId) {
-      const key = `conv-${data.conversationId}`;
-      ws.subscriptions.add(key);
-      if (!subscriptionIndex.has(key)) subscriptionIndex.set(key, new Set());
-      subscriptionIndex.get(key).add(ws);
-    }
-    const subTarget = data.sessionId || data.conversationId;
-    debugLog(`[WebSocket] Client ${ws.clientId} subscribed to ${subTarget}`);
-    sendWs(ws, ({
-      type: 'subscription_confirmed',
-      sessionId: data.sessionId,
-      conversationId: data.conversationId,
-      timestamp: Date.now()
-    }));
-
-    // Notify client if this conversation has an active streaming execution
-    // Machine is authoritative for streaming state check on subscribe
-    if (data.conversationId && execMachine.isActive(data.conversationId)) {
-      const ctx = execMachine.getContext(data.conversationId);
-      const execution = activeExecutions.get(data.conversationId);
-      const sessionId = ctx?.sessionId || execution?.sessionId;
-      const conv = queries.getConversation(data.conversationId);
-      const queueLength = execMachine.getQueue(data.conversationId).length || messageQueues.get(data.conversationId)?.length || 0;
-      sendWs(ws, ({
-        type: 'streaming_start',
-        sessionId,
-        conversationId: data.conversationId,
-        agentId: conv?.agentType || conv?.agentId || 'claude-code',
-        queueLength,
-        resumed: true,
-        seq: ++broadcastSeq,
-        timestamp: Date.now()
-      }));
-    }
-
-    // Inject pending checkpoint events if this is a conversation subscription
-    if (data.conversationId && checkpointManager.hasPendingCheckpoint(data.conversationId)) {
-      const checkpoint = checkpointManager.getPendingCheckpoint(data.conversationId);
-      if (checkpoint) {
-        debugLog(`[checkpoint] Injecting ${checkpoint.events.length} events to client for ${data.conversationId}`);
-
-        const latestSession = queries.getLatestSession(data.conversationId);
-        if (latestSession) {
-          sendWs(ws, ({
-            type: 'streaming_resumed',
-            sessionId: latestSession.id,
-            conversationId: data.conversationId,
-            resumeFrom: checkpoint.sessionId,
-            eventCount: checkpoint.events.length,
-            chunkCount: checkpoint.chunks.length,
-            timestamp: Date.now()
-          }));
-
-          checkpointManager.injectCheckpointEvents(latestSession.id, checkpoint, (evt) => {
-            sendWs(ws, ({
-              ...evt,
-              sessionId: latestSession.id,
-              conversationId: data.conversationId
-            }));
-          });
-        }
-      }
-    }
-  } else if (data.type === 'unsubscribe') {
-    if (data.sessionId) {
-      ws.subscriptions.delete(data.sessionId);
-      const idx = subscriptionIndex.get(data.sessionId);
-      if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(data.sessionId); }
-    }
-    if (data.conversationId) {
-      const key = `conv-${data.conversationId}`;
-      ws.subscriptions.delete(key);
-      const idx = subscriptionIndex.get(key);
-      if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(key); }
-    }
-    debugLog(`[WebSocket] Client ${ws.clientId} unsubscribed from ${data.sessionId || data.conversationId}`);
-  } else if (data.type === 'get_subscriptions') {
-    sendWs(ws, ({
-      type: 'subscriptions',
-      subscriptions: Array.from(ws.subscriptions),
-      timestamp: Date.now()
-    }));
-  } else if (data.type === 'set_voice') {
-    ws.ttsVoiceId = data.voiceId || 'default';
-  } else if (data.type === 'latency_report') {
-    ws.latencyTier = data.quality || 'good';
-    ws.latencyAvg = data.avg || 0;
-    ws.latencyTrend = data.trend || 'stable';
-  } else if (data.type === 'ping') {
-    sendWs(ws, ({
-      type: 'pong',
-      requestId: data.requestId,
-      timestamp: Date.now()
-    }));
-  } else if (data.type === 'terminal_start') {
-    if (ws.terminalProc) {
-      try { ws.terminalProc.kill(); } catch(e) {}
-    }
-    try {
-      const _req = createRequire(import.meta.url);
-      const pty = _req('node-pty');
-      const shell = process.env.SHELL || '/bin/bash';
-      const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
-      const proc = pty.spawn(shell, [], {
-        name: 'xterm-256color',
-        cols: data.cols || 80,
-        rows: data.rows || 24,
-        cwd: cwd,
-        env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' }
-      });
-      ws.terminalProc = proc;
-      ws.terminalPty = true;
-      proc.on('data', (chunk) => {
-        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: Buffer.from(chunk).toString('base64'), encoding: 'base64' }));
-      });
-      proc.on('exit', (code) => {
-        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code });
-        ws.terminalProc = null;
-      });
-      proc.on('error', (err) => {
-        console.error('[TERMINAL] PTY error (contained):', err.message);
-        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message });
-        ws.terminalProc = null;
-      });
-      sendWs(ws, ({ type: 'terminal_started', timestamp: Date.now() }));
-    } catch (e) {
-      console.error('[TERMINAL] Failed to spawn PTY, falling back to pipes:', e.message);
-      const shell = process.env.SHELL || '/bin/bash';
-      const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
-      const proc = spawn(shell, ['-i'], { cwd, env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' }, stdio: ['pipe', 'pipe', 'pipe'] });
-      ws.terminalProc = proc;
-      ws.terminalPty = false;
-      proc.stdout.on('data', (chunk) => {
-        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
-      });
-      proc.stderr.on('data', (chunk) => {
-        if (ws.readyState === 1) sendWs(ws, ({ type: 'terminal_output', data: chunk.toString('base64'), encoding: 'base64' }));
-      });
-      proc.on('exit', (code) => {
-        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code });
-        ws.terminalProc = null;
-      });
-      proc.on('error', (err) => {
-        console.error('[TERMINAL] Spawn error (contained):', err.message);
-        if (ws.readyState === 1) sendWs(ws, { type: 'terminal_exit', code: 1, error: err.message });
-        ws.terminalProc = null;
-      });
-      proc.stdin.on('error', () => {});
-      proc.stdout.on('error', () => {});
-      proc.stderr.on('error', () => {});
-      sendWs(ws, ({ type: 'terminal_started', timestamp: Date.now() }));
-    }
-  } else if (data.type === 'terminal_input') {
-    if (ws.terminalProc) {
-      try {
-        const input = Buffer.from(data.data, 'base64');
-        if (ws.terminalPty) {
-          ws.terminalProc.write(input);
-        } else if (ws.terminalProc.stdin && ws.terminalProc.stdin.writable) {
-          ws.terminalProc.stdin.write(input);
-        }
-      } catch (e) {}
-    }
-  } else if (data.type === 'terminal_resize') {
-    if (ws.terminalProc && ws.terminalPty) {
-      try {
-        const { cols, rows } = data;
-        if (cols && rows && typeof ws.terminalProc.resize === 'function') {
-          ws.terminalProc.resize(cols, rows);
-        }
-      } catch (e) {}
-    }
-   } else if (data.type === 'terminal_stop') {
-     if (ws.terminalProc) {
-       try { ws.terminalProc.kill(); } catch(e) {}
-       ws.terminalProc = null;
-     }
-    } else if (data.type === 'pm2_list') {
-      if (!pm2Manager.connected) {
-        if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
-      } else {
-        pm2Manager.listProcesses().then(processes => {
-          if (ws.readyState === 1) {
-            const hasActive = processes.some(p => ['online','launching','stopping','waiting restart'].includes(p.status));
-            sendWs(ws, { type: 'pm2_list_response', processes, hasActive });
-          }
-        }).catch(() => {
-          if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'list failed', timestamp: Date.now() }));
-        });
-      }
-    } else if (data.type === 'pm2_start_monitoring') {
-      pm2Subscribers.add(ws);
-      ws.pm2Subscribed = true;
-      if (!pm2Manager.connected) {
-        if (ws.readyState === 1) sendWs(ws, ({ type: 'pm2_unavailable', reason: 'PM2 not connected', timestamp: Date.now() }));
-      } else {
-        sendWs(ws, { type: 'pm2_monitoring_started' });
-      }
-    } else if (data.type === 'pm2_stop_monitoring') {
-      pm2Subscribers.delete(ws);
-      ws.pm2Subscribed = false;
-      sendWs(ws, { type: 'pm2_monitoring_stopped' });
-    } else if (data.type === 'pm2_start') {
-      pm2Manager.startProcess(data.name).then(result => {
-        sendWs(ws, { type: 'pm2_start_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_stop') {
-      pm2Manager.stopProcess(data.name).then(result => {
-        sendWs(ws, { type: 'pm2_stop_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_restart') {
-      pm2Manager.restartProcess(data.name).then(result => {
-        sendWs(ws, { type: 'pm2_restart_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_delete') {
-      pm2Manager.deleteProcess(data.name).then(result => {
-        sendWs(ws, { type: 'pm2_delete_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_logs') {
-      pm2Manager.getLogs(data.name, { lines: data.lines || 100 }).then(result => {
-        sendWs(ws, { type: 'pm2_logs_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_flush_logs') {
-      pm2Manager.flushLogs(data.name).then(result => {
-        sendWs(ws, { type: 'pm2_flush_logs_response', name: data.name, ...result });
-      });
-    } else if (data.type === 'pm2_ping') {
-      pm2Manager.ping().then(result => {
-        sendWs(ws, { type: 'pm2_ping_response', ...result });
-      });
-    }
-
-  } catch (err) { console.error('[WS-LEGACY] Handler error (contained):', err.message); }
+const { wss, hotReloadClients } = createWsSetup(server, {
+  BASE_URL, watch, staticDir, _assetCache, htmlState, sendWs, wsRouter, debugLog,
+  subscriptionIndex, syncClients, pm2Subscribers, wsOptimizer,
+  legacyDeps: {
+    subscriptionIndex, execMachine, activeExecutions, messageQueues,
+    checkpointManager, queries, pm2Manager, pm2Subscribers,
+    getSeq: () => ++broadcastSeq, sendWs, debugLog
+  }
 });
 
-// Heartbeat interval to detect stale connections
-const heartbeatInterval = setInterval(() => {
-  syncClients.forEach(ws => {
-    if (!ws.isAlive) {
-      syncClients.delete(ws);
-      wsOptimizer.removeClient(ws);
-      return ws.terminate();
-    }
-    ws.isAlive = false;
-    ws.ping();
-  });
-}, 30000);
-
-if (watch) {
-  const watchedFiles = new Map();
-  try {
-    fs.readdirSync(staticDir).forEach(file => {
-      const fp = path.join(staticDir, file);
-      if (watchedFiles.has(fp)) return;
-      fs.watchFile(fp, { interval: 100 }, (curr, prev) => {
-        if (curr.mtime > prev.mtime) {
-          _assetCache.clear();
-          htmlState.cache = null;
-          htmlState.etag = null;
-          hotReloadClients.forEach(c => { if (c.readyState === 1) c.send(JSON.stringify({ type: 'reload' })); });
-        }
-      });
-      watchedFiles.set(fp, true);
-    });
-  } catch (e) { console.error('Watch error:', e.message); }
-}
-
 const { killActiveExecutions, recoverStaleSessions, resumeInterruptedStreams, isProcessAlive, markAgentDead, resumeConversation, performAgentHealthCheck } = createRecovery({
   activeExecutions,
   processMessageWithStreaming,
@@ -799,7 +292,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); }
@@ -823,253 +316,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 { performAutoImport } = createAutoImport({ queries, broadcastSync });
+const { performDbRecovery } = createDbRecovery({ queries, debugLog });
+const { loadPluginExtensions } = createPluginLoader({ pluginsDir: path.join(__dirname, 'lib', 'plugins'), expressApp, BASE_URL });
 
-  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...');
+setInterval(performDbRecovery, 300000);
 
-  // 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() });
-      }
-    };
-
-    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);
-  }
-
-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();