agentgui 1.0.218 → 1.0.220

package/lib/speech.js

@@ -4,7 +4,6 @@ import path from 'path';
 import os from 'os';
 import http from 'http';
 import { fileURLToPath } from 'url';
-import { patchWebtalkForWindows } from './webtalk-patch.js';
 
 const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -13,8 +12,6 @@ const ROOT = path.dirname(__dirname);
 const serverSTT = require('webtalk/server-stt');
 const serverTTS = require('webtalk/server-tts');
 
-patchWebtalkForWindows(serverTTS);
-
 const EXTRA_VOICE_DIRS = [path.join(ROOT, 'voices')];
 
 const POCKET_TTS_VOICES = [
@@ -124,14 +121,7 @@ function getStatus() {
 function preloadTTS() {
   const defaultVoice = serverTTS.findVoiceFile('custom_cleetus', EXTRA_VOICE_DIRS) || '/config/voices/cleetus.wav';
   const voicePath = fs.existsSync(defaultVoice) ? defaultVoice : null;
-  const options = {
-    binaryPaths: [
-      path.join(os.homedir(), '.gmgui', 'pocket-venv', 'Scripts', 'pocket-tts.exe'),
-      path.join(os.homedir(), '.gmgui', 'pocket-venv', 'bin', 'pocket-tts.exe'),
-      path.join(os.homedir(), '.gmgui', 'pocket-venv', 'bin', 'pocket-tts'),
-    ]
-  };
-  serverTTS.start(voicePath, options).then(ok => {
+  serverTTS.start(voicePath, {}).then(ok => {
     if (ok) console.log('[TTS] pocket-tts sidecar started');
     else console.log('[TTS] pocket-tts failed to start');
   }).catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.218",
+  "version": "1.0.220",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -11,44 +11,17 @@ import { createRequire } from 'module';
 import { OAuth2Client } from 'google-auth-library';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
-import { isSetup, install, detectPython } from './lib/windows-pocket-tts-setup.js';
 let speechModule = null;
 async function getSpeech() {
   if (!speechModule) speechModule = await import('./lib/speech.js');
   return speechModule;
 }
 
-const pocketTtsSetupState = { attempted: false, ready: false, error: null, inProgress: false };
-
 async function ensurePocketTtsSetup(onProgress) {
-  if (pocketTtsSetupState.attempted) {
-    return pocketTtsSetupState.ready;
-  }
-
-  if (pocketTtsSetupState.inProgress) {
-    let waited = 0;
-    const MAX_WAIT = 600000;
-    while (pocketTtsSetupState.inProgress && waited < MAX_WAIT) {
-      await new Promise(r => setTimeout(r, 100));
-      waited += 100;
-    }
-    return pocketTtsSetupState.ready;
-  }
-
-  pocketTtsSetupState.inProgress = true;
-
-  if (onProgress) onProgress({ step: 'detecting-python', status: 'in-progress', message: 'Detecting Python installation' });
-
-  const result = await install((msg) => {
-    if (onProgress) onProgress(msg);
-  });
-
-  pocketTtsSetupState.attempted = true;
-  pocketTtsSetupState.ready = result.success;
-  pocketTtsSetupState.error = result.error || null;
-  pocketTtsSetupState.inProgress = false;
-
-  return pocketTtsSetupState.ready;
+  const { createRequire: cr } = await import('module');
+  const r = cr(import.meta.url);
+  const serverTTS = r('webtalk/server-tts');
+  return serverTTS.ensureInstalled(onProgress);
 }
 
 function eagerTTS(text, conversationId, sessionId) {
@@ -1446,12 +1419,12 @@ const server = http.createServer(async (req, res) => {
           return;
         }
 
-        if (!pocketTtsSetupState.attempted && process.platform === 'win32') {
+        if (process.platform === 'win32') {
           const setupOk = await ensurePocketTtsSetup((msg) => {
             broadcastSync({ type: 'tts_setup_progress', ...msg });
           });
           if (!setupOk) {
-            sendJSON(req, res, 503, { error: pocketTtsSetupState.error || 'pocket-tts setup failed', retryable: false });
+            sendJSON(req, res, 503, { error: 'pocket-tts setup failed', retryable: false });
             return;
           }
 
@@ -1465,11 +1438,6 @@ const server = http.createServer(async (req, res) => {
         }
 
         const speech = await getSpeech();
-        const status = speech.getStatus();
-        if (status.ttsError) {
-          sendJSON(req, res, 503, { error: status.ttsError, retryable: false });
-          return;
-        }
         const wavBuffer = await speech.synthesize(text, voiceId);
         res.writeHead(200, { 'Content-Type': 'audio/wav', 'Content-Length': wavBuffer.length });
         res.end(wavBuffer);
@@ -1492,11 +1460,6 @@ const server = http.createServer(async (req, res) => {
           return;
         }
         const speech = await getSpeech();
-        const status = speech.getStatus();
-        if (status.ttsError) {
-          sendJSON(req, res, 503, { error: status.ttsError, retryable: false });
-          return;
-        }
         res.writeHead(200, {
           'Content-Type': 'application/octet-stream',
           'Transfer-Encoding': 'chunked',
@@ -1524,26 +1487,18 @@ const server = http.createServer(async (req, res) => {
       try {
         const { getStatus } = await getSpeech();
         const baseStatus = getStatus();
-        const pythonDetect = detectPython();
-        const statusWithSetup = {
+        const r = createRequire(import.meta.url);
+        const serverTTS = r('webtalk/server-tts');
+        const pyInfo = serverTTS.detectPython();
+        sendJSON(req, res, 200, {
           ...baseStatus,
-          pythonDetected: pythonDetect.found,
-          pythonVersion: pythonDetect.version,
-          pocketTtsSetup: {
-            ready: pocketTtsSetupState.ready,
-            attempted: pocketTtsSetupState.attempted,
-            error: pocketTtsSetupState.error,
-          },
-          setupMessage: pocketTtsSetupState.error || (pocketTtsSetupState.ready ? 'pocket-tts ready' : 'Will setup on first TTS request'),
-        };
-        sendJSON(req, res, 200, statusWithSetup);
+          pythonDetected: pyInfo.found,
+          pythonVersion: pyInfo.version || null,
+          setupMessage: baseStatus.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
+        });
       } catch (err) {
-        const pythonDetect = detectPython();
         sendJSON(req, res, 200, {
           sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false,
-          pythonDetected: pythonDetect.found,
-          pythonVersion: pythonDetect.version,
-          pocketTtsSetup: { ready: false, attempted: false, error: null },
           setupMessage: 'Will setup on first TTS request',
         });
       }

package/lib/webtalk-patch.js

@@ -1,33 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-export function patchWebtalkForWindows(serverTTS) {
-  if (process.platform !== 'win32') return;
-
-  const venvDir = path.join(os.homedir(), '.gmgui', 'pocket-venv');
-
-  // Check if pocket-tts exists at Windows paths
-  const windowsBinaries = [
-    path.join(venvDir, 'Scripts', 'pocket-tts.exe'),
-    path.join(venvDir, 'bin', 'pocket-tts.exe'),
-    path.join(venvDir, 'bin', 'pocket-tts'),
-  ];
-
-  const found = windowsBinaries.find(p => fs.existsSync(p));
-
-  if (found) {
-    // Patch the start function to use the correct binary
-    const originalStart = serverTTS.start;
-
-    serverTTS.start = function(voicePath, options) {
-      if (!options) options = {};
-      if (!options.binaryPaths) options.binaryPaths = [];
-
-      // Ensure Windows paths are first
-      options.binaryPaths = [...windowsBinaries, ...options.binaryPaths];
-
-      return originalStart.call(this, voicePath, options);
-    };
-  }
-}

package/lib/windows-pocket-tts-setup.js

@@ -1,215 +0,0 @@
-import { execSync, spawnSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-const PYTHON_VERSION_MIN = [3, 9];
-const VENV_DIR = path.join(os.homedir(), '.gmgui', 'pocket-venv');
-const isWin = process.platform === 'win32';
-const EXECUTABLE_NAME = isWin ? 'pocket-tts.exe' : 'pocket-tts';
-
-const CONFIG = {
-  PIP_TIMEOUT: 120000,
-  VENV_CREATION_TIMEOUT: 30000,
-  MAX_RETRIES: 3,
-  RETRY_DELAY_MS: 1000,
-  RETRY_BACKOFF_MULTIPLIER: 2,
-};
-
-function getPocketTtsPath() {
-  if (isWin) {
-    return path.join(VENV_DIR, 'Scripts', EXECUTABLE_NAME);
-  }
-  return path.join(VENV_DIR, 'bin', EXECUTABLE_NAME);
-}
-
-function detectPython() {
-  try {
-    const versionOutput = execSync('python --version', { encoding: 'utf-8', timeout: 10000 }).trim();
-    const match = versionOutput.match(/(\d+)\.(\d+)/);
-    if (!match) return { found: false, version: null, error: 'Could not parse version' };
-
-    const major = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-    const versionOk = major > PYTHON_VERSION_MIN[0] || (major === PYTHON_VERSION_MIN[0] && minor >= PYTHON_VERSION_MIN[1]);
-
-    if (!versionOk) {
-      return { found: true, version: `${major}.${minor}`, error: `Python ${major}.${minor} found but ${PYTHON_VERSION_MIN[0]}.${PYTHON_VERSION_MIN[1]}+ required` };
-    }
-
-    return { found: true, version: `${major}.${minor}`, error: null };
-  } catch (e) {
-    return { found: false, version: null, error: 'Python not found in PATH' };
-  }
-}
-
-function isSetup() {
-  const exePath = getPocketTtsPath();
-  return fs.existsSync(exePath);
-}
-
-function cleanupPartialInstall() {
-  try {
-    if (fs.existsSync(VENV_DIR)) {
-      fs.rmSync(VENV_DIR, { recursive: true, force: true });
-      return true;
-    }
-  } catch (e) {
-    console.error(`Failed to cleanup partial install: ${e.message}`);
-  }
-  return false;
-}
-
-function verifyInstallation() {
-  const exePath = getPocketTtsPath();
-  if (!fs.existsSync(exePath)) {
-    return { valid: false, error: `Binary not found at ${exePath}` };
-  }
-
-  try {
-    const result = spawnSync(exePath, ['--help'], { encoding: 'utf-8', timeout: 10000, stdio: 'pipe' });
-    if (result.status === 0 || (result.stdout && result.stdout.includes('pocket-tts'))) {
-      return { valid: true, version: 'installed' };
-    }
-    if (result.stderr && result.stderr.includes('pocket-tts')) {
-      return { valid: true, version: 'installed' };
-    }
-    return { valid: true, version: 'binary-exists' };
-  } catch (e) {
-    return { valid: false, error: `Binary exists but failed verification: ${e.message}` };
-  }
-}
-
-async function executeWithRetry(fn, stepName, maxRetries = CONFIG.MAX_RETRIES) {
-  let lastError = null;
-  let delayMs = CONFIG.RETRY_DELAY_MS;
-
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn(attempt);
-    } catch (e) {
-      lastError = e;
-      if (attempt < maxRetries) {
-        console.log(`Attempt ${attempt}/${maxRetries} failed for ${stepName}, retrying in ${delayMs}ms`);
-        await new Promise(r => setTimeout(r, delayMs));
-        delayMs *= CONFIG.RETRY_BACKOFF_MULTIPLIER;
-      }
-    }
-  }
-
-  const msg = `${stepName} failed after ${maxRetries} attempts: ${lastError.message || lastError}`;
-  throw new Error(msg);
-}
-
-async function install(onProgress) {
-  const pythonDetect = detectPython();
-
-  if (!pythonDetect.found) {
-    const msg = pythonDetect.error || 'Python not found';
-    if (onProgress) onProgress({ step: 'detecting-python', status: 'error', message: msg });
-    return { success: false, error: msg };
-  }
-
-  if (pythonDetect.error) {
-    if (onProgress) onProgress({ step: 'detecting-python', status: 'error', message: pythonDetect.error });
-    return { success: false, error: pythonDetect.error };
-  }
-
-  if (onProgress) onProgress({ step: 'detecting-python', status: 'success', message: `Found Python ${pythonDetect.version}` });
-
-  if (isSetup()) {
-    const verify = verifyInstallation();
-    if (verify.valid) {
-      if (onProgress) onProgress({ step: 'verifying', status: 'success', message: 'pocket-tts already installed' });
-      return { success: true };
-    }
-  }
-
-  if (onProgress) onProgress({ step: 'creating-venv', status: 'in-progress', message: `Creating virtual environment at ${VENV_DIR}` });
-
-  try {
-    await executeWithRetry(async (attempt) => {
-      return execSync(`python -m venv "${VENV_DIR}"`, {
-        encoding: 'utf-8',
-        stdio: 'pipe',
-        timeout: CONFIG.VENV_CREATION_TIMEOUT,
-      });
-    }, 'venv creation', 2);
-
-    if (onProgress) onProgress({ step: 'creating-venv', status: 'success', message: 'Virtual environment created' });
-  } catch (e) {
-    const msg = `Failed to create venv: ${e.message || e}`;
-    if (onProgress) onProgress({ step: 'creating-venv', status: 'error', message: msg });
-    cleanupPartialInstall();
-    return { success: false, error: msg };
-  }
-
-  if (onProgress) onProgress({ step: 'installing', status: 'in-progress', message: 'Installing pocket-tts via pip (this may take 2-5 minutes on slow connections)' });
-
-  try {
-    await executeWithRetry(async (attempt) => {
-      if (attempt > 1 && onProgress) {
-        onProgress({ step: 'installing', status: 'in-progress', message: `Installing pocket-tts (attempt ${attempt}/${CONFIG.MAX_RETRIES})` });
-      }
-
-      const pipCmd = isWin
-        ? `"${path.join(VENV_DIR, 'Scripts', 'pip')}" install --no-cache-dir pocket-tts`
-        : `"${path.join(VENV_DIR, 'bin', 'pip')}" install --no-cache-dir pocket-tts`;
-
-      return execSync(pipCmd, {
-        encoding: 'utf-8',
-        stdio: 'pipe',
-        timeout: CONFIG.PIP_TIMEOUT,
-        env: { ...process.env, PIP_DEFAULT_TIMEOUT: '120' },
-      });
-    }, 'pip install', CONFIG.MAX_RETRIES);
-
-    if (onProgress) onProgress({ step: 'installing', status: 'success', message: 'pocket-tts installed successfully' });
-  } catch (e) {
-    const msg = `Failed to install pocket-tts: ${e.message || e}`;
-    if (onProgress) onProgress({ step: 'installing', status: 'error', message: msg });
-    cleanupPartialInstall();
-    return { success: false, error: msg };
-  }
-
-  if (onProgress) onProgress({ step: 'verifying', status: 'in-progress', message: 'Verifying installation' });
-
-  const verify = verifyInstallation();
-  if (!verify.valid) {
-    const msg = verify.error || 'Installation verification failed';
-    if (onProgress) onProgress({ step: 'verifying', status: 'error', message: msg });
-    cleanupPartialInstall();
-    return { success: false, error: msg };
-  }
-
-  const exePath = getPocketTtsPath();
-  const binDir = path.join(VENV_DIR, 'bin');
-  const binExePath = path.join(binDir, 'pocket-tts');
-
-  if (isWin) {
-    try {
-      fs.mkdirSync(binDir, { recursive: true });
-    } catch (e) {}
-
-    const exeWithExt = path.join(binDir, 'pocket-tts.exe');
-    if (fs.existsSync(exePath) && !fs.existsSync(exeWithExt)) {
-      try {
-        fs.copyFileSync(exePath, exeWithExt);
-      } catch (e) {}
-    }
-
-    const batchFile = path.join(binDir, 'pocket-tts.bat');
-    if (!fs.existsSync(batchFile) && fs.existsSync(exeWithExt)) {
-      try {
-        const batchContent = `@echo off\nsetlocal enabledelayedexpansion\nset PYTHONUNBUFFERED=1\nset HF_HUB_DISABLE_SYMLINKS_WARNING=1\n"${exeWithExt}" %*\n`;
-        fs.writeFileSync(batchFile, batchContent, 'utf-8');
-      } catch (e) {}
-    }
-  }
-
-  if (onProgress) onProgress({ step: 'verifying', status: 'success', message: `pocket-tts ready (${verify.version})` });
-
-  return { success: true };
-}
-
-export { detectPython, isSetup, install, getPocketTtsPath, VENV_DIR, CONFIG, cleanupPartialInstall, verifyInstallation };