agentgui 1.0.753 → 1.0.755

package/CLAUDE.md

@@ -24,6 +24,7 @@ lib/acp-runner.js      ACP JSON-RPC session lifecycle (init, session/new, prompt
 lib/acp-protocol.js    ACP session/update message normalization (shared by all ACP agents)
 lib/acp-sdk-manager.js ACP tool lifecycle - on-demand start opencode/kilo/codex, health checks, idle timeout
 lib/acp-server-machine.js  XState v5 machine per ACP tool: stopped/starting/running/crashed/restarting states
+lib/agent-discovery.js Agent binary detection (findCommand), ACP server query, discoverAgents, CLI wrapper logic
 lib/agent-registry-configs.js  Agent registration configs (Claude Code, OpenCode, Gemini, 10+ ACP agents)
 lib/agent-descriptors.js  Data-driven ACP agent descriptor builder
 lib/checkpoint-manager.js  Session recovery - load checkpoints, inject into resume flow, idempotency
@@ -32,15 +33,19 @@ lib/db-queries.js      All 88 query functions (createQueries factory, extracted
 lib/execution-machine.js   XState v5 machine per conversation: idle/streaming/draining/rate_limited states
 lib/gm-agent-configs.js    GM agent configuration and spawning
 lib/jsonl-watcher.js   Watches ~/.claude/projects for JSONL file changes
+lib/oauth-common.js    Shared OAuth helpers (buildBaseUrl, isRemoteRequest, encodeOAuthState, result/relay pages)
+lib/oauth-gemini.js    Gemini OAuth flow (credential discovery, token exchange, callback handling)
+lib/oauth-codex.js     Codex CLI OAuth flow (PKCE S256, token exchange, callback handling)
 lib/plugin-interface.js  Plugin interface contract definition
 lib/plugin-loader.js   Plugin discovery and loading (EventEmitter-based)
 lib/pm2-manager.js     PM2 process management wrapper
+lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
+lib/speech-manager.js  TTS orchestration (eager TTS, voice cache, model download, broadcastModelProgress)
 lib/tool-install-machine.js  XState v5 machine per tool: unchecked/checking/idle/installing/installed/updating/needs_update/failed states
 lib/tool-manager.js    Tool facade - re-exports from tool-version, tool-spawner, tool-provisioner
 lib/tool-version.js    Version detection for CLI tools and plugins (data-driven framework paths)
 lib/tool-spawner.js    npm/bun install/update spawn with timeout and heartbeat
 lib/tool-provisioner.js  Auto-provisioning and periodic update checking
-lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
 lib/ws-protocol.js     WebSocket RPC router (WsRouter class)
 lib/ws-optimizer.js    Per-client priority queue for WS event batching
 lib/ws-handlers-conv.js  Conversation CRUD, chunks, cancel, steer, inject RPC handlers
@@ -130,6 +135,9 @@ XState v5 machines are authoritative for their respective state domains. Ad-hoc
 - `STARTUP_CWD` - Working directory passed to agents
 - `HOT_RELOAD` - Set to "false" to disable watch mode
 - `CODEX_HOME` - Override Codex CLI home directory (default: `~/.codex`)
+- `RATE_LIMIT_MAX` - Max HTTP requests per IP per minute (default: 300)
+- `PASSWORD` - Basic auth password for all HTTP routes (optional)
+- `AGENTGUI_BASE_URL` - Override base URL for OAuth callbacks (e.g., `https://myserver.com`)
 
 ## ACP Tool Lifecycle
 
@@ -159,6 +167,7 @@ All routes are prefixed with `BASE_URL` (default `/gm`).
 - `GET /api/sessions/:id/execution` - Get execution events (query: limit, offset, filterType)
 - `GET /api/agents` - List discovered agents
 - `GET /api/acp/status` - ACP tool lifecycle status (ports, health, PIDs, restart counts)
+- `GET /api/health` - Server health check (version, uptime, agents, wsClients, memory, acp status)
 - `GET /api/home` - Get home directory
 - `POST /api/stt` - Speech-to-text (raw audio body)
 - `POST /api/tts` - Text-to-speech (body: text)

package/lib/speech-manager.js

@@ -0,0 +1,203 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+
+let speechModule = null;
+let _broadcastSync = null;
+let _syncClients = null;
+let _queries = null;
+
+export function initSpeechManager({ broadcastSync, syncClients, queries }) {
+  _broadcastSync = broadcastSync;
+  _syncClients = syncClients;
+  _queries = queries;
+}
+
+export async function ensurePocketTtsSetup(onProgress) {
+  const r = createRequire(import.meta.url);
+  const serverTTS = r('webtalk/server-tts');
+  return serverTTS.ensureInstalled(onProgress);
+}
+
+export async function getSpeech() {
+  if (!speechModule) speechModule = await import('./speech.js');
+  return speechModule;
+}
+
+const ttsTextAccumulators = new Map();
+
+export const voiceCacheManager = {
+  generating: new Map(),
+  maxCacheSize: 10 * 1024 * 1024,
+  async getOrGenerateCache(conversationId, text) {
+    const cacheKey = `${conversationId}:${text}`;
+    if (this.generating.has(cacheKey)) {
+      return new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          const cached = _queries.getVoiceCache(conversationId, text);
+          if (cached) { clearInterval(checkInterval); resolve(cached); }
+        }, 50);
+      });
+    }
+    const cached = _queries.getVoiceCache(conversationId, text);
+    if (cached) return cached;
+    this.generating.set(cacheKey, true);
+    try {
+      const speech = await getSpeech();
+      const audioBlob = await speech.synthesize(text, 'default');
+      const saved = _queries.saveVoiceCache(conversationId, text, audioBlob);
+      const totalSize = _queries.getVoiceCacheSize(conversationId);
+      if (totalSize > this.maxCacheSize) {
+        const needed = totalSize - this.maxCacheSize;
+        _queries.deleteOldestVoiceCache(conversationId, needed);
+      }
+      return saved;
+    } finally {
+      this.generating.delete(cacheKey);
+    }
+  }
+};
+
+export const modelDownloadState = {
+  downloading: false,
+  progress: null,
+  error: null,
+  complete: false,
+  startTime: null,
+  downloadMetrics: new Map()
+};
+
+export function broadcastModelProgress(progress) {
+  modelDownloadState.progress = progress;
+  const broadcastData = {
+    type: 'model_download_progress',
+    modelId: progress.type || 'unknown',
+    bytesDownloaded: progress.bytesDownloaded || 0,
+    bytesRemaining: progress.bytesRemaining || 0,
+    totalBytes: progress.totalBytes || 0,
+    downloadSpeed: progress.downloadSpeed || 0,
+    eta: progress.eta || 0,
+    retryCount: progress.retryCount || 0,
+    currentGateway: progress.currentGateway || '',
+    status: progress.status || (progress.done ? 'completed' : progress.downloading ? 'downloading' : 'paused'),
+    percentComplete: progress.percentComplete || 0,
+    completedFiles: progress.completedFiles || 0,
+    totalFiles: progress.totalFiles || 0,
+    timestamp: Date.now(),
+    ...progress
+  };
+  _broadcastSync(broadcastData);
+}
+
+async function validateAndCleanupModels(modelsDir) {
+  try {
+    const manifestPath = path.join(modelsDir, '.manifests.json');
+    if (fs.existsSync(manifestPath)) {
+      try {
+        const content = fs.readFileSync(manifestPath, 'utf8');
+        JSON.parse(content);
+      } catch (e) {
+        console.error('[MODELS] Manifest corrupted, removing:', e.message);
+        fs.unlinkSync(manifestPath);
+      }
+    }
+    const files = fs.readdirSync(modelsDir);
+    for (const file of files) {
+      if (file.endsWith('.tmp')) {
+        try { fs.unlinkSync(path.join(modelsDir, file)); console.log('[MODELS] Cleaned up temp file:', file); }
+        catch (e) { console.warn('[MODELS] Failed to clean:', file); }
+      }
+    }
+  } catch (e) {
+    console.warn('[MODELS] Cleanup check failed:', e.message);
+  }
+}
+
+export async function ensureModelsDownloaded() {
+  if (modelDownloadState.downloading) {
+    while (modelDownloadState.downloading) { await new Promise(r => setTimeout(r, 100)); }
+    return modelDownloadState.complete;
+  }
+  modelDownloadState.downloading = true;
+  modelDownloadState.error = null;
+  try {
+    const r = createRequire(import.meta.url);
+    const { createConfig } = r('webtalk/config');
+    const { ensureModel } = r('webtalk/whisper-models');
+    const { ensureTTSModels } = r('webtalk/tts-models');
+    const gmguiModels = path.join(os.homedir(), '.gmgui', 'models');
+    const modelsBase = process.env.PORTABLE_EXE_DIR
+      ? (fs.existsSync(path.join(process.env.PORTABLE_EXE_DIR, 'models', 'onnx-community')) ? path.join(process.env.PORTABLE_EXE_DIR, 'models') : gmguiModels)
+      : gmguiModels;
+    await validateAndCleanupModels(modelsBase);
+    const config = createConfig({ modelsDir: modelsBase, ttsModelsDir: path.join(modelsBase, 'tts') });
+    const onProgress = (progress) => { broadcastModelProgress({ ...progress, started: true, done: false, downloading: true }); };
+    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'whisper', status: 'starting' });
+    await ensureModel('onnx-community/whisper-base', config, onProgress);
+    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', status: 'starting' });
+    await ensureTTSModels(config, onProgress);
+    modelDownloadState.complete = true;
+    broadcastModelProgress({ started: true, done: true, complete: true, downloading: false });
+    return true;
+  } catch (err) {
+    console.error('[MODELS] Download error:', err.message);
+    modelDownloadState.error = err.message;
+    broadcastModelProgress({ done: true, error: err.message });
+    return false;
+  } finally {
+    modelDownloadState.downloading = false;
+  }
+}
+
+export function eagerTTS(text, conversationId, sessionId) {
+  const key = `${conversationId}:${sessionId}`;
+  let acc = ttsTextAccumulators.get(key);
+  if (!acc) { acc = { text: '', timer: null }; ttsTextAccumulators.set(key, acc); }
+  acc.text += text;
+  if (acc.timer) clearTimeout(acc.timer);
+  acc.timer = setTimeout(() => flushTTSaccumulator(key, conversationId, sessionId), 600);
+}
+
+function flushTTSaccumulator(key, conversationId, sessionId) {
+  const acc = ttsTextAccumulators.get(key);
+  if (!acc || !acc.text) return;
+  const text = acc.text.trim();
+  acc.text = '';
+  ttsTextAccumulators.delete(key);
+  getSpeech().then(speech => {
+    const status = speech.getStatus();
+    if (!status.ttsReady || status.ttsError) return;
+    const voices = new Set();
+    for (const ws of _syncClients) {
+      const vid = ws.ttsVoiceId || 'default';
+      const convKey = `conv-${conversationId}`;
+      if (ws.subscriptions && (ws.subscriptions.has(sessionId) || ws.subscriptions.has(convKey))) {
+        voices.add(vid);
+      }
+    }
+    if (voices.size === 0) return;
+    for (const vid of voices) {
+      const cacheKey = speech.ttsCacheKey(text, vid);
+      const cached = speech.ttsCacheGet(cacheKey);
+      if (cached) { pushTTSAudio(cacheKey, cached, conversationId, sessionId, vid); continue; }
+      speech.synthesize(text, vid).then(wav => {
+        if (speech.ttsCacheSet) speech.ttsCacheSet(cacheKey, wav);
+        pushTTSAudio(cacheKey, wav, conversationId, sessionId, vid);
+      }).catch(() => {});
+    }
+  }).catch(() => {});
+}
+
+function pushTTSAudio(cacheKey, wav, conversationId, sessionId, voiceId) {
+  const b64 = wav.toString('base64');
+  _broadcastSync({
+    type: 'tts_audio',
+    cacheKey,
+    audio: b64,
+    voiceId,
+    conversationId,
+    sessionId,
+    timestamp: Date.now()
+  });
+}

