agentgui 1.0.757 → 1.0.759

package/lib/routes-oauth.js

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,173 @@
+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/package.json

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

package/server.js

@@ -19,6 +19,8 @@ import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descripto
 import { findCommand, queryACPServerAgents, discoverAgents, discoverExternalACPServers, initializeAgentDiscovery } from './lib/agent-discovery.js';
 import { getGeminiOAuthCreds, startGeminiOAuth, exchangeGeminiOAuthCode, handleGeminiOAuthCallback, getGeminiOAuthStatus, getGeminiOAuthState } from './lib/oauth-gemini.js';
 import { initSpeechManager, getSpeech, ensurePocketTtsSetup, voiceCacheManager, modelDownloadState, broadcastModelProgress, ensureModelsDownloaded, eagerTTS } from './lib/speech-manager.js';
+import { register as registerSpeechRoutes } from './lib/routes-speech.js';
+import { register as registerOAuthRoutes } from './lib/routes-oauth.js';
 import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getCodexOAuthStatus, getCodexOAuthState, CODEX_HOME, CODEX_AUTH_FILE } from './lib/oauth-codex.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
@@ -1998,130 +2000,8 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/gemini-oauth/start' && req.method === 'POST') {
-      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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/gemini-oauth/status' && req.method === 'GET') {
-      sendJSON(req, res, 200, getGeminiOAuthState());
-      return;
-    }
-
-    if (pathOnly === '/api/gemini-oauth/relay' && req.method === 'POST') {
-      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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/gemini-oauth/complete' && req.method === 'POST') {
-      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) {
-          const desc = parsed.searchParams.get('error_description') || error;
-          sendJSON(req, res, 200, { error: desc });
-          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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/codex-oauth/start' && req.method === 'POST') {
-      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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/codex-oauth/status' && req.method === 'GET') {
-      sendJSON(req, res, 200, getCodexOAuthState());
-      return;
-    }
-
-    if (pathOnly === '/api/codex-oauth/relay' && req.method === 'POST') {
-      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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/codex-oauth/complete' && req.method === 'POST') {
-      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) {
-          const desc = parsed.searchParams.get('error_description') || error;
-          sendJSON(req, res, 200, { error: desc });
-          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 });
-      }
-      return;
-    }
+    const oauthHandler = _oauthRoutes._match(req.method, pathOnly);
+    if (oauthHandler) { await oauthHandler(req, res); return; }
 
     const agentAuthMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/auth$/);
     if (agentAuthMatch && req.method === 'POST') {
@@ -2317,207 +2197,8 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/stt' && req.method === 'POST') {
-      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();
-            console.log('[STT] Cleared', cleared, 'corrupted files and reset error state');
-            await ensureModelsDownloaded();
-            errorMsg = 'STT cache was corrupted, re-downloaded models. Please try again.';
-          } catch (e) {
-            console.warn('[STT] Recovery failed:', e.message);
-            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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/voices' && req.method === 'GET') {
-      try {
-        const { getVoices } = await getSpeech();
-        sendJSON(req, res, 200, { ok: true, voices: getVoices() });
-      } catch (err) {
-        sendJSON(req, res, 200, { ok: true, voices: [] });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/tts' && req.method === 'POST') {
-      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;
-          }
-
-          // After successful setup, start the TTS sidecar if not already running
-          const speech = await getSpeech();
-          if (speech.preloadTTS) {
-            speech.preloadTTS();
-            // Wait a bit for it to start
-            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 });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/tts-stream' && req.method === 'POST') {
-      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);
-        const statusCode = isModelError ? 503 : 500;
-        if (!res.headersSent) sendJSON(req, res, statusCode, { error: err.message || 'TTS stream failed', retryable: !isModelError });
-        else res.end();
-      }
-      return;
-    }
-
-    if (pathOnly.startsWith('/api/tts-cache/') && req.method === 'GET') {
-      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;
-    }
-
-    if (pathOnly === '/api/speech-status' && req.method === 'GET') {
-      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,
-        });
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/speech-status' && req.method === 'POST') {
-      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' });
-      return;
-    }
+    const speechHandler = _speechRoutes._match(req.method, pathOnly);
+    if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
 
     if (pathOnly === '/api/clone' && req.method === 'POST') {
       const body = await parseBody(req);
@@ -3742,6 +3423,8 @@ function broadcastSync(event) {
 const wsRouter = new WsRouter();
 
 initSpeechManager({ broadcastSync, syncClients, queries });
+const _speechRoutes = registerSpeechRoutes({ sendJSON, parseBody, broadcastSync, debugLog });
+const _oauthRoutes = registerOAuthRoutes({ sendJSON, parseBody, PORT, BASE_URL, rootDir });
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,