agentgui 1.0.512 → 1.0.514

package/lib/tool-manager.js

@@ -6,10 +6,10 @@ import path from 'path';
 
 const isWindows = os.platform() === 'win32';
 const TOOLS = [
-  { id: 'gm-oc', name: 'OpenCode', pkg: 'opencode-ai' },
-  { id: 'gm-gc', name: 'Gemini CLI', pkg: '@google/gemini-cli' },
-  { id: 'gm-kilo', name: 'Kilo', pkg: '@kilocode/cli' },
-  { id: 'gm-cc', name: 'Claude Code', pkg: '@anthropic-ai/claude-code' },
+  { id: 'gm-oc', name: 'OpenCode', pkg: 'opencode-ai', pluginId: 'opencode-ai' },
+  { id: 'gm-gc', name: 'Gemini CLI', pkg: '@google/gemini-cli', pluginId: 'gm' },
+  { id: 'gm-kilo', name: 'Kilo', pkg: '@kilocode/cli', pluginId: '@kilocode/cli' },
+  { id: 'gm-cc', name: 'Claude Code', pkg: '@anthropic-ai/claude-code', pluginId: 'gm' },
 ];
 
 const statusCache = new Map();
@@ -23,12 +23,14 @@ const getNodeModulesPath = () => {
   return path.join(__dirname, '..', 'node_modules');
 };
 
