agentgui 1.0.180 → 1.0.182

package/database.js

@@ -354,6 +354,13 @@ export const queries = {
     return stmt.all();
   },
 
+  getResumableConversations() {
+    const stmt = prep(
+      "SELECT id, title, claudeSessionId, agentType, workingDirectory FROM conversations WHERE isStreaming = 1 AND claudeSessionId IS NOT NULL AND claudeSessionId != ''"
+    );
+    return stmt.all();
+  },
+
   clearAllStreamingFlags() {
     const stmt = prep('UPDATE conversations SET isStreaming = 0 WHERE isStreaming = 1');
     return stmt.run().changes;

package/lib/pocket-sidecar.js

@@ -6,7 +6,6 @@ import { fileURLToPath } from 'url';
 import http from 'http';
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const POCKET_BIN = path.join(ROOT, 'data', 'pocket-venv', 'bin', 'pocket-tts');
 const PORT = 8787;
 
 const FALLBACK_VOICE = 'alba';
@@ -15,11 +14,21 @@ const state = {
   restartCount: 0, failureCount: 0, lastError: null,
   healthy: false, voicePath: null, starting: false,
   shutdownRequested: false, healthTimer: null, restartTimer: null,
-  voiceCloning: false,
+  voiceCloning: false, adopted: false,
 };
 globalThis.__pocketSidecar = state;
 
-function isInstalled() { return fs.existsSync(POCKET_BIN); }
+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;
@@ -54,21 +63,24 @@ function killProcess() {
 
 function scheduleRestart() {
   if (state.shutdownRequested) return;
-  killProcess();
+  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:', POCKET_BIN, args.join(' '));
-  return spawn(POCKET_BIN, args, {
+  console.log('[POCKET-TTS] Starting:', bin, args.join(' '));
+  return spawn(bin, args, {
     stdio: ['ignore', 'pipe', 'pipe'],
     env: { ...process.env, PYTHONUNBUFFERED: '1' },
   });
@@ -92,10 +104,29 @@ async function waitForReady(proc, timeoutSec) {
   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 (!isInstalled()) { state.lastError = 'not installed'; state.status = 'unavailable'; return false; }
   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 {

package/lib/speech.js

@@ -105,6 +105,8 @@ let transformersModule = null;
 let sttPipeline = null;
 let sttLoading = false;
 let sttLoadError = null;
+let sttLoadErrorTime = 0;
+const STT_RETRY_MS = 30000;
 const SAMPLE_RATE_STT = 16000;
 
 const TTS_CACHE_MAX_BYTES = 10 * 1024 * 1024;
@@ -159,10 +161,10 @@ async function decodeAudioFile(filePath) {
 
 async function getSTT() {
   if (sttPipeline) return sttPipeline;
-  if (sttLoadError) throw sttLoadError;
+  if (sttLoadError && (Date.now() - sttLoadErrorTime < STT_RETRY_MS)) throw sttLoadError;
   if (sttLoading) {
     while (sttLoading) await new Promise(r => setTimeout(r, 100));
-    if (sttLoadError) throw sttLoadError;
+    if (sttLoadError && (Date.now() - sttLoadErrorTime < STT_RETRY_MS)) throw sttLoadError;
     if (!sttPipeline) throw new Error('STT pipeline failed to load');
     return sttPipeline;
   }
@@ -183,6 +185,7 @@ async function getSTT() {
   } catch (err) {
     sttPipeline = null;
     sttLoadError = new Error('STT model load failed: ' + err.message);
+    sttLoadErrorTime = Date.now();
     throw sttLoadError;
   } finally {
     sttLoading = false;

package/package.json

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

package/server.js

@@ -1311,34 +1311,121 @@ function recoverStaleSessions() {
   try {
     const now = Date.now();
 
+    const resumable = new Set();
+    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations() : [];
+    for (const conv of resumableConvs) {
+      if (conv.agentType === 'claude-code') {
+        resumable.add(conv.id);
+      }
+    }
+
     const staleSessions = queries.getActiveSessions ? queries.getActiveSessions() : [];
+    let markedCount = 0;
     for (const session of staleSessions) {
       if (activeExecutions.has(session.conversationId)) continue;
+      if (resumable.has(session.conversationId)) continue;
       queries.updateSession(session.id, {
         status: 'error',
         error: 'Server restarted',
         completed_at: now
       });
+      markedCount++;
     }
-    if (staleSessions.length > 0) {
-      console.log(`[RECOVERY] Marked ${staleSessions.length} stale session(s) as error`);
+    if (markedCount > 0) {
+      console.log(`[RECOVERY] Marked ${markedCount} stale session(s) as error`);
     }
 
     const streamingConvs = queries.getStreamingConversations ? queries.getStreamingConversations() : [];
     let clearedCount = 0;
     for (const conv of streamingConvs) {
       if (activeExecutions.has(conv.id)) continue;
+      if (resumable.has(conv.id)) continue;
       queries.setIsStreaming(conv.id, false);
       clearedCount++;
     }
     if (clearedCount > 0) {
       console.log(`[RECOVERY] Cleared isStreaming flag on ${clearedCount} stale conversation(s)`);
     }
+    if (resumable.size > 0) {
+      console.log(`[RECOVERY] Found ${resumable.size} resumable conversation(s)`);
+    }
   } catch (err) {
     console.error('[RECOVERY] Stale session recovery error:', err.message);
   }
 }
 
+async function resumeInterruptedStreams() {
+  try {
+    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations() : [];
+    const toResume = resumableConvs.filter(c => c.agentType === 'claude-code');
+
+    if (toResume.length === 0) return;
+
+    console.log(`[RESUME] Resuming ${toResume.length} interrupted conversation(s)`);
+
+    for (let i = 0; i < toResume.length; i++) {
+      const conv = toResume[i];
+      try {
+        const staleSessions = [...queries.getSessionsByStatus(conv.id, 'active'), ...queries.getSessionsByStatus(conv.id, 'pending')];
+        for (const s of staleSessions) {
+          queries.updateSession(s.id, { status: 'interrupted', error: 'Server restarted, resuming', completed_at: Date.now() });
+        }
+
+        const lastMsg = queries.getLastUserMessage(conv.id);
+        const prompt = lastMsg?.content || 'continue';
+        const promptText = typeof prompt === 'string' ? prompt : JSON.stringify(prompt);
+
+        const session = queries.createSession(conv.id);
+        queries.createEvent('session.created', {
+          sessionId: session.id,
+          resumeReason: 'server_restart',
+          claudeSessionId: conv.claudeSessionId
+        }, conv.id, session.id);
+
+        activeExecutions.set(conv.id, {
+          pid: null,
+          startTime: Date.now(),
+          sessionId: session.id,
+          lastActivity: Date.now()
+        });
+
+        broadcastSync({
+          type: 'streaming_start',
+          sessionId: session.id,
+          conversationId: conv.id,
+          agentId: conv.agentType,
+          resumed: true,
+          timestamp: Date.now()
+        });
+
+        const messageId = lastMsg?.id || null;
+        console.log(`[RESUME] Resuming conv ${conv.id} (claude session: ${conv.claudeSessionId})`);
+
+        processMessageWithStreaming(conv.id, messageId, session.id, promptText, conv.agentType)
+          .catch(err => debugLog(`[RESUME] Error resuming conv ${conv.id}: ${err.message}`));
+
+        if (i < toResume.length - 1) {
+          await new Promise(r => setTimeout(r, 200));
+        }
+      } catch (err) {
+        console.error(`[RESUME] Failed to resume conv ${conv.id}: ${err.message}`);
+        queries.setIsStreaming(conv.id, false);
+        const activeSessions = queries.getSessionsByStatus(conv.id, 'active');
+        const pendingSessions = queries.getSessionsByStatus(conv.id, 'pending');
+        for (const s of [...activeSessions, ...pendingSessions]) {
+          queries.updateSession(s.id, {
+            status: 'error',
+            error: 'Resume failed: ' + err.message,
+            completed_at: Date.now()
+          });
+        }
+      }
+    }
+  } catch (err) {
+    console.error('[RESUME] Error during stream resumption:', err.message);
+  }
+}
+
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -1414,6 +1501,9 @@ function onServerReady() {
   // Recover stale active sessions from previous run
   recoverStaleSessions();
 
+  // Resume interrupted streams after recovery
+  resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
+
   getSpeech().then(s => s.preloadTTS()).catch(e => debugLog('[TTS] Preload failed: ' + e.message));
 
   performAutoImport();