agentgui 1.0.191 → 1.0.192

package/lib/speech.js

@@ -1,17 +1,75 @@
 import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
+import http from 'http';
 import { fileURLToPath } from 'url';
 
 const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.dirname(__dirname);
 
-// Use webtalk's server-side modules
 const serverSTT = require('webtalk/server-stt');
 const serverTTS = require('webtalk/server-tts');
 
 const EXTRA_VOICE_DIRS = [path.join(ROOT, 'voices')];
+const TTS_PORT = 8787;
+
+const TTS_CACHE_MAX = 10 * 1024 * 1024;
+let cacheBytes = 0;
+const cache = new Map();
+const inflight = new Map();
+
+function resolveVoice(voiceId) {
+  if (!voiceId || voiceId === 'default') return null;
+  return serverTTS.findVoiceFile(voiceId, EXTRA_VOICE_DIRS);
+}
+
+function cachePut(key, buf) {
+  if (cache.has(key)) { cacheBytes -= cache.get(key).length; cache.delete(key); }
+  while (cacheBytes + buf.length > TTS_CACHE_MAX && cache.size > 0) {
+    const oldest = cache.keys().next().value;
+    cacheBytes -= cache.get(oldest).length;
+    cache.delete(oldest);
+  }
+  cache.set(key, buf);
+  cacheBytes += buf.length;
+}
+
+function sendToPocket(text, voicePath) {
+  return new Promise((resolve, reject) => {
+    const boundary = '----PocketTTS' + Date.now();
+    const parts = [];
+    parts.push(`--${boundary}\r\nContent-Disposition: form-data; name="text"\r\n\r\n${text}\r\n`);
+    if (voicePath) {
+      const data = fs.readFileSync(voicePath);
+      const name = path.basename(voicePath);
+      parts.push(`--${boundary}\r\nContent-Disposition: form-data; name="voice_wav"; filename="${name}"\r\nContent-Type: audio/wav\r\n\r\n`);
+      parts.push(data);
+      parts.push('\r\n');
+    }
+    parts.push(`--${boundary}--\r\n`);
+    const body = Buffer.concat(parts.map(p => Buffer.isBuffer(p) ? p : Buffer.from(p)));
+    const req = http.request({
+      hostname: '127.0.0.1', port: TTS_PORT, path: '/tts', method: 'POST',
+      headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}`, 'Content-Length': body.length },
+      timeout: 60000,
+    }, res => {
+      if (res.statusCode !== 200) {
+        let e = '';
+        res.on('data', d => e += d);
+        res.on('end', () => reject(new Error(`pocket-tts HTTP ${res.statusCode}: ${e}`)));
+        return;
+      }
+      const chunks = [];
+      res.on('data', d => chunks.push(d));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('pocket-tts timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
 
 function transcribe(audioBuffer) {
   return serverSTT.transcribe(audioBuffer);
@@ -21,12 +79,37 @@ function getSTT() {
   return serverSTT.getSTT();
 }
 
-function synthesize(text, voiceId) {
-  return serverTTS.synthesize(text, voiceId, EXTRA_VOICE_DIRS);
+async function synthesize(text, voiceId) {
+  const status = serverTTS.getStatus();
+  if (!status.ready) throw new Error('pocket-tts not healthy');
+  const key = (voiceId || 'default') + ':' + text;
+  const cached = cache.get(key);
+  if (cached) { cache.delete(key); cache.set(key, cached); return cached; }
+  const existing = inflight.get(key);
+  if (existing) return existing;
+  const promise = (async () => {
+    const voicePath = resolveVoice(voiceId);
+    const wav = await sendToPocket(text, voicePath);
+    if (!wav || wav.length <= 44) throw new Error('pocket-tts returned empty audio');
+    cachePut(key, wav);
+    return wav;
+  })();
+  inflight.set(key, promise);
+  try { return await promise; } finally { inflight.delete(key); }
 }
 
-function synthesizeStream(text, voiceId) {
-  return serverTTS.synthesizeStream(text, voiceId, EXTRA_VOICE_DIRS);
+async function* synthesizeStream(text, voiceId) {
+  const status = serverTTS.getStatus();
+  if (!status.ready) throw new Error('pocket-tts not healthy');
+  const sentences = splitSentences(text);
+  for (const sentence of sentences) {
+    const key = (voiceId || 'default') + ':' + sentence;
+    const cached = cache.get(key);
+    if (cached) { cache.delete(key); cache.set(key, cached); yield cached; continue; }
+    const voicePath = resolveVoice(voiceId);
+    const wav = await sendToPocket(sentence, voicePath);
+    if (wav && wav.length > 44) { cachePut(key, wav); yield wav; }
+  }
 }
 
 function getVoices() {
@@ -59,15 +142,19 @@ function preloadTTS() {
 }
 
 function ttsCacheKey(text, voiceId) {
-  return serverTTS.ttsCacheKey(text, voiceId);
+  return (voiceId || 'default') + ':' + text;
 }
 
 function ttsCacheGet(key) {
-  return serverTTS.ttsCacheGet(key);
+  const cached = cache.get(key);
+  if (cached) { cache.delete(key); cache.set(key, cached); }
+  return cached || null;
 }
 
 function splitSentences(text) {
-  return serverTTS.splitSentences(text);
+  const raw = text.match(/[^.!?]+[.!?]+[\s]?|[^.!?]+$/g);
+  if (!raw) return [text];
+  return raw.map(s => s.trim()).filter(s => s.length > 0);
 }
 
 export { transcribe, synthesize, synthesizeStream, getSTT, getStatus, getVoices, preloadTTS, ttsCacheKey, ttsCacheGet, splitSentences };

package/package.json

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

package/lib/pocket-sidecar.js

@@ -1,221 +0,0 @@
-import { spawn } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
-import { fileURLToPath } from 'url';
-import http from 'http';
-
-const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const PORT = 8787;
-
-const FALLBACK_VOICE = 'alba';
-const state = {
-  process: null, port: PORT, status: 'stopped', pid: null,
-  restartCount: 0, failureCount: 0, lastError: null,
-  healthy: false, voicePath: null, starting: false,
-  shutdownRequested: false, healthTimer: null, restartTimer: null,
-  voiceCloning: false, adopted: false,
-};
-globalThis.__pocketSidecar = state;
-
-function findBinary() {
-  const candidates = [
-    path.join(ROOT, 'data', 'pocket-venv', 'bin', 'pocket-tts'),
-    '/config/workspace/agentgui/data/pocket-venv/bin/pocket-tts',
-    path.join(os.homedir(), '.gmgui', 'pocket-venv', 'bin', 'pocket-tts'),
-  ];
-  for (const p of candidates) if (fs.existsSync(p)) return p;
-  return null;
-}
-
-function isInstalled() { return !!findBinary(); }
-
-function findVoiceFile(voiceId) {
-  if (!voiceId || voiceId === 'default') return null;
-  const baseName = voiceId.replace(/^custom_/, '');
-  const dirs = [
-    path.join(process.env.STARTUP_CWD || process.cwd(), 'voices'),
-    path.join(ROOT, 'voices'), path.join(os.homedir(), 'voices'), '/config/voices',
-  ];
-  for (const dir of dirs)
-    for (const ext of ['.wav', '.mp3', '.ogg', '.flac']) {
-      const p = path.join(dir, baseName + ext);
-      if (fs.existsSync(p)) return p;
-    }
-  return null;
-}
-
-function healthCheck() {
-  return new Promise((resolve) => {
-    const req = http.get(`http://127.0.0.1:${PORT}/health`, { timeout: 3000 }, (res) => {
-      res.resume();
-      res.on('end', () => { state.healthy = res.statusCode === 200; resolve(state.healthy); });
-    });
-    req.on('error', () => { state.healthy = false; resolve(false); });
-    req.on('timeout', () => { req.destroy(); state.healthy = false; resolve(false); });
-  });
-}
-
-function killProcess() {
-  if (state.process) { try { state.process.kill('SIGTERM'); } catch (_) {} }
-  state.process = null; state.pid = null; state.healthy = false; state.status = 'stopped';
-}
-
-function scheduleRestart() {
-  if (state.shutdownRequested) return;
-  if (!state.adopted) killProcess();
-  const delay = Math.min(1000 * Math.pow(2, state.restartCount), 30000);
-  state.restartCount++;
-  console.log(`[POCKET-TTS] Restart in ${delay}ms (attempt ${state.restartCount})`);
-  state.restartTimer = setTimeout(() => {
-    state.restartTimer = null;
-    state.adopted = false;
-    start(state.voicePath).catch(e => console.error('[POCKET-TTS] Restart failed:', e.message));
-  }, delay);
-}
-
-function spawnSidecar(voice) {
-  const bin = findBinary();
-  if (!bin) throw new Error('pocket-tts binary not found');
-  const args = ['serve', '--host', '0.0.0.0', '--port', String(PORT)];
-  if (voice) args.push('--voice', voice);
-  console.log('[POCKET-TTS] Starting:', bin, args.join(' '));
-  return spawn(bin, args, {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, PYTHONUNBUFFERED: '1' },
-  });
-}
-
-function attachProc(proc) {
-  state.process = proc; state.pid = proc.pid; state.status = 'starting';
-  proc.stdout.on('data', d => { const l = d.toString().trim(); if (l) console.log('[POCKET-TTS]', l); });
-  proc.stderr.on('data', d => { const l = d.toString().trim(); if (l) console.error('[POCKET-TTS]', l); });
-  proc.on('error', e => { state.lastError = e.message; });
-}
-
-async function waitForReady(proc, timeoutSec) {
-  let exited = false;
-  proc.on('exit', () => { exited = true; });
-  for (let i = 0; i < timeoutSec; i++) {
-    if (exited) return false;
-    await new Promise(r => setTimeout(r, 1000));
-    if (await healthCheck()) return true;
-  }
-  return false;
-}
-
-async function adoptRunning() {
-  if (await healthCheck()) {
-    state.status = 'running'; state.healthy = true; state.adopted = true;
-    state.restartCount = 0; state.failureCount = 0; state.lastError = null;
-    if (!state.healthTimer) state.healthTimer = setInterval(async () => {
-      if (state.status !== 'running') return;
-      const ok = await healthCheck();
-      if (!ok && !state.shutdownRequested) {
-        state.failureCount++;
-        if (state.failureCount >= 3) { state.adopted = false; scheduleRestart(); }
-      } else if (ok) state.failureCount = 0;
-    }, 10000);
-    console.log('[POCKET-TTS] Adopted existing instance on port', PORT);
-    return true;
-  }
-  return false;
-}
-
-async function start(voicePath) {
-  if (state.starting) return false;
-  if (state.status === 'running' && state.healthy) return true;
-  if (await adoptRunning()) return true;
-  if (!isInstalled()) { state.lastError = 'not installed'; state.status = 'unavailable'; return false; }
-  state.starting = true; state.shutdownRequested = false;
-  const requestedVoice = voicePath || state.voicePath;
-  try {
-    killProcess();
-    let proc = spawnSidecar(requestedVoice);
-    attachProc(proc);
-    let ready = await waitForReady(proc, 120);
-    if (!ready && requestedVoice && requestedVoice !== FALLBACK_VOICE) {
-      console.log('[POCKET-TTS] Custom voice failed, trying predefined voice:', FALLBACK_VOICE);
-      killProcess();
-      proc = spawnSidecar(FALLBACK_VOICE);
-      attachProc(proc);
-      state.voiceCloning = false;
-      ready = await waitForReady(proc, 120);
-      if (ready) state.voicePath = FALLBACK_VOICE;
-    } else if (ready) {
-      state.voicePath = requestedVoice;
-      state.voiceCloning = !!requestedVoice && !['alba','marius','javert','jean','fantine','cosette','eponine','azelma'].includes(requestedVoice);
-    }
-    if (ready) {
-      state.status = 'running'; state.restartCount = 0; state.failureCount = 0; state.lastError = null;
-      proc.on('exit', (code, sig) => {
-        console.log(`[POCKET-TTS] Exited: code=${code} signal=${sig}`);
-        state.process = null; state.pid = null; state.healthy = false; state.status = 'stopped';
-        if (!state.shutdownRequested) scheduleRestart();
-      });
-      if (!state.healthTimer) state.healthTimer = setInterval(async () => {
-        if (state.status !== 'running') return;
-        const ok = await healthCheck();
-        if (!ok && !state.shutdownRequested) {
-          state.failureCount++;
-          if (state.failureCount >= 3) scheduleRestart();
-        } else if (ok) state.failureCount = 0;
-      }, 10000);
-      console.log('[POCKET-TTS] Ready on port', PORT, '(voice cloning:', state.voiceCloning + ')');
-      return true;
-    }
-    state.lastError = 'Start timeout'; state.status = 'error'; killProcess(); return false;
-  } catch (err) {
-    state.lastError = err.message; state.status = 'error'; return false;
-  } finally { state.starting = false; }
-}
-
-async function stop() {
-  state.shutdownRequested = true;
-  if (state.healthTimer) { clearInterval(state.healthTimer); state.healthTimer = null; }
-  if (state.restartTimer) { clearTimeout(state.restartTimer); state.restartTimer = null; }
-  killProcess();
-}
-
-async function synthesize(text, voicePath) {
-  if (!state.healthy) throw new Error('pocket-tts not ready');
-  const boundary = '----PocketTTS' + Date.now();
-  const parts = [];
-  parts.push(`--${boundary}\r\nContent-Disposition: form-data; name="text"\r\n\r\n${text}\r\n`);
-  if (state.voiceCloning && voicePath && voicePath !== state.voicePath) {
-    const data = fs.readFileSync(voicePath);
-    const name = path.basename(voicePath);
-    parts.push(`--${boundary}\r\nContent-Disposition: form-data; name="voice_wav"; filename="${name}"\r\nContent-Type: audio/wav\r\n\r\n`);
-    parts.push(data); parts.push('\r\n');
-  }
-  parts.push(`--${boundary}--\r\n`);
-  const body = Buffer.concat(parts.map(p => Buffer.isBuffer(p) ? p : Buffer.from(p)));
-  return new Promise((resolve, reject) => {
-    const req = http.request({
-      hostname: '127.0.0.1', port: PORT, path: '/tts', method: 'POST',
-      headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}`, 'Content-Length': body.length },
-      timeout: 60000,
-    }, res => {
-      if (res.statusCode !== 200) {
-        let e = ''; res.on('data', d => e += d);
-        res.on('end', () => reject(new Error(`pocket-tts HTTP ${res.statusCode}: ${e}`)));
-        return;
-      }
-      const chunks = []; res.on('data', d => chunks.push(d));
-      res.on('end', () => resolve(Buffer.concat(chunks)));
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('pocket-tts timeout')); });
-    req.write(body); req.end();
-  });
-}
-
-function getState() {
-  return {
-    status: state.status, healthy: state.healthy, pid: state.pid, port: state.port,
-    restartCount: state.restartCount, failureCount: state.failureCount,
-    lastError: state.lastError, installed: isInstalled(), voiceCloning: state.voiceCloning,
-  };
-}
-
-export { start, stop, synthesize, healthCheck, getState, isInstalled, findVoiceFile };