-const getInstalledVersion = (pkg) => {
+const getInstalledVersion = (pkg, pluginId = null) => {
   try {
     const homeDir = os.homedir();
+    const tool = pluginId ? TOOLS.find(t => t.pkg === pkg) : null;
+    const actualPluginId = pluginId || (tool?.pluginId) || pkg;
 
-    // Check Claude Code plugins
-    const claudePath = path.join(homeDir, '.claude', 'plugins', pkg, 'plugin.json');
+    // Check Claude Code plugins using correct pluginId
+    const claudePath = path.join(homeDir, '.claude', 'plugins', actualPluginId, 'plugin.json');
     if (fs.existsSync(claudePath)) {
       try {
         const pluginJson = JSON.parse(fs.readFileSync(claudePath, 'utf-8'));
@@ -38,8 +40,8 @@ const getInstalledVersion = (pkg) => {
       }
     }
 
-    // Check OpenCode agents
-    const opencodePath = path.join(homeDir, '.config', 'opencode', 'agents', pkg, 'plugin.json');
+    // Check OpenCode agents using correct pluginId
+    const opencodePath = path.join(homeDir, '.config', 'opencode', 'agents', actualPluginId, 'plugin.json');
     if (fs.existsSync(opencodePath)) {
       try {
         const pluginJson = JSON.parse(fs.readFileSync(opencodePath, 'utf-8'));
@@ -50,7 +52,7 @@ const getInstalledVersion = (pkg) => {
     }
 
     // Check Gemini CLI agents (stored as 'gm' directory)
-    const geminiPath = path.join(homeDir, '.gemini', 'extensions', 'gm', 'plugin.json');
+    const geminiPath = path.join(homeDir, '.gemini', 'extensions', actualPluginId, 'plugin.json');
     if (fs.existsSync(geminiPath)) {
       try {
         const pluginJson = JSON.parse(fs.readFileSync(geminiPath, 'utf-8'));
@@ -60,7 +62,7 @@ const getInstalledVersion = (pkg) => {
       }
     }
     // Try gemini-extension.json as fallback
-    const geminiExtPath = path.join(homeDir, '.gemini', 'extensions', 'gm', 'gemini-extension.json');
+    const geminiExtPath = path.join(homeDir, '.gemini', 'extensions', actualPluginId, 'gemini-extension.json');
     if (fs.existsSync(geminiExtPath)) {
       try {
         const extJson = JSON.parse(fs.readFileSync(geminiExtPath, 'utf-8'));
@@ -70,8 +72,8 @@ const getInstalledVersion = (pkg) => {
       }
     }
 
-    // Check Kilo agents
-    const kiloPath = path.join(homeDir, '.config', 'kilo', 'agents', pkg, 'plugin.json');
+    // Check Kilo agents using correct pluginId
+    const kiloPath = path.join(homeDir, '.config', 'kilo', 'agents', actualPluginId, 'plugin.json');
     if (fs.existsSync(kiloPath)) {
       try {
         const pluginJson = JSON.parse(fs.readFileSync(kiloPath, 'utf-8'));
@@ -379,7 +381,7 @@ export async function install(toolId, onProgress) {
       statusCache.delete(toolId);
       versionCache.clear();
 
-      const version = getInstalledVersion(tool.pkg);
+      const version = getInstalledVersion(tool.pkg, tool.pluginId);
       if (!version) {
         console.warn(`[tool-manager] Install succeeded but version detection failed for ${toolId}. Attempting CLI check...`);
         const cliVersion = await getCliToolVersion(tool.pkg);
@@ -413,7 +415,7 @@ export async function update(toolId, onProgress) {
       statusCache.delete(toolId);
       versionCache.clear();
 
-      const version = getInstalledVersion(tool.pkg);
+      const version = getInstalledVersion(tool.pkg, tool.pluginId);
       if (!version) {
         console.warn(`[tool-manager] Update succeeded but version detection failed for ${toolId}. Attempting CLI check...`);
         const cliVersion = await getCliToolVersion(tool.pkg);

package/package.json

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

package/server.js

@@ -1863,17 +1863,13 @@ const server = http.createServer(async (req, res) => {
         if (!installCompleted) {
           installCompleted = true;
           queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Install timeout after 6 minutes' });
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: { success: false, error: 'Install timeout after 6 minutes' } });
-          }
+          broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error: 'Install timeout after 6 minutes' } });
           queries.addToolInstallHistory(toolId, 'install', 'failed', 'Install timeout after 6 minutes');
         }
       }, 360000);
 
       toolManager.install(toolId, (msg) => {
-        if (wsOptimizer && wsOptimizer.broadcast) {
-          wsOptimizer.broadcast({ type: 'tool_install_progress', toolId, data: msg });
-        }
+        broadcastSync({ type: 'tool_install_progress', toolId, data: msg });
       }).then(async (result) => {
         clearTimeout(installTimeout);
         if (installCompleted) return;
@@ -1884,16 +1880,12 @@ const server = http.createServer(async (req, res) => {
           queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
           const freshStatus = await toolManager.checkToolStatusAsync(toolId);
           console.log(`[TOOLS-API] Fresh status after install for ${toolId}:`, JSON.stringify(freshStatus));
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_install_complete', toolId, data: { success: true, ...freshStatus } });
-          }
+          broadcastSync({ type: 'tool_install_complete', toolId, data: { success: true, ...freshStatus } });
           queries.addToolInstallHistory(toolId, 'install', 'success', null);
         } else {
           console.error(`[TOOLS-API] Install failed for ${toolId}:`, result.error);
           queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: result });
-          }
+          broadcastSync({ type: 'tool_install_failed', toolId, data: result });
           queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
         }
       }).catch((err) => {
@@ -1903,9 +1895,7 @@ const server = http.createServer(async (req, res) => {
         const error = err?.message || 'Unknown error';
         console.error(`[TOOLS-API] Install error for ${toolId}:`, error);
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-        if (wsOptimizer && wsOptimizer.broadcast) {
-          wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: { success: false, error } });
-        }
+        broadcastSync({ type: 'tool_install_failed', toolId, data: { success: false, error } });
         queries.addToolInstallHistory(toolId, 'install', 'failed', error);
       });
       return;
@@ -1932,17 +1922,13 @@ const server = http.createServer(async (req, res) => {
         if (!updateCompleted) {
           updateCompleted = true;
           queries.updateToolStatus(toolId, { status: 'failed', error_message: 'Update timeout after 6 minutes' });
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: { success: false, error: 'Update timeout after 6 minutes' } });
-          }
+          broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error: 'Update timeout after 6 minutes' } });
           queries.addToolInstallHistory(toolId, 'update', 'failed', 'Update timeout after 6 minutes');
         }
       }, 360000);
 
       toolManager.update(toolId, (msg) => {
-        if (wsOptimizer && wsOptimizer.broadcast) {
-          wsOptimizer.broadcast({ type: 'tool_update_progress', toolId, data: msg });
-        }
+        broadcastSync({ type: 'tool_update_progress', toolId, data: msg });
       }).then(async (result) => {
         clearTimeout(updateTimeout);
         if (updateCompleted) return;
@@ -1953,16 +1939,12 @@ const server = http.createServer(async (req, res) => {
           queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
           const freshStatus = await toolManager.checkToolStatusAsync(toolId);
           console.log(`[TOOLS-API] Fresh status after update for ${toolId}:`, JSON.stringify(freshStatus));
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_update_complete', toolId, data: { success: true, ...freshStatus } });
-          }
+          broadcastSync({ type: 'tool_update_complete', toolId, data: { success: true, ...freshStatus } });
           queries.addToolInstallHistory(toolId, 'update', 'success', null);
         } else {
           console.error(`[TOOLS-API] Update failed for ${toolId}:`, result.error);
           queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
-          if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: result });
-          }
+          broadcastSync({ type: 'tool_update_failed', toolId, data: result });
           queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
         }
       }).catch((err) => {
@@ -1972,9 +1954,7 @@ const server = http.createServer(async (req, res) => {
         const error = err?.message || 'Unknown error';
         console.error(`[TOOLS-API] Update error for ${toolId}:`, error);
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
-        if (wsOptimizer && wsOptimizer.broadcast) {
-          wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: { success: false, error } });
-        }
+        broadcastSync({ type: 'tool_update_failed', toolId, data: { success: false, error } });
         queries.addToolInstallHistory(toolId, 'update', 'failed', error);
       });
       return;

