agentgui 1.0.840 → 1.0.842

package/CHANGELOG.md

@@ -1,6 +1,8 @@
 ## [Unreleased]
 
 ### Refactor
+- Extract maskKey, getProviderConfigs, saveProviderConfig, buildSystemPrompt, PROVIDER_CONFIGS from server.js to lib/provider-config.js (151L); extract logError, makeCleanupExecution, makeGetModelsForAgent, errLogPath from server.js to lib/server-utils.js (61L); server.js imports all via named imports; cleanupExecution wired after broadcastSync; _debugRoutes receives errLogPath
+- Extract parseBody, acceptsEncoding, compressAndSend, sendJSON from server.js to lib/http-utils.js (43L); server.js imports from new module; zlib import removed from server.js
 - Extract message/stream/queue routes (messagesMatch, streamMatch, queueMatch handlers) to lib/routes-messages.js (140L) and session/chunk/full/execution routes to lib/routes-sessions.js (145L); server.js reduced from 2406L to 2127L; both files ≤200L; wired via _messagesRoutes._match and _sessionsRoutes._match in request handler
 - Extract runs/scripts/agent-auth/auth-config HTTP routes from server.js to lib/routes-runs.js (157L), lib/routes-scripts.js (136L), lib/routes-agent-actions.js (118L), lib/routes-auth-config.js (30L); routes-auth-config uses getProviderConfigs/saveProviderConfig from server.js deps (no duplication); server.js reduced from 2406L to 1399L total (-1007L)
 - Extract processMessageWithStreaming (539L), scheduleRetry, drainMessageQueue, and parseRateLimitResetTime from server.js into lib/process-message.js (127L, createProcessMessage factory), lib/stream-event-handler.js (116L, createEventHandler), lib/message-queue.js (63L, createMessageQueue), lib/process-message-rate-limit.js (19L); all files ≤200L; server.js reduced by ~660L and imports/wires all factories after broadcastSync is created

package/CLAUDE.md

@@ -60,6 +60,9 @@ lib/routes-runs.js     Runs HTTP route handlers (POST /api/runs, runs search, ru
 lib/routes-scripts.js  Scripts/cancel/resume/inject HTTP route handlers (conversation scripts, run-script, stop-script, cancel, resume, inject)
 lib/routes-agent-actions.js  Agent auth and update HTTP route handlers (POST /api/agents/:id/auth, POST /api/agents/:id/update)
 lib/routes-auth-config.js  Auth config HTTP route handlers (GET /api/auth/configs, POST /api/auth/save-config)
+lib/http-utils.js       HTTP utility functions (parseBody, acceptsEncoding, compressAndSend, sendJSON)
+lib/provider-config.js  Provider config helpers (buildSystemPrompt, maskKey, getProviderConfigs, saveProviderConfig, PROVIDER_CONFIGS)
+lib/server-utils.js     Server utility functions (logError, errLogPath, makeCleanupExecution, makeGetModelsForAgent)
 lib/routes-debug.js    Debug/backup/restore/ws-stats HTTP route handlers
 lib/routes-threads.js  Thread CRUD HTTP route handlers (ACP v0.2.3 thread API)
 lib/ws-protocol.js     WebSocket RPC router (WsRouter class)

package/lib/http-utils.js

@@ -0,0 +1,42 @@
+import zlib from 'zlib';
+
+export function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('error', reject);
+    req.on('end', () => {
+      try { resolve(body ? JSON.parse(body) : {}); }
+      catch (e) { reject(new Error('Invalid JSON')); }
+    });
+  });
+}
+
+export function acceptsEncoding(req, encoding) {
+  const accept = req.headers['accept-encoding'] || '';
+  return accept.includes(encoding);
+}
+
+export function compressAndSend(req, res, statusCode, contentType, body) {
+  const raw = typeof body === 'string' ? Buffer.from(body) : body;
+  const isHtml = contentType && contentType.includes('text/html');
+  const baseHeaders = { 'Content-Type': contentType };
+  if (isHtml) baseHeaders['Cache-Control'] = 'no-store';
+  if (raw.length < 860) {
+    res.writeHead(statusCode, { ...baseHeaders, 'Content-Length': raw.length });
+    res.end(raw);
+    return;
+  }
+  if (acceptsEncoding(req, 'gzip')) {
+    const compressed = zlib.gzipSync(raw, { level: 6 });
+    res.writeHead(statusCode, { ...baseHeaders, 'Content-Encoding': 'gzip', 'Content-Length': compressed.length });
+    res.end(compressed);
+  } else {
+    res.writeHead(statusCode, { ...baseHeaders, 'Content-Length': raw.length });
+    res.end(raw);
+  }
+}
+
+export function sendJSON(req, res, statusCode, data) {
+  compressAndSend(req, res, statusCode, 'application/json', JSON.stringify(data));
+}

