agentgui 1.0.776 → 1.0.778

package/lib/speech-manager.js

@@ -65,7 +65,8 @@ export const modelDownloadState = {
   error: null,
   complete: false,
   startTime: null,
-  downloadMetrics: new Map()
+  downloadMetrics: new Map(),
+  waiters: []
 };
 
 export function broadcastModelProgress(progress) {
@@ -116,8 +117,7 @@ async function validateAndCleanupModels(modelsDir) {
 
 export async function ensureModelsDownloaded() {
   if (modelDownloadState.downloading) {
-    while (modelDownloadState.downloading) { await new Promise(r => setTimeout(r, 100)); }
-    return modelDownloadState.complete;
+    return new Promise(resolve => { modelDownloadState.waiters.push(resolve); });
   }
   modelDownloadState.downloading = true;
   modelDownloadState.error = null;
@@ -147,6 +147,9 @@ export async function ensureModelsDownloaded() {
     return false;
   } finally {
     modelDownloadState.downloading = false;
+    const result = modelDownloadState.complete;
+    for (const resolve of modelDownloadState.waiters) resolve(result);
+    modelDownloadState.waiters = [];
   }
 }
 

package/lib/tool-spawner.js

@@ -100,9 +100,11 @@ export function createInstaller(getTool, statusCache, checkToolStatusAsync) {
         toolInstallMachine.send(toolId, { type: 'INSTALL_COMPLETE', version: fresh.version });
         return fresh;
       }
+      clearVersionCache();
       toolInstallMachine.send(toolId, { type: 'FAILED', error: result.error });
       return result;
     } catch (err) {
+      clearVersionCache();
       toolInstallMachine.send(toolId, { type: 'FAILED', error: err.message });
       return { success: false, error: err.message };
     }
@@ -122,9 +124,11 @@ export function createInstaller(getTool, statusCache, checkToolStatusAsync) {
         toolInstallMachine.send(toolId, { type: 'UPDATE_COMPLETE', version: fresh.version });
         return fresh;
       }
+      clearVersionCache();
       toolInstallMachine.send(toolId, { type: 'FAILED', error: result.error });
       return result;
     } catch (err) {
+      clearVersionCache();
       toolInstallMachine.send(toolId, { type: 'FAILED', error: err.message });
       return { success: false, error: err.message };
     }

package/lib/ws-handlers-session.js