package/static/js/voice.js

@@ -453,6 +453,43 @@
     });
   }
 
+  function preGenerateTTS(text) {
+    if (!ttsEnabled) return;
+    var clean = text.replace(/<[^>]*>/g, '').trim();
+    if (!clean) return;
+    var parts = [];
+    if (typeof agentGUIClient !== 'undefined' && agentGUIClient && typeof agentGUIClient.parseMarkdownCodeBlocks === 'function') {
+      parts = agentGUIClient.parseMarkdownCodeBlocks(clean);
+    } else {
+      parts = [{ type: 'text', content: clean }];
+    }
+    parts.forEach(function(part) {
+      if (part.type === 'code') return;
+      var segment = part.content.trim();
+      if (!segment) return;
+      var cacheKey = selectedVoiceId + ':' + segment;
+      if (ttsAudioCache.has(cacheKey)) return;
+      var optimizedText = optimizePromptForSpeech(segment);
+      fetch(BASE + '/api/tts', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text: optimizedText, voiceId: selectedVoiceId })
+      }).then(function(resp) {
+        if (!resp.ok) throw new Error('TTS pre-generation failed: ' + resp.status);
+        return resp.arrayBuffer();
+      }).then(function(buf) {
+        var blob = new Blob([buf], { type: 'audio/wav' });
+        if (ttsAudioCache.size >= TTS_CLIENT_CACHE_MAX) {
+          var oldest = ttsAudioCache.keys().next().value;
+          ttsAudioCache.delete(oldest);
+        }
+        ttsAudioCache.set(cacheKey, blob);
+      }).catch(function(err) {
+        console.warn('[Voice] TTS pre-generation failed:', err);
+      });
+    });
+  }
+
   function processQueue() {
     if (isSpeaking || speechQueue.length === 0) return;
     if (ttsDisabledUntilReset) {
@@ -783,6 +820,7 @@
       var div = addVoiceBlock(block.text, isUser);
       if (div && isNew && ttsEnabled && blockRole === 'assistant') {
         div.classList.add('speaking');
+        preGenerateTTS(block.text);
         speak(block.text);
         setTimeout(function() { div.classList.remove('speaking'); }, 2000);
       }

package/test-fixes.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for validating the two fixes:
+ * 1. Agent selector visibility in chat view
+ * 2. TTS streaming pre-generation
+ */
+
+import fs from 'fs';
+import { execSync } from 'child_process';
+
+console.log('=== AgentGUI Fix Validation ===\n');
+
+// Test 1: Verify agent selectors are NOT hidden on desktop
+console.log('Test 1: Agent Selector Visibility');
+console.log('-----------------------------------');
+const html = fs.readFileSync('./static/index.html', 'utf-8');
+const beforeMobileMedia = html.substring(0, html.indexOf('@media (max-width: 480px)'));
+const cliHiddenOnDesktop = beforeMobileMedia.includes('.cli-selector { display: none; }');
+const modelHiddenOnDesktop = beforeMobileMedia.includes('.model-selector { display: none; }');
+
+if (!cliHiddenOnDesktop && !modelHiddenOnDesktop) {
+  console.log('✓ PASS: Agent selectors are NOT hidden by CSS on desktop');
+  console.log('  - CLI selector will be visible when populated');
+  console.log('  - Model selector will be visible when populated');
+} else {
+  console.log('❌ FAIL: Agent selectors are still hidden on desktop');
+  if (cliHiddenOnDesktop) console.log('  - .cli-selector has display:none');
+  if (modelHiddenOnDesktop) console.log('  - .model-selector has display:none');
+}
+
+// Verify selectors are in HTML
+const hasSelectors = html.includes('data-cli-selector') &&
+                     html.includes('data-agent-selector') &&
+                     html.includes('data-model-selector');
+if (hasSelectors) {
+  console.log('✓ PASS: All selector elements are present in HTML');
+} else {
+  console.log('❌ FAIL: Some selector elements are missing');
+}
+
+// Test 2: Verify TTS pre-generation is implemented
+console.log('\nTest 2: TTS Streaming Pre-generation');
+console.log('--------------------------------------');
+const voiceJs = fs.readFileSync('./static/js/voice.js', 'utf-8');
+const hasPreGenerateFunction = voiceJs.includes('function preGenerateTTS(text)');
+const callsPreGenerate = voiceJs.includes('preGenerateTTS(block.text)');
+const usesCache = voiceJs.includes('if (ttsAudioCache.has(cacheKey)) return;');
+const fetchesTTS = voiceJs.match(/fetch\(BASE \+ '\/api\/tts'/g)?.length >= 2; // Should be in both preGenerate and processQueue
+
+if (hasPreGenerateFunction && callsPreGenerate && usesCache && fetchesTTS) {
+  console.log('✓ PASS: TTS pre-generation is fully implemented');
+  console.log('  - preGenerateTTS function exists');
+  console.log('  - Called when assistant text arrives');
+  console.log('  - Uses cache to avoid duplicate generation');
+  console.log('  - Audio generation happens in background');
+} else {
+  console.log('❌ FAIL: TTS pre-generation incomplete');
+  if (!hasPreGenerateFunction) console.log('  - Missing preGenerateTTS function');
+  if (!callsPreGenerate) console.log('  - Not called in handleVoiceBlock');
+  if (!usesCache) console.log('  - Missing cache check');
+}
+
+// Test 3: Check that client.js populates selectors correctly
+console.log('\nTest 3: Selector Population Logic');
+console.log('-----------------------------------');
+const clientJs = fs.readFileSync('./static/js/client.js', 'utf-8');
+const setsDisplay = clientJs.includes("this.ui.cliSelector.style.display = 'inline-block'");
+const populatesOptions = clientJs.includes('.innerHTML = displayAgents');
+
+if (setsDisplay && populatesOptions) {
+  console.log('✓ PASS: Client.js correctly populates and displays selectors');
+  console.log('  - Sets display to inline-block when agents loaded');
+  console.log('  - Populates options from agent list');
+} else {
+  console.log('❌ FAIL: Selector population logic may be broken');
+}
+
+// Summary
+console.log('\n=== SUMMARY ===');
+const allTestsPass = !cliHiddenOnDesktop && !modelHiddenOnDesktop &&
+                     hasSelectors && hasPreGenerateFunction &&
+                     callsPreGenerate && usesCache &&
+                     setsDisplay && populatesOptions;
+
+if (allTestsPass) {
+  console.log('✓ ALL TESTS PASSED\n');
+  console.log('Manual Testing Instructions:');
+  console.log('1. Start server: npm run dev');
+  console.log('2. Open http://localhost:3000/gm/');
+  console.log('3. Check chat input area - you should see:');
+  console.log('   - CLI selector dropdown (e.g., "Claude")');
+  console.log('   - Model selector dropdown (e.g., "Sonnet 4.5")');
+  console.log('   - Microphone button for voice input');
+  console.log('4. Open Voice tab and enable "Auto-speak responses"');
+  console.log('5. Send a message and observe:');
+  console.log('   - Text streams in as agent responds');
+  console.log('   - Voice playback starts immediately after completion (no delay)');
+  console.log('   - Audio was pre-generated during streaming');
+} else {
+  console.log('❌ SOME TESTS FAILED - Review output above\n');
+  process.exit(1);
+}