package/lib/provider-config.js

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getGeminiOAuthStatus } from './oauth-gemini.js';
+import { getCodexOAuthStatus } from './oauth-codex.js';
+
+export function buildSystemPrompt(agentId, model, subAgent) {
+  const parts = [];
+  if (agentId && agentId !== 'claude-code') {
+    const displayAgentId = agentId.split('-·-')[0];
+    parts.push(`Use ${displayAgentId} subagent for all tasks.`);
+  }
+  if (model) parts.push(`Model: ${model}.`);
+  if (subAgent) parts.push(`Subagent: ${subAgent}.`);
+  return parts.join(' ');
+}
+
+const PROVIDER_CONFIGS = {
+  'anthropic': {
+    name: 'Anthropic', configPaths: [
+      path.join(os.homedir(), '.claude.json'),
+      path.join(os.homedir(), '.config', 'claude', 'settings.json'),
+      path.join(os.homedir(), '.anthropic.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
+  },
+  'openai': {
+    name: 'OpenAI', configPaths: [
+      path.join(os.homedir(), '.openai.json'),
+      path.join(os.homedir(), '.config', 'openai', 'api-key')
+    ],
+    configFormat: (apiKey, model) => ({ apiKey, defaultModel: model })
+  },
+  'google': {
+    name: 'Google Gemini', configPaths: [
+      path.join(os.homedir(), '.gemini.json'),
+      path.join(os.homedir(), '.config', 'gemini', 'credentials.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
+  },
+  'openrouter': {
+    name: 'OpenRouter', configPaths: [
+      path.join(os.homedir(), '.openrouter.json'),
+      path.join(os.homedir(), '.config', 'openrouter', 'config.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
+  },
+  'github': {
+    name: 'GitHub Models', configPaths: [
+      path.join(os.homedir(), '.github.json'),
+      path.join(os.homedir(), '.config', 'github-copilot.json')
+    ],
+    configFormat: (apiKey, model) => ({ github_token: apiKey, default_model: model })
+  },
+  'azure': {
+    name: 'Azure OpenAI', configPaths: [
+      path.join(os.homedir(), '.azure.json'),
+      path.join(os.homedir(), '.config', 'azure-openai', 'config.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, endpoint: '', default_model: model })
+  },
+  'anthropic-claude-code': {
+    name: 'Claude Code Max', configPaths: [
+      path.join(os.homedir(), '.claude', 'max.json'),
+      path.join(os.homedir(), '.config', 'claude-code', 'max.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, plan: 'max', default_model: model })
+  },
+  'opencode': {
+    name: 'OpenCode', configPaths: [
+      path.join(os.homedir(), '.opencode', 'config.json'),
+      path.join(os.homedir(), '.config', 'opencode', 'config.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model, providers: ['anthropic', 'openai', 'google'] })
+  },
+  'proxypilot': {
+    name: 'ProxyPilot', configPaths: [
+      path.join(os.homedir(), '.proxypilot', 'config.json'),
+      path.join(os.homedir(), '.config', 'proxypilot', 'config.json')
+    ],
+    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
+  },
+  'codex': {
+    name: 'Codex CLI', configPaths: [
+      path.join(os.homedir(), '.codex', 'auth.json')
+    ],
+    configFormat: (apiKey) => ({ auth_mode: 'apikey', OPENAI_API_KEY: apiKey })
+  }
+};
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return '****';
+  return '****' + key.slice(-4);
+}
+
+export function getProviderConfigs() {
+  const configs = {};
+  for (const [providerId, config] of Object.entries(PROVIDER_CONFIGS)) {
+    if (providerId === 'google') {
+      const oauthStatus = getGeminiOAuthStatus();
+      if (oauthStatus) {
+        configs[providerId] = { name: config.name, ...oauthStatus };
+        continue;
+      }
+    }
+    if (providerId === 'codex') {
+      const oauthStatus = getCodexOAuthStatus();
+      if (oauthStatus) {
+        configs[providerId] = { name: config.name, ...oauthStatus };
+        continue;
+      }
+    }
+    for (const configPath of config.configPaths) {
+      try {
+        if (fs.existsSync(configPath)) {
+          const content = fs.readFileSync(configPath, 'utf8');
+          const parsed = JSON.parse(content);
+          const rawKey = parsed.api_key || parsed.apiKey || parsed.github_token || parsed.OPENAI_API_KEY || '';
+          configs[providerId] = {
+            name: config.name,
+            apiKey: maskKey(rawKey),
+            hasKey: !!rawKey,
+            defaultModel: parsed.default_model || parsed.defaultModel || '',
+            path: configPath
+          };
+          break;
+        }
+      } catch (_) {}
+    }
+    if (!configs[providerId]) {
+      configs[providerId] = { name: config.name, apiKey: '', hasKey: false, defaultModel: '', path: '' };
+    }
+  }
+  return configs;
+}
+
+export function saveProviderConfig(providerId, apiKey, defaultModel) {
+  const config = PROVIDER_CONFIGS[providerId];
+  if (!config) throw new Error('Unknown provider: ' + providerId);
+  const configPath = config.configPaths[0];
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+  let existing = {};
+  try {
+    if (fs.existsSync(configPath)) existing = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_) {}
+  const merged = { ...existing, ...config.configFormat(apiKey, defaultModel) };
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
+  return configPath;
+}

package/lib/server-utils.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const errLogPath = path.join(os.homedir(), 'logs', 'agentgui-errors.log');
+
+export function logError(op, err, ctx = {}) {
+  try {
+    const line = JSON.stringify({ ts: new Date().toISOString(), op, msg: err?.message, stack: err?.stack, ...ctx }) + '\n';
+    fs.appendFile(errLogPath, line, () => {});
+  } catch (_) {}
+}
+
+export function makeCleanupExecution(deps) {
+  const { execMachine, activeExecutions, queries, broadcastSync, debugLog } = deps;
+  return function cleanupExecution(conversationId, broadcastCompletion = false) {
+    debugLog(`[cleanup] Starting cleanup for ${conversationId}`);
+    const machineSnap = execMachine.snapshot(conversationId);
+    if (machineSnap && machineSnap.value !== 'idle') {
+      execMachine.send(conversationId, { type: 'CANCEL' });
+    }
+    activeExecutions.delete(conversationId);
+    queries.setIsStreaming(conversationId, false);
+    if (broadcastCompletion) {
+      broadcastSync({
+        type: 'execution_cleaned_up',
+        conversationId,
+        timestamp: Date.now()
+      });
+    }
+    debugLog(`[cleanup] Cleanup complete for ${conversationId}`);
+  };
+}
+
+export function makeGetModelsForAgent(deps) {
+  const { modelCache, discoveredAgents, ensureRunning, queryACPModels } = deps;
+  return async function getModelsForAgent(agentId) {
+    const cached = modelCache.get(agentId);
+    if (cached && Date.now() - cached.timestamp < 300000) return cached.models;
+    let models = [];
+    if (agentId === 'claude-code') {
+      models = [
+        { id: 'haiku', label: 'Haiku' },
+        { id: 'sonnet', label: 'Sonnet' },
+        { id: 'opus', label: 'Opus' }
+      ];
+    } else {
+      const agent = discoveredAgents.find(a => a.id === agentId);
+      if (agent?.protocol === 'acp') {
+        await ensureRunning(agentId);
+        try { models = await queryACPModels(agentId); } catch (_) {}
+      } else if (agent?.protocol === 'cli-wrapper' && agent.acpId) {
+        await ensureRunning(agent.acpId);
+        try { models = await queryACPModels(agent.acpId); } catch (_) {}
+      }
+    }
+    modelCache.set(agentId, { models, timestamp: Date.now() });
+    return models;
+  };
+}

package/package.json

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

package/server.js

@@ -2,7 +2,6 @@ import http from 'http';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import zlib from 'zlib';
 import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import { execSync, spawn } from 'child_process';
@@ -37,6 +36,7 @@ import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getC
 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';
 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';
@@ -63,6 +63,8 @@ import { parseRateLimitResetTime } from './lib/process-message-rate-limit.js';
 import { createEventHandler } from './lib/stream-event-handler.js';
 import { createMessageQueue } from './lib/message-queue.js';
 import { createProcessMessage } from './lib/process-message.js';
+import { buildSystemPrompt, getProviderConfigs, saveProviderConfig } from './lib/provider-config.js';
+import { logError, errLogPath, makeCleanupExecution, makeGetModelsForAgent } from './lib/server-utils.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -80,18 +82,6 @@ process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - un
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
 process.on('exit', (code) => { console.log('[PROCESS] exit with code:', code); });
 
-
-function buildSystemPrompt(agentId, model, subAgent) {
-  const parts = [];
-  if (agentId && agentId !== 'claude-code') {
-    const displayAgentId = agentId.split('-·-')[0];
-    parts.push(`Use ${displayAgentId} subagent for all tasks.`);
-  }
-  if (model) parts.push(`Model: ${model}.`);
-  if (subAgent) parts.push(`Subagent: ${subAgent}.`);
-  return parts.join(' ');
-}
-
 const activeExecutions = new Map();
 const activeScripts = new Map();
 const messageQueues = new Map();
@@ -108,41 +98,6 @@ const debugLog = (msg) => {
   console.error(`[${timestamp}] ${msg}`);
 };
 
-const _errLogPath = path.join(os.homedir(), 'logs', 'agentgui-errors.log');
-function logError(op, err, ctx = {}) {
-  try {
-    const line = JSON.stringify({ ts: new Date().toISOString(), op, msg: err?.message, stack: err?.stack, ...ctx }) + '\n';
-    fs.appendFile(_errLogPath, line, () => {});
-  } catch (_) {}
-}
-
-// Atomic cleanup function - machine is authoritative, Map stays in sync
-function cleanupExecution(conversationId, broadcastCompletion = false) {
-  debugLog(`[cleanup] Starting cleanup for ${conversationId}`);
-
-  // Machine drives cleanup: send CANCEL (clears queue, transitions to idle)
-  const machineSnap = execMachine.snapshot(conversationId);
-  if (machineSnap && machineSnap.value !== 'idle') {
-    execMachine.send(conversationId, { type: 'CANCEL' });
-  }
-
-  // Keep Map in sync with machine
-  activeExecutions.delete(conversationId);
-
-  // Clean database state
-  queries.setIsStreaming(conversationId, false);
-
-  if (broadcastCompletion) {
-    broadcastSync({
-      type: 'execution_cleaned_up',
-      conversationId,
-      timestamp: Date.now()
-    });
-  }
-
-  debugLog(`[cleanup] Cleanup complete for ${conversationId}`);
-}
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = process.env.PORTABLE_EXE_DIR || __dirname;
 const PORT = process.env.PORT || 3000;
@@ -246,205 +201,7 @@ initializeAgentDiscovery(discoveredAgents, rootDir, logError).then(() => {
 }).catch(() => {});
 
 const modelCache = new Map();
-
-async function getModelsForAgent(agentId) {
-  const cached = modelCache.get(agentId);
-  if (cached && Date.now() - cached.timestamp < 300000) return cached.models;
-  let models = [];
-  if (agentId === 'claude-code') {
-    models = [
-      { id: 'haiku', label: 'Haiku' },
-      { id: 'sonnet', label: 'Sonnet' },
-      { id: 'opus', label: 'Opus' }
-    ];
-  } else {
-    const agent = discoveredAgents.find(a => a.id === agentId);
-    if (agent?.protocol === 'acp') {
-      await ensureRunning(agentId);
-      try { models = await queryACPModels(agentId); } catch (_) {}
-    } else if (agent?.protocol === 'cli-wrapper' && agent.acpId) {
-      await ensureRunning(agent.acpId);
-      try { models = await queryACPModels(agent.acpId); } catch (_) {}
-    }
-  }
-  modelCache.set(agentId, { models, timestamp: Date.now() });
-  return models;
-}
-
-const PROVIDER_CONFIGS = {
-  'anthropic': {
-    name: 'Anthropic', configPaths: [
-      path.join(os.homedir(), '.claude.json'),
-      path.join(os.homedir(), '.config', 'claude', 'settings.json'),
-      path.join(os.homedir(), '.anthropic.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
-  },
-  'openai': {
-    name: 'OpenAI', configPaths: [
-      path.join(os.homedir(), '.openai.json'),
-      path.join(os.homedir(), '.config', 'openai', 'api-key')
-    ],
-    configFormat: (apiKey, model) => ({ apiKey, defaultModel: model })
-  },
-  'google': {
-    name: 'Google Gemini', configPaths: [
-      path.join(os.homedir(), '.gemini.json'),
-      path.join(os.homedir(), '.config', 'gemini', 'credentials.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
-  },
-  'openrouter': {
-    name: 'OpenRouter', configPaths: [
-      path.join(os.homedir(), '.openrouter.json'),
-      path.join(os.homedir(), '.config', 'openrouter', 'config.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
-  },
-  'github': {
-    name: 'GitHub Models', configPaths: [
-      path.join(os.homedir(), '.github.json'),
-      path.join(os.homedir(), '.config', 'github-copilot.json')
-    ],
-    configFormat: (apiKey, model) => ({ github_token: apiKey, default_model: model })
-  },
-  'azure': {
-    name: 'Azure OpenAI', configPaths: [
-      path.join(os.homedir(), '.azure.json'),
-      path.join(os.homedir(), '.config', 'azure-openai', 'config.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, endpoint: '', default_model: model })
-  },
-  'anthropic-claude-code': {
-    name: 'Claude Code Max', configPaths: [
-      path.join(os.homedir(), '.claude', 'max.json'),
-      path.join(os.homedir(), '.config', 'claude-code', 'max.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, plan: 'max', default_model: model })
-  },
-  'opencode': {
-    name: 'OpenCode', configPaths: [
-      path.join(os.homedir(), '.opencode', 'config.json'),
-      path.join(os.homedir(), '.config', 'opencode', 'config.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model, providers: ['anthropic', 'openai', 'google'] })
-  },
-  'proxypilot': {
-    name: 'ProxyPilot', configPaths: [
-      path.join(os.homedir(), '.proxypilot', 'config.json'),
-      path.join(os.homedir(), '.config', 'proxypilot', 'config.json')
-    ],
-    configFormat: (apiKey, model) => ({ api_key: apiKey, default_model: model })
-  },
-  'codex': {
-    name: 'Codex CLI', configPaths: [
-      path.join(os.homedir(), '.codex', 'auth.json')
-    ],
-    configFormat: (apiKey) => ({ auth_mode: 'apikey', OPENAI_API_KEY: apiKey })
-  }
-};
-
-function maskKey(key) {
-  if (!key || key.length < 8) return '****';
-  return '****' + key.slice(-4);
-}
-
-function getProviderConfigs() {
-  const configs = {};
-  for (const [providerId, config] of Object.entries(PROVIDER_CONFIGS)) {
-    if (providerId === 'google') {
-      const oauthStatus = getGeminiOAuthStatus();
-      if (oauthStatus) {
-        configs[providerId] = { name: config.name, ...oauthStatus };
-        continue;
-      }
-    }
-    if (providerId === 'codex') {
-      const oauthStatus = getCodexOAuthStatus();
-      if (oauthStatus) {
-        configs[providerId] = { name: config.name, ...oauthStatus };
-        continue;
-      }
-    }
-    for (const configPath of config.configPaths) {
-      try {
-        if (fs.existsSync(configPath)) {
-          const content = fs.readFileSync(configPath, 'utf8');
-          const parsed = JSON.parse(content);
-          const rawKey = parsed.api_key || parsed.apiKey || parsed.github_token || parsed.OPENAI_API_KEY || '';
-          configs[providerId] = {
-            name: config.name,
-            apiKey: maskKey(rawKey),
-            hasKey: !!rawKey,
-            defaultModel: parsed.default_model || parsed.defaultModel || '',
-            path: configPath
-          };
-          break;
-        }
-      } catch (_) {}
-    }
-    if (!configs[providerId]) {
-      configs[providerId] = { name: config.name, apiKey: '', hasKey: false, defaultModel: '', path: '' };
-    }
-  }
-  return configs;
-}
-
-function saveProviderConfig(providerId, apiKey, defaultModel) {
-  const config = PROVIDER_CONFIGS[providerId];
-  if (!config) throw new Error('Unknown provider: ' + providerId);
-  const configPath = config.configPaths[0];
-  const configDir = path.dirname(configPath);
-  if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
-  let existing = {};
-  try {
-    if (fs.existsSync(configPath)) existing = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  } catch (_) {}
-  const merged = { ...existing, ...config.configFormat(apiKey, defaultModel) };
-  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2), { mode: 0o600 });
-  return configPath;
-}
-
-function parseBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    req.on('data', chunk => body += chunk);
-    req.on('error', reject);
-    req.on('end', () => {
-      try { resolve(body ? JSON.parse(body) : {}); }
-      catch (e) { reject(new Error('Invalid JSON')); }
-    });
-  });
-}
-
-function acceptsEncoding(req, encoding) {
-  const accept = req.headers['accept-encoding'] || '';
-  return accept.includes(encoding);
-}
-
-function compressAndSend(req, res, statusCode, contentType, body) {
-  const raw = typeof body === 'string' ? Buffer.from(body) : body;
-  const isHtml = contentType && contentType.includes('text/html');
-  const baseHeaders = { 'Content-Type': contentType };
-  if (isHtml) baseHeaders['Cache-Control'] = 'no-store';
-  if (raw.length < 860) {
-    res.writeHead(statusCode, { ...baseHeaders, 'Content-Length': raw.length });
-    res.end(raw);
-    return;
-  }
-  if (acceptsEncoding(req, 'gzip')) {
-    const compressed = zlib.gzipSync(raw, { level: 6 });
-    res.writeHead(statusCode, { ...baseHeaders, 'Content-Encoding': 'gzip', 'Content-Length': compressed.length });
-    res.end(compressed);
-  } else {
-    res.writeHead(statusCode, { ...baseHeaders, 'Content-Length': raw.length });
-    res.end(raw);
-  }
-}
-
-function sendJSON(req, res, statusCode, data) {
-  compressAndSend(req, res, statusCode, 'application/json', JSON.stringify(data));
-}
+const getModelsForAgent = makeGetModelsForAgent({ modelCache, discoveredAgents, ensureRunning, queryACPModels });
 
 const _rateLimitMap = new LRUCache({ max: 1000, ttl: 60000 });
 const RATE_LIMIT_MAX = parseInt(process.env.RATE_LIMIT_MAX || '300', 10);
@@ -741,6 +498,8 @@ const broadcastSync = createBroadcast({
   getSeq: () => ++broadcastSeq
 });
 
+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,
@@ -767,7 +526,7 @@ const _oauthRoutes = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL,
 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 });
+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 });