@@ -99,7 +99,24 @@ export function register(router, deps) {
   router.handle('sess.exec', (p) => {
     const limit = Math.min(parseInt(p.limit || '1000'), 5000);
     const offset = Math.max(parseInt(p.offset || '0'), 0);
-    return { sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false, metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 } };
+    const session = db.getSession(p.id);
+    const allChunks = session ? (db.getChunksSince(p.id, 0) || []) : [];
+    const filterType = p.filterType;
+    const filtered = filterType ? allChunks.filter(e => e.type === filterType) : allChunks;
+    return {
+      sessionId: p.id,
+      events: filtered.slice(offset, offset + limit),
+      total: filtered.length,
+      limit,
+      offset,
+      hasMore: offset + limit < filtered.length,
+      metadata: {
+        status: session?.status || 'unknown',
+        startTime: session?.created_at || null,
+        duration: session?.completed_at && session?.created_at ? session.completed_at - session.created_at : 0,
+        eventCount: filtered.length
+      }
+    };
   });
 
   router.handle('agent.ls', () => {

package/package.json

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

package/server.js

@@ -143,10 +143,13 @@ function cleanupExecution(conversationId, broadcastCompletion = false) {
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = process.env.PORTABLE_EXE_DIR || __dirname;
 const PORT = process.env.PORT || 3000;
-const BASE_URL = (process.env.BASE_URL || '/gm').replace(/\/+$/, '');
+const BASE_URL = (process.env.BASE_URL || '/gm').replace(/\/+/g, '/').replace(/\/+$/, '');
 const watch = process.argv.includes('--no-watch') ? false : (process.argv.includes('--watch') || process.env.HOT_RELOAD !== 'false');
 
-const STARTUP_CWD = process.env.STARTUP_CWD || process.cwd();
+const STARTUP_CWD = (() => {
+  const cwd = process.env.STARTUP_CWD || process.cwd();
+  try { fs.accessSync(cwd, fs.constants.R_OK); return cwd; } catch { console.warn(`[server] STARTUP_CWD "${cwd}" not accessible, falling back to ${process.cwd()}`); return process.cwd(); }
+})();
 const staticDir = path.join(rootDir, 'static');
 if (!fs.existsSync(staticDir)) fs.mkdirSync(staticDir, { recursive: true });
 
@@ -654,7 +657,7 @@ const server = http.createServer(async (req, res) => {
       sendJSON(req, res, 200, { message: userMessage, session, streamId: session.id });
 
       processMessageWithStreaming(conversationId, userMessage.id, session.id, prompt, agentId, model, subAgent)
-        .catch(err => debugLog(`[stream] Uncaught error: ${err.message}`));
+        .catch(err => debugLog(`[stream] Uncaught error: ${err.stack || err.message}`));
       return;
     }
 
@@ -812,29 +815,25 @@ const server = http.createServer(async (req, res) => {
       const filterType = url.searchParams.get('filterType');
 
       try {
-        // Retrieve execution history from database
-        // This would normally query execution_events table
-        // For now, return proper response structure
+        const session = queries.getSession(sessionId);
+        const allChunks = session ? (queries.getChunksSince(sessionId, 0) || []) : [];
+        const filtered = filterType ? allChunks.filter(e => e.type === filterType) : allChunks;
         const executionData = {
           sessionId,
-          events: [],
-          total: 0,
+          events: filtered.slice(offset, offset + limit),
+          total: filtered.length,
           limit,
           offset,
-          hasMore: false,
+          hasMore: offset + limit < filtered.length,
           metadata: {
-            status: 'pending',
-            startTime: Date.now(),
-            duration: 0,
-            eventCount: 0
-              }
+            status: session?.status || 'unknown',
+            startTime: session?.created_at || null,
+            duration: session?.completed_at && session?.created_at ? session.completed_at - session.created_at : 0,
+            eventCount: filtered.length
+          }
         };
 
-        if (filterType) {
-          executionData.events = executionData.events.filter(e => e.type === filterType);
-        }
-
-                sendJSON(req, res, 200, executionData);
+        sendJSON(req, res, 200, executionData);
       } catch (err) {
                 sendJSON(req, res, 400, { error: err.message });
       }

package/static/js/client.js

@@ -94,7 +94,7 @@ class AgentGUIClient {
     this._debug = typeof localStorage !== 'undefined' && localStorage.getItem('debug') === '1';
   }
 
-  _dbg(...args) { if (this._debug) this._dbg(...args); }
+  _dbg(...args) { if (this._debug) console.log('[AgentGUI]', ...args); }
 
   /**
    * Initialize the client

package/static/js/voice.js

@@ -57,8 +57,9 @@
 
   function _doSpeak(text) {
     audioChunkQueue = [];
-    var cached = ttsAudioCache.get(selectedVoiceId + ':' + text);
-    if (cached) { audioChunkQueue.push(cached); playNextChunk(); return; }
+    var cacheKey = selectedVoiceId + ':' + text;
+    var cached = ttsAudioCache.get(cacheKey);
+    if (cached) { ttsAudioCache.delete(cacheKey); ttsAudioCache.set(cacheKey, cached); audioChunkQueue.push(cached); playNextChunk(); return; }
     function stream() {
       if (!streamingSupported) { nonStream(text); return; }
       fetch(BASE + '/api/tts-stream', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: text, voiceId: selectedVoiceId }) })
@@ -71,6 +72,7 @@
             buf = cat(buf, res.value);
             while (buf.length >= 4) {
               var len = new DataView(buf.buffer, buf.byteOffset, 4).getUint32(0, false);
+              if (len > 10 * 1024 * 1024) { buf = new Uint8Array(0); if (api()) api().send({ type: 'PLAYBACK_ERROR' }); return; }
               if (buf.length < 4 + len) break;
               audioChunkQueue.push(new Blob([buf.slice(4, 4 + len)], { type: 'audio/wav' }));
               buf = buf.slice(4 + len);