agentgui 1.0.917 → 1.0.918

package/lib/pm2-manager.js

@@ -1,170 +0,0 @@
-import pm2 from 'pm2';
-
-const ACTIVE_STATES = new Set(['online', 'launching', 'stopping', 'waiting restart']);
-
-class PM2Manager {
-  constructor() {
-    this.connected = false;
-    this.monitoring = false;
-    this.monitorInterval = null;
-    this.broadcastFn = null;
-    this.logStreams = new Map();
-  }
-
-  async connect() {
-    if (this.connected) return true;
-    return new Promise((resolve, reject) => {
-      pm2.connect(false, (err) => {
-        if (err) { this.connected = false; reject(err); }
-        else { this.connected = true; resolve(true); }
-      });
-    });
-  }
-
-  async ensureConnected() {
-    if (this.connected) return true;
-    await this.connect();
-    return true;
-  }
-
-  async listProcesses() {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.list((err, list) => {
-          if (err) { this.connected = false; resolve([]); return; }
-          if (!Array.isArray(list)) { resolve([]); return; }
-          resolve(list.map(proc => ({
-            name: proc.name,
-            pm_id: proc.pm_id,
-            status: proc.status,
-            pid: proc.pid,
-            cpu: proc.monit ? (proc.monit.cpu || 0) : 0,
-            memory: proc.monit ? (typeof proc.monit.memory === 'number' ? proc.monit.memory : 0) : 0,
-            uptime: proc.pm2_env ? proc.pm2_env.pm_uptime : null,
-            restarts: proc.pm2_env ? (proc.pm2_env.restart_time || 0) : 0,
-            watching: proc.pm2_env ? (proc.pm2_env.watch || false) : false,
-            isActive: ACTIVE_STATES.has(proc.status)
-          })));
-        });
-      });
-    } catch (_) {
-      this.connected = false;
-      return [];
-    }
-  }
-
-  async startMonitoring(broadcastFn) {
-    if (this.monitoring) return;
-    this.monitoring = true;
-    this.broadcastFn = broadcastFn;
-    const tick = async () => {
-      if (!this.monitoring) return;
-      try {
-        const processes = await this.listProcesses();
-        const hasActive = processes.some(p => p.isActive);
-        broadcastFn({ type: 'pm2_monit_update', processes, hasActive, available: true, timestamp: Date.now() });
-      } catch (_) {}
-    };
-    this.monitorInterval = setInterval(tick, 2000);
-    await tick();
-  }
-
-  stopMonitoring() {
-    this.monitoring = false;
-    if (this.monitorInterval) { clearInterval(this.monitorInterval); this.monitorInterval = null; }
-    this.broadcastFn = null;
-  }
-
-  async startProcess(name) {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.start(name, (err) => resolve(err ? { success: false, error: err.message } : { success: true }));
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async stopProcess(name) {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.stop(name, (err) => resolve(err ? { success: false, error: err.message } : { success: true }));
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async restartProcess(name) {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.restart(name, (err) => resolve(err ? { success: false, error: err.message } : { success: true }));
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async deleteProcess(name) {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.delete(name, (err) => resolve(err ? { success: false, error: err.message } : { success: true }));
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async getLogs(name, options = {}) {
-    try {
-      await this.ensureConnected();
-      const existing = this.logStreams.get(name);
-      if (existing) { try { existing.destroy(); } catch (_) {} this.logStreams.delete(name); }
-      return new Promise((resolve) => {
-        const lines = [];
-        let settled = false;
-        const finish = (result) => { if (!settled) { settled = true; resolve(result); } };
-        const timer = setTimeout(() => finish({ success: true, logs: lines.join('\n') }), 4000);
-        try {
-          const stream = pm2.logs(name, { raw: true, lines: options.lines || 100, follow: false });
-          this.logStreams.set(name, stream);
-          stream.on('data', (c) => lines.push(c.toString()));
-          stream.on('end', () => { clearTimeout(timer); this.logStreams.delete(name); finish({ success: true, logs: lines.join('\n') }); });
-          stream.on('error', (e) => { clearTimeout(timer); this.logStreams.delete(name); finish({ success: false, error: e.message }); });
-        } catch (err) { clearTimeout(timer); finish({ success: false, error: err.message }); }
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async flushLogs(name) {
-    try {
-      await this.ensureConnected();
-      return new Promise((resolve) => {
-        pm2.flush(name, (err) => resolve(err ? { success: false, error: err.message } : { success: true }));
-      });
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async ping() {
-    try {
-      await this.ensureConnected();
-      return { success: true, status: 'connected' };
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  async heal() {
-    this.connected = false;
-    try {
-      await this.connect();
-      return { success: true };
-    } catch (err) { return { success: false, error: err.message }; }
-  }
-
-  disconnect() {
-    this.stopMonitoring();
-    for (const [, s] of this.logStreams) { try { s.destroy(); } catch (_) {} }
-    this.logStreams.clear();
-    this.connected = false;
-    try { pm2.disconnect(); } catch (_) {}
-  }
-}
-
-export const pm2Manager = new PM2Manager();
-export default pm2Manager;

package/lib/routes-oauth.js

@@ -1,105 +0,0 @@
-import { startGeminiOAuth, exchangeGeminiOAuthCode, getGeminiOAuthState } from './oauth-gemini.js';
-import { startCodexOAuth, exchangeCodexOAuthCode, getCodexOAuthState } from './oauth-codex.js';
-
-export function register(deps) {
-  const { sendJSON, parseBody, PORT, BASE_URL, rootDir } = deps;
-  const routes = {};
-
-  routes['POST /api/gemini-oauth/start'] = async (req, res) => {
-    try {
-      const result = await startGeminiOAuth(req, { PORT, BASE_URL, rootDir });
-      sendJSON(req, res, 200, { authUrl: result.authUrl, mode: result.mode });
-    } catch (e) {
-      console.error('[gemini-oauth] /api/gemini-oauth/start failed:', e);
-      sendJSON(req, res, 500, { error: e.message });
-    }
-  };
-
-  routes['GET /api/gemini-oauth/status'] = async (req, res) => {
-    sendJSON(req, res, 200, getGeminiOAuthState());
-  };
-
-  routes['POST /api/gemini-oauth/relay'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const { code, state: stateParam } = body;
-      if (!code || !stateParam) { sendJSON(req, res, 400, { error: 'Missing code or state' }); return; }
-      const email = await exchangeGeminiOAuthCode(code, stateParam);
-      sendJSON(req, res, 200, { success: true, email });
-    } catch (e) {
-      sendJSON(req, res, 400, { error: e.message });
-    }
-  };
-
-  routes['POST /api/gemini-oauth/complete'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const pastedUrl = (body.url || '').trim();
-      if (!pastedUrl) { sendJSON(req, res, 400, { error: 'No URL provided' }); return; }
-      let parsed;
-      try { parsed = new URL(pastedUrl); } catch (_) {
-        sendJSON(req, res, 400, { error: 'Invalid URL. Paste the full URL from the browser address bar.' }); return;
-      }
-      const error = parsed.searchParams.get('error');
-      if (error) { sendJSON(req, res, 200, { error: parsed.searchParams.get('error_description') || error }); return; }
-      const code = parsed.searchParams.get('code');
-      const state = parsed.searchParams.get('state');
-      const email = await exchangeGeminiOAuthCode(code, state);
-      sendJSON(req, res, 200, { success: true, email });
-    } catch (e) {
-      sendJSON(req, res, 400, { error: e.message });
-    }
-  };
-
-  routes['POST /api/codex-oauth/start'] = async (req, res) => {
-    try {
-      const result = await startCodexOAuth(req, { PORT, BASE_URL });
-      sendJSON(req, res, 200, { authUrl: result.authUrl, mode: result.mode });
-    } catch (e) {
-      console.error('[codex-oauth] /api/codex-oauth/start failed:', e);
-      sendJSON(req, res, 500, { error: e.message });
-    }
-  };
-
-  routes['GET /api/codex-oauth/status'] = async (req, res) => {
-    sendJSON(req, res, 200, getCodexOAuthState());
-  };
-
-  routes['POST /api/codex-oauth/relay'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const { code, state: stateParam } = body;
-      if (!code || !stateParam) { sendJSON(req, res, 400, { error: 'Missing code or state' }); return; }
-      const email = await exchangeCodexOAuthCode(code, stateParam);
-      sendJSON(req, res, 200, { success: true, email });
-    } catch (e) {
-      sendJSON(req, res, 400, { error: e.message });
-    }
-  };
-
-  routes['POST /api/codex-oauth/complete'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const pastedUrl = (body.url || '').trim();
-      if (!pastedUrl) { sendJSON(req, res, 400, { error: 'No URL provided' }); return; }
-      let parsed;
-      try { parsed = new URL(pastedUrl); } catch (_) {
-        sendJSON(req, res, 400, { error: 'Invalid URL. Paste the full URL from the browser address bar.' }); return;
-      }
-      const error = parsed.searchParams.get('error');
-      if (error) { sendJSON(req, res, 200, { error: parsed.searchParams.get('error_description') || error }); return; }
-      const code = parsed.searchParams.get('code');
-      const state = parsed.searchParams.get('state');
-      const email = await exchangeCodexOAuthCode(code, state);
-      sendJSON(req, res, 200, { success: true, email });
-    } catch (e) {
-      sendJSON(req, res, 400, { error: e.message });
-    }
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    return routes[`${method} ${pathOnly}`] || null;
-  };
-
-  return routes;
-}

package/lib/routes-speech.js

@@ -1,173 +0,0 @@
-import { getSpeech, ensurePocketTtsSetup, ensureModelsDownloaded, modelDownloadState } from './speech-manager.js';
-
-export function register(deps) {
-  const { sendJSON, parseBody, broadcastSync, debugLog } = deps;
-  const routes = {};
-
-  routes['POST /api/stt'] = async (req, res) => {
-    try {
-      const chunks = [];
-      for await (const chunk of req) chunks.push(chunk);
-      const audioBuffer = Buffer.concat(chunks);
-      if (audioBuffer.length === 0) { sendJSON(req, res, 400, { error: 'No audio data' }); return; }
-      broadcastSync({ type: 'stt_progress', status: 'transcribing', percentComplete: 0 });
-      const { transcribe } = await getSpeech();
-      const text = await transcribe(audioBuffer);
-      const finalText = (text || '').trim();
-      broadcastSync({ type: 'stt_progress', status: 'completed', percentComplete: 100, transcript: finalText });
-      sendJSON(req, res, 200, { text: finalText });
-    } catch (err) {
-      debugLog('[STT] Error: ' + err.message);
-      let errorMsg = err.message || 'STT failed';
-      if (errorMsg.includes('VERS_1.21') || errorMsg.includes('onnxruntime')) {
-        errorMsg = 'STT model load failed: onnxruntime version mismatch. Try: npm install or npm ci';
-      } else if (errorMsg.includes('not valid JSON') || errorMsg.includes('Unexpected token') || errorMsg.includes('corrupted files cleared')) {
-        try {
-          const speech = await getSpeech();
-          const cleared = speech.clearCorruptedSTTCache();
-          speech.resetSTTError();
-          await ensureModelsDownloaded();
-          errorMsg = 'STT cache was corrupted, re-downloaded models. Please try again.';
-        } catch (e) {
-          errorMsg = 'STT model load failed: corrupted cache. Recovery attempted, try again.';
-        }
-      }
-      broadcastSync({ type: 'stt_progress', status: 'failed', percentComplete: 0, error: errorMsg });
-      if (!res.headersSent) sendJSON(req, res, 500, { error: errorMsg });
-    }
-  };
-
-  routes['GET /api/voices'] = async (req, res) => {
-    try {
-      const { getVoices } = await getSpeech();
-      sendJSON(req, res, 200, { ok: true, voices: getVoices() });
-    } catch (err) {
-      sendJSON(req, res, 200, { ok: true, voices: [] });
-    }
-  };
-
-  routes['POST /api/tts'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const text = body.text || '';
-      const voiceId = body.voiceId || null;
-      if (!text) { sendJSON(req, res, 400, { error: 'No text provided' }); return; }
-      if (process.platform === 'win32') {
-        const setupOk = await ensurePocketTtsSetup((msg) => {
-          broadcastSync({ type: 'tts_setup_progress', ...msg });
-        });
-        if (!setupOk) { sendJSON(req, res, 503, { error: 'pocket-tts setup failed', retryable: false }); return; }
-        const speech = await getSpeech();
-        if (speech.preloadTTS) { speech.preloadTTS(); await new Promise(r => setTimeout(r, 2000)); }
-      }
-      const speech = await getSpeech();
-      const wavBuffer = await speech.synthesize(text, voiceId);
-      res.writeHead(200, { 'Content-Type': 'audio/wav', 'Content-Length': wavBuffer.length });
-      res.end(wavBuffer);
-    } catch (err) {
-      debugLog('[TTS] Error: ' + err.message);
-      const isModelError = /model.*load|pipeline.*failed|failed to load/i.test(err.message);
-      const statusCode = isModelError ? 503 : 500;
-      if (!res.headersSent) sendJSON(req, res, statusCode, { error: err.message || 'TTS failed', retryable: !isModelError });
-    }
-  };
-
-  routes['POST /api/tts-stream'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      const text = body.text || '';
-      const voiceId = body.voiceId || null;
-      if (!text) { sendJSON(req, res, 400, { error: 'No text provided' }); return; }
-      const speech = await getSpeech();
-      const gen = speech.synthesizeStream(text, voiceId);
-      const firstResult = await gen.next();
-      if (firstResult.done) { sendJSON(req, res, 500, { error: 'TTS stream returned no audio', retryable: true }); return; }
-      res.writeHead(200, {
-        'Content-Type': 'application/octet-stream',
-        'Transfer-Encoding': 'chunked',
-        'X-Content-Type': 'audio/wav-stream',
-        'Cache-Control': 'no-cache'
-      });
-      const writeChunk = (wavChunk) => {
-        const lenBuf = Buffer.alloc(4);
-        lenBuf.writeUInt32BE(wavChunk.length, 0);
-        res.write(lenBuf);
-        res.write(wavChunk);
-      };
-      writeChunk(firstResult.value);
-      for await (const wavChunk of gen) writeChunk(wavChunk);
-      res.end();
-    } catch (err) {
-      debugLog('[TTS-STREAM] Error: ' + err.message);
-      const isModelError = /model.*load|pipeline.*failed|failed to load/i.test(err.message);
-      if (!res.headersSent) sendJSON(req, res, isModelError ? 503 : 500, { error: err.message || 'TTS stream failed', retryable: !isModelError });
-      else res.end();
-    }
-  };
-
-  routes['GET /api/speech-status'] = async (req, res) => {
-    try {
-      const { getStatus } = await getSpeech();
-      const baseStatus = getStatus();
-      sendJSON(req, res, 200, {
-        ...baseStatus,
-        setupMessage: baseStatus.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
-        modelsDownloading: modelDownloadState.downloading,
-        modelsComplete: modelDownloadState.complete,
-        modelsError: modelDownloadState.error,
-        modelsProgress: modelDownloadState.progress,
-      });
-    } catch (err) {
-      sendJSON(req, res, 200, {
-        sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false,
-        setupMessage: 'Will setup on first TTS request',
-        modelsDownloading: modelDownloadState.downloading,
-        modelsComplete: modelDownloadState.complete,
-        modelsError: modelDownloadState.error,
-      });
-    }
-  };
-
-  routes['POST /api/speech-status'] = async (req, res) => {
-    const body = await parseBody(req);
-    if (body.forceDownload) {
-      if (modelDownloadState.complete) { sendJSON(req, res, 200, { ok: true, modelsComplete: true, message: 'Models already ready' }); return; }
-      if (!modelDownloadState.downloading) {
-        modelDownloadState.error = null;
-        ensureModelsDownloaded().then(ok => {
-          broadcastSync({ type: 'model_download_progress', progress: { done: true, complete: ok, error: ok ? null : 'Download failed' } });
-        }).catch(err => {
-          broadcastSync({ type: 'model_download_progress', progress: { done: true, error: err.message } });
-        });
-      }
-      sendJSON(req, res, 200, { ok: true, message: 'Starting model download' });
-      return;
-    }
-    sendJSON(req, res, 400, { error: 'Unknown request' });
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    const key = `${method} ${pathOnly}`;
-    if (routes[key]) return routes[key];
-    if (method === 'GET' && pathOnly.startsWith('/api/tts-cache/')) return routes['_tts-cache'];
-    return null;
-  };
-
-  routes['_tts-cache'] = async (req, res, pathOnly) => {
-    const cacheKey = decodeURIComponent(pathOnly.slice('/api/tts-cache/'.length));
-    try {
-      const speech = await getSpeech();
-      const cached = speech.ttsCacheGet(cacheKey);
-      if (cached) {
-        res.writeHead(200, { 'Content-Type': 'audio/wav', 'Content-Length': cached.length, 'Cache-Control': 'public, max-age=3600' });
-        res.end(cached);
-      } else {
-        sendJSON(req, res, 404, { error: 'not cached' });
-      }
-    } catch (err) {
-      sendJSON(req, res, 500, { error: err.message });
-    }
-  };
-
-  return routes;
-}

package/lib/routes-tools.js

@@ -1,184 +0,0 @@
-import * as toolInstallMachine from './tool-install-machine.js';
-
-export function register(deps) {
-  const { sendJSON, parseBody, queries, broadcastSync, logError, toolManager } = deps;
-
-  function mapTool(t) {
-    return {
-      id: t.id, name: t.name, pkg: t.pkg,
-      category: t.category || 'plugin',
-      installed: t.installed || false,
-      status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
-      isUpToDate: t.isUpToDate || false,
-      upgradeNeeded: t.upgradeNeeded || false,
-      hasUpdate: (t.upgradeNeeded && t.installed) || false,
-      installedVersion: t.installedVersion || null,
-      publishedVersion: t.publishedVersion || null,
-      machineState: toolInstallMachine.getState(t.id),
-    };
-  }
-
-  const routes = {};
-
-  routes['GET /api/tools'] = async (req, res) => {
-    try {
-      const tools = await Promise.race([
-        toolManager.getAllToolsAsync(true),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000))
-      ]);
-      sendJSON(req, res, 200, { tools: tools.map(mapTool) });
-    } catch (err) {
-      sendJSON(req, res, 200, { tools: toolManager.getAllToolsSync().map(mapTool) });
-    }
-  };
-
-  routes['POST /api/tools/update'] = async (req, res) => {
-    const allToolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo', 'gm-codex'];
-    sendJSON(req, res, 200, { updating: true, toolCount: allToolIds.length });
-    broadcastSync({ type: 'tools_update_started', tools: allToolIds });
-    setImmediate(async () => {
-      const results = {};
-      for (const toolId of allToolIds) {
-        try {
-          const result = await toolManager.update(toolId, (msg) => broadcastSync({ type: 'tool_update_progress', toolId, data: msg }));
-          results[toolId] = result;
-          if (result.success) {
-            const version = result.version || null;
-            queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-            queries.addToolInstallHistory(toolId, 'update', 'success', null);
-            const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-            broadcastSync({ type: 'tool_update_complete', toolId, data: { ...result, ...freshStatus } });
-          } else {
-            queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-            queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
-            broadcastSync({ type: 'tool_update_failed', toolId, data: result });
-          }
-        } catch (err) {
-          queries.updateToolStatus(toolId, { status: 'failed', error_message: err.message });
-          queries.addToolInstallHistory(toolId, 'update', 'failed', err.message);
-          broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: err.message } });
-        }
-      }
-      broadcastSync({ type: 'tools_update_complete', data: results });
-    });
-  };
-
-  routes['POST /api/tools/refresh-all'] = async (req, res) => {
-    sendJSON(req, res, 200, { refreshing: true, toolCount: 4 });
-    broadcastSync({ type: 'tools_refresh_started' });
-    setImmediate(async () => {
-      const tools = await toolManager.refreshAllToolsAsync();
-      for (const tool of tools) {
-        queries.updateToolStatus(tool.id, { status: tool.installed ? 'installed' : 'not_installed', version: tool.installedVersion, last_check_at: Date.now() });
-        if (tool.installed && tool.upgradeNeeded) {
-          queries.updateToolStatus(tool.id, { update_available: 1, latest_version: tool.publishedVersion });
-        }
-      }
-      broadcastSync({ type: 'tools_refresh_complete', data: tools });
-    });
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    const key = `${method} ${pathOnly}`;
-    if (routes[key]) return routes[key];
-    let m;
-    if ((m = pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/))) return (req, res) => handleToolStatus(req, res, m[1]);
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/))) return (req, res) => handleToolInstall(req, res, m[1]);
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/))) return (req, res) => handleToolUpdate(req, res, m[1]);
-    if (method === 'GET' && (m = pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/))) return (req, res) => handleToolHistory(req, res, m[1]);
-    return null;
-  };
-
-  async function handleToolStatus(req, res, toolId) {
-    const dbStatus = queries.getToolStatus(toolId);
-    const tmStatus = toolManager.checkToolStatus(toolId);
-    if (!tmStatus && !dbStatus) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
-    const status = {
-      toolId, installed: tmStatus?.installed || (dbStatus?.status === 'installed'),
-      isUpToDate: tmStatus?.isUpToDate || false, upgradeNeeded: tmStatus?.upgradeNeeded || false,
-      status: dbStatus?.status || (tmStatus?.installed ? 'installed' : 'not_installed'),
-      installedVersion: dbStatus?.version || tmStatus?.installedVersion || null,
-      timestamp: Date.now(), error_message: dbStatus?.error_message || null
-    };
-    if (status.installed) { const updates = await toolManager.checkForUpdates(toolId); status.hasUpdate = updates.needsUpdate || false; }
-    sendJSON(req, res, 200, status);
-  }
-
-  async function handleToolInstall(req, res, toolId) {
-    const tool = toolManager.getToolConfig(toolId);
-    if (!tool) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
-    const existing = queries.getToolStatus(toolId);
-    if (!existing) queries.insertToolInstallation(toolId, { status: 'not_installed' });
-    queries.updateToolStatus(toolId, { status: 'installing' });
-    sendJSON(req, res, 200, { success: true, installing: true, estimatedTime: 60000 });
-    let done = false;
-    const timeout = setTimeout(() => {
-      if (!done) { done = true; queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Install timeout after 6 minutes' }); broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error: 'Install timeout after 6 minutes' } }); queries.addToolInstallHistory(toolId, 'install', 'failed', 'Install timeout after 6 minutes'); }
-    }, 360000);
-    toolManager.install(toolId, (msg) => broadcastSync({ type: 'tool_install_progress', toolId, data: msg })).then(async (result) => {
-      clearTimeout(timeout); if (done) return; done = true;
-      if (result.success) {
-        const version = result.version || null;
-        queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-        const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-        broadcastSync({ type: 'tool_install_complete', toolId, data: { success: true, version, ...freshStatus } });
-        queries.addToolInstallHistory(toolId, 'install', 'success', null);
-      } else {
-        queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-        broadcastSync({ type: 'tool_install_failed', toolId, data: result });
-        queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
-      }
-    }).catch((err) => {
-      clearTimeout(timeout); if (done) return; done = true;
-      const error = err?.message || 'Unknown error';
-      logError('toolInstall', err, { toolId });
-      queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-      broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error } });
-      queries.addToolInstallHistory(toolId, 'install', 'failed', error);
-    });
-  }
-
-  async function handleToolUpdate(req, res, toolId) {
-    const body = await parseBody(req);
-    const tool = toolManager.getToolConfig(toolId);
-    if (!tool) { sendJSON(req, res, 404, { error: 'Tool not found' }); return; }
-    const current = await toolManager.checkToolStatusAsync(toolId);
-    if (!current || !current.installed) { sendJSON(req, res, 400, { error: 'Tool not installed' }); return; }
-    queries.updateToolStatus(toolId, { status: 'updating' });
-    sendJSON(req, res, 200, { success: true, updating: true });
-    let done = false;
-    const timeout = setTimeout(() => {
-      if (!done) { done = true; queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Update timeout after 6 minutes' }); broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: 'Update timeout after 6 minutes' } }); queries.addToolInstallHistory(toolId, 'update', 'failed', 'Update timeout after 6 minutes'); }
-    }, 360000);
-    toolManager.update(toolId, (msg) => broadcastSync({ type: 'tool_update_progress', toolId, data: msg })).then(async (result) => {
-      clearTimeout(timeout); if (done) return; done = true;
-      if (result.success) {
-        const version = result.version || null;
-        queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
-        const freshStatus = await toolManager.checkToolStatusAsync(toolId);
-        broadcastSync({ type: 'tool_update_complete', toolId, data: { success: true, version, ...freshStatus } });
-        queries.addToolInstallHistory(toolId, 'update', 'success', null);
-      } else {
-        queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-        broadcastSync({ type: 'tool_update_failed', toolId, data: result });
-        queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
-      }
-    }).catch((err) => {
-      clearTimeout(timeout); if (done) return; done = true;
-      const error = err?.message || 'Unknown error';
-      logError('toolUpdate', err, { toolId });
-      queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-      broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error } });
-      queries.addToolInstallHistory(toolId, 'update', 'failed', error);
-    });
-  }
-
-  async function handleToolHistory(req, res, toolId) {
-    const url = new URL(req.url, 'http://localhost');
-    const limit = Math.min(parseInt(url.searchParams.get('limit')) || 20, 100);
-    const offset = parseInt(url.searchParams.get('offset')) || 0;
-    sendJSON(req, res, 200, { history: queries.getToolInstallHistory(toolId, limit, offset) });
-  }
-
-  return routes;
-}