agentgui 1.0.208 → 1.0.209

package/CLAUDE.md

@@ -89,3 +89,53 @@ Server broadcasts:
 - `streaming_complete` - Execution finished
 - `streaming_error` - Execution failed
 - `conversation_created`, `conversation_updated`, `conversation_deleted`
+- `tts_setup_progress` - Windows pocket-tts setup progress (step, status, message)
+
+## Pocket-TTS Windows Setup (Reliability for Slow/Bad Internet)
+
+On Windows, text-to-speech uses pocket-tts which requires Python and pip install. The setup process is now resilient to slow/unreliable connections:
+
+### Features
+- **Extended timeouts**: 120s for pip install (accommodates slow connections)
+- **Retry logic**: 3 attempts with exponential backoff (1s, 2s delays)
+- **Progress reporting**: Real-time updates via WebSocket to UI
+- **Partial install cleanup**: Failed venvs are removed to allow retry
+- **Installation verification**: Binary validation via `--version` check
+- **Concurrent waiting**: Multiple simultaneous requests wait for single setup (600s timeout)
+
+### Configuration (lib/windows-pocket-tts-setup.js)
+```javascript
+const CONFIG = {
+  PIP_TIMEOUT: 120000,           // 2 minutes
+  VENV_CREATION_TIMEOUT: 30000,  // 30 seconds
+  MAX_RETRIES: 3,                 // 3 attempts
+  RETRY_DELAY_MS: 1000,          // 1 second initial
+  RETRY_BACKOFF_MULTIPLIER: 2,   // 2x exponential
+};
+```
+
+### Network Requirements
+- **Minimum**: 50 kbps sustained, < 5s latency, < 10% packet loss
+- **Recommended**: 256+ kbps, < 2s latency, < 1% packet loss
+- **Expected time on slow connection**: 2-6 minutes with retries
+
+### Progress Messages
+During TTS setup on first use, WebSocket broadcasts:
+```json
+{
+  "type": "tts_setup_progress",
+  "step": "detecting-python|creating-venv|installing|verifying",
+  "status": "in-progress|success|error",
+  "message": "descriptive status message with retry count if applicable"
+}
+```
+
+### Recovery Behavior
+1. Network timeout → auto-retry with backoff
+2. Partial venv → auto-cleanup before retry
+3. Failed verification → auto-cleanup and error
+4. Concurrent requests → first starts setup, others wait up to 600s
+5. Interrupted setup → cleanup allows fresh retry
+
+### Testing
+Setup validates by running pocket-tts binary with `--version` flag to confirm functional installation, not just file existence.

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

@@ -8,6 +8,14 @@ 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);
@@ -17,7 +25,7 @@ function getPocketTtsPath() {
 
 function detectPython() {
   try {
-    const versionOutput = execSync('python --version', { encoding: 'utf-8' }).trim();
+    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' };
 
@@ -40,6 +48,53 @@ function isSetup() {
   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 versionOutput = execSync(`"${exePath}" --version`, { encoding: 'utf-8', timeout: 10000, stdio: 'pipe' });
+    return { valid: true, version: versionOutput.trim() };
+  } 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();
 
@@ -57,56 +112,79 @@ async function install(onProgress) {
   if (onProgress) onProgress({ step: 'detecting-python', status: 'success', message: `Found Python ${pythonDetect.version}` });
 
   if (isSetup()) {
-    if (onProgress) onProgress({ step: 'verifying', status: 'success', message: 'pocket-tts already installed' });
-    return { success: true };
+    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 {
-    const mkdirResult = execSync(`python -m venv "${VENV_DIR}"`, { encoding: 'utf-8', stdio: 'pipe' });
+    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.stderr || 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 a minute)' });
+  if (onProgress) onProgress({ step: 'installing', status: 'in-progress', message: 'Installing pocket-tts via pip (this may take 2-5 minutes on slow connections)' });
 
   try {
-    const pipCmd = isWin
-      ? `"${path.join(VENV_DIR, 'Scripts', 'pip')}" install pocket-tts`
-      : `"${path.join(VENV_DIR, 'bin', 'pip')}" install pocket-tts`;
+    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);
 
-    const installResult = execSync(pipCmd, { encoding: 'utf-8', stdio: 'pipe', timeout: 300000 });
     if (onProgress) onProgress({ step: 'installing', status: 'success', message: 'pocket-tts installed successfully' });
   } catch (e) {
-    const msg = `Failed to install pocket-tts: ${e.message || e.stderr || 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 exePath = getPocketTtsPath();
-  const binDir = path.join(VENV_DIR, 'bin');
-  const binExePath = path.join(binDir, 'pocket-tts');
-
-  if (!fs.existsSync(exePath)) {
-    const msg = `pocket-tts binary not found at ${exePath}`;
+  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 };
   }
 
-  // On Windows, webtalk looks for pocket-tts in bin/ (Unix path structure)
-  // Copy the executable there for compatibility with Node.js spawn()
+  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) {}
 
-    // Copy pocket-tts.exe to bin folder
     const exeWithExt = path.join(binDir, 'pocket-tts.exe');
     if (fs.existsSync(exePath) && !fs.existsSync(exeWithExt)) {
       try {
@@ -114,7 +192,6 @@ async function install(onProgress) {
       } catch (e) {}
     }
 
-    // Create a batch file wrapper for Node.js spawn compatibility
     const batchFile = path.join(binDir, 'pocket-tts.bat');
     if (!fs.existsSync(batchFile) && fs.existsSync(exeWithExt)) {
       try {
@@ -124,9 +201,9 @@ async function install(onProgress) {
     }
   }
 
-  if (onProgress) onProgress({ step: 'verifying', status: 'success', message: 'pocket-tts ready' });
+  if (onProgress) onProgress({ step: 'verifying', status: 'success', message: `pocket-tts ready (${verify.version})` });
 
   return { success: true };
 }
 
-export { detectPython, isSetup, install, getPocketTtsPath, VENV_DIR };
+export { detectPython, isSetup, install, getPocketTtsPath, VENV_DIR, CONFIG, cleanupPartialInstall, verifyInstallation };

package/package.json

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

package/server.js

@@ -27,7 +27,8 @@ async function ensurePocketTtsSetup(onProgress) {
 
   if (pocketTtsSetupState.inProgress) {
     let waited = 0;
-    while (pocketTtsSetupState.inProgress && waited < 30000) {
+    const MAX_WAIT = 600000;
+    while (pocketTtsSetupState.inProgress && waited < MAX_WAIT) {
       await new Promise(r => setTimeout(r, 100));
       waited += 100;
     }