package/package.json

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

package/server.js

@@ -18,6 +18,7 @@ import { runClaudeWithStreaming } from './lib/claude-runner.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
 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 { 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';
@@ -69,232 +70,6 @@ process.on('SIGHUP', () => { console.log('[SIGNAL] SIGHUP received (ignored - un
 process.on('beforeExit', (code) => { console.log('[PROCESS] beforeExit with code:', code); });
 process.on('exit', (code) => { console.log('[PROCESS] exit with code:', code); });
 
-const ttsTextAccumulators = new Map();
-const voiceCacheManager = {
-  generating: new Map(),
-  maxCacheSize: 10 * 1024 * 1024,
-  async getOrGenerateCache(conversationId, text) {
-    const cacheKey = `${conversationId}:${text}`;
-    if (this.generating.has(cacheKey)) {
-      return new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          const cached = queries.getVoiceCache(conversationId, text);
-          if (cached) {
-            clearInterval(checkInterval);
-            resolve(cached);
-          }
-        }, 50);
-      });
-    }
-    const cached = queries.getVoiceCache(conversationId, text);
-    if (cached) return cached;
-    this.generating.set(cacheKey, true);
-    try {
-      const speech = await getSpeech();
-      const audioBlob = await speech.synthesize(text, 'default');
-      const saved = queries.saveVoiceCache(conversationId, text, audioBlob);
-      const totalSize = queries.getVoiceCacheSize(conversationId);
-      if (totalSize > this.maxCacheSize) {
-        const needed = totalSize - this.maxCacheSize;
-        queries.deleteOldestVoiceCache(conversationId, needed);
-      }
-      return saved;
-    } finally {
-      this.generating.delete(cacheKey);
-    }
-  }
-};
-
-let speechModule = null;
-async function getSpeech() {
-  if (!speechModule) speechModule = await import('./lib/speech.js');
-  return speechModule;
-}
-
-async function ensurePocketTtsSetup(onProgress) {
-  const { createRequire: cr } = await import('module');
-  const r = cr(import.meta.url);
-  const serverTTS = r('webtalk/server-tts');
-  return serverTTS.ensureInstalled(onProgress);
-}
-
-// Model download manager
-const modelDownloadState = {
-  downloading: false,
-  progress: null,
-  error: null,
-  complete: false,
-  startTime: null,
-  downloadMetrics: new Map()
-};
-
-function broadcastModelProgress(progress) {
-  modelDownloadState.progress = progress;
-  const broadcastData = {
-    type: 'model_download_progress',
-    modelId: progress.type || 'unknown',
-    bytesDownloaded: progress.bytesDownloaded || 0,
-    bytesRemaining: progress.bytesRemaining || 0,
-    totalBytes: progress.totalBytes || 0,
-    downloadSpeed: progress.downloadSpeed || 0,
-    eta: progress.eta || 0,
-    retryCount: progress.retryCount || 0,
-    currentGateway: progress.currentGateway || '',
-    status: progress.status || (progress.done ? 'completed' : progress.downloading ? 'downloading' : 'paused'),
-    percentComplete: progress.percentComplete || 0,
-    completedFiles: progress.completedFiles || 0,
-    totalFiles: progress.totalFiles || 0,
-    timestamp: Date.now(),
-    ...progress
-  };
-  broadcastSync(broadcastData);
-}
-
-async function validateAndCleanupModels(modelsDir) {
-  try {
-    const manifestPath = path.join(modelsDir, '.manifests.json');
-    if (fs.existsSync(manifestPath)) {
-      try {
-        const content = fs.readFileSync(manifestPath, 'utf8');
-        JSON.parse(content);
-      } catch (e) {
-        console.error('[MODELS] Manifest corrupted, removing:', e.message);
-        fs.unlinkSync(manifestPath);
-      }
-    }
-
-    const files = fs.readdirSync(modelsDir);
-    for (const file of files) {
-      if (file.endsWith('.tmp')) {
-        try {
-          fs.unlinkSync(path.join(modelsDir, file));
-          console.log('[MODELS] Cleaned up temp file:', file);
-        } catch (e) {
-          console.warn('[MODELS] Failed to clean:', file);
-        }
-      }
-    }
-  } catch (e) {
-    console.warn('[MODELS] Cleanup check failed:', e.message);
-  }
-}
-
-async function ensureModelsDownloaded() {
-  if (modelDownloadState.downloading) {
-    while (modelDownloadState.downloading) {
-      await new Promise(r => setTimeout(r, 100));
-    }
-    return modelDownloadState.complete;
-  }
-
-  modelDownloadState.downloading = true;
-  modelDownloadState.error = null;
-
-  try {
-    const r = createRequire(import.meta.url);
-    const { createConfig } = r('webtalk/config');
-    const { ensureModel } = r('webtalk/whisper-models');
-    const { ensureTTSModels } = r('webtalk/tts-models');
-    const gmguiModels = path.join(os.homedir(), '.gmgui', 'models');
-    const modelsBase = process.env.PORTABLE_EXE_DIR
-      ? (fs.existsSync(path.join(process.env.PORTABLE_EXE_DIR, 'models', 'onnx-community')) ? path.join(process.env.PORTABLE_EXE_DIR, 'models') : gmguiModels)
-      : gmguiModels;
-
-    await validateAndCleanupModels(modelsBase);
-
-    const config = createConfig({
-      modelsDir: modelsBase,
-      ttsModelsDir: path.join(modelsBase, 'tts'),
-    });
-
-    // Progress callback for broadcasting download progress
-    const onProgress = (progress) => {
-      broadcastModelProgress({
-        ...progress,
-        started: true,
-        done: false,
-        downloading: true
-      });
-    };
-
-    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'whisper', status: 'starting' });
-    await ensureModel('onnx-community/whisper-base', config, onProgress);
-
-    broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', status: 'starting' });
-    await ensureTTSModels(config, onProgress);
-
-    modelDownloadState.complete = true;
-    broadcastModelProgress({ started: true, done: true, complete: true, downloading: false });
-    return true;
-  } catch (err) {
-    console.error('[MODELS] Download error:', err.message);
-    modelDownloadState.error = err.message;
-    broadcastModelProgress({ done: true, error: err.message });
-    return false;
-  } finally {
-    modelDownloadState.downloading = false;
-  }
-}
-
-function eagerTTS(text, conversationId, sessionId) {
-  const key = `${conversationId}:${sessionId}`;
-  let acc = ttsTextAccumulators.get(key);
-  if (!acc) {
-    acc = { text: '', timer: null };
-    ttsTextAccumulators.set(key, acc);
-  }
-  acc.text += text;
-  if (acc.timer) clearTimeout(acc.timer);
-  acc.timer = setTimeout(() => flushTTSaccumulator(key, conversationId, sessionId), 600);
-}
-
-function flushTTSaccumulator(key, conversationId, sessionId) {
-  const acc = ttsTextAccumulators.get(key);
-  if (!acc || !acc.text) return;
-  const text = acc.text.trim();
-  acc.text = '';
-  ttsTextAccumulators.delete(key);
-  
-  getSpeech().then(speech => {
-    const status = speech.getStatus();
-    if (!status.ttsReady || status.ttsError) return;
-    const voices = new Set();
-    for (const ws of syncClients) {
-      const vid = ws.ttsVoiceId || 'default';
-      const convKey = `conv-${conversationId}`;
-      if (ws.subscriptions && (ws.subscriptions.has(sessionId) || ws.subscriptions.has(convKey))) {
-        voices.add(vid);
-      }
-    }
-    if (voices.size === 0) return;
-    for (const vid of voices) {
-      const cacheKey = speech.ttsCacheKey(text, vid);
-      const cached = speech.ttsCacheGet(cacheKey);
-      if (cached) {
-        pushTTSAudio(cacheKey, cached, conversationId, sessionId, vid);
-        continue;
-      }
-      speech.synthesize(text, vid).then(wav => {
-        if (speech.ttsCacheSet) speech.ttsCacheSet(cacheKey, wav);
-        pushTTSAudio(cacheKey, wav, conversationId, sessionId, vid);
-      }).catch(() => {});
-    }
-  }).catch(() => {});
-}
-
-function pushTTSAudio(cacheKey, wav, conversationId, sessionId, voiceId) {
-  const b64 = wav.toString('base64');
-  broadcastSync({
-    type: 'tts_audio',
-    cacheKey,
-    audio: b64,
-    voiceId,
-    conversationId,
-    sessionId,
-    timestamp: Date.now()
-  });
-}
-
 
 function buildSystemPrompt(agentId, model, subAgent) {
   const parts = [];
@@ -3943,6 +3718,8 @@ function broadcastSync(event) {
 // WebSocket protocol router
 const wsRouter = new WsRouter();
 
+initSpeechManager({ broadcastSync, syncClients, queries });
+
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,
   broadcastSync, processMessageWithStreaming, cleanupExecution,