agentgui 1.0.148 → 1.0.150

package/database.js

@@ -335,14 +335,14 @@ export const queries = {
 
   getSessionsProcessingLongerThan(minutes) {
     const cutoff = Date.now() - (minutes * 60 * 1000);
-    const stmt = db.prepare('SELECT * FROM sessions WHERE status = ? AND started_at < ?');
-    return stmt.all('pending', cutoff);
+    const stmt = db.prepare("SELECT * FROM sessions WHERE status IN ('active', 'pending') AND started_at < ?");
+    return stmt.all(cutoff);
   },
 
   cleanupOrphanedSessions(days) {
     const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
-    const stmt = db.prepare('DELETE FROM sessions WHERE status = ? AND started_at < ?');
-    const result = stmt.run('pending', cutoff);
+    const stmt = db.prepare("DELETE FROM sessions WHERE status IN ('active', 'pending') AND started_at < ?");
+    const result = stmt.run(cutoff);
     return result.changes || 0;
   },
 

package/lib/claude-runner.js

@@ -139,7 +139,24 @@ class AgentRunner {
     });
   }
 
-  async runACP(prompt, cwd, config = {}) {
+  async runACP(prompt, cwd, config = {}, _retryCount = 0) {
+    const maxRetries = config.maxRetries ?? 1;
+    try {
+      return await this._runACPOnce(prompt, cwd, config);
+    } catch (err) {
+      const isEmptyExit = err.message && err.message.includes('ACP exited with code');
+      const isBinaryError = err.code === 'ENOENT' || (err.message && err.message.includes('ENOENT'));
+      if ((isEmptyExit || isBinaryError) && _retryCount < maxRetries) {
+        const delay = Math.min(1000 * Math.pow(2, _retryCount), 5000);
+        console.error(`[${this.id}] ACP attempt ${_retryCount + 1} failed: ${err.message}. Retrying in ${delay}ms...`);
+        await new Promise(r => setTimeout(r, delay));
+        return this.runACP(prompt, cwd, config, _retryCount + 1);
+      }
+      throw err;
+    }
+  }
+
+  async _runACPOnce(prompt, cwd, config = {}) {
     return new Promise((resolve, reject) => {
       const {
         timeout = 300000,
@@ -147,11 +164,10 @@ class AgentRunner {
         onError = null
       } = config;
 
-      // Use adapter if required (e.g., for Claude Code via Zed adapter)
       const cmd = this.requiresAdapter && this.adapterCommand ? this.adapterCommand : this.command;
       const baseArgs = this.requiresAdapter && this.adapterCommand ? this.adapterArgs : ['acp'];
       const args = [...baseArgs];
-      
+
       const proc = spawn(cmd, args, { cwd });
 
       if (config.onPid) {
@@ -163,6 +179,7 @@ class AgentRunner {
       let sessionId = null;
       let requestId = 0;
       let initialized = false;
+      let stderrText = '';
 
       const timeoutHandle = setTimeout(() => {
         timedOut = true;
@@ -170,12 +187,9 @@ class AgentRunner {
         reject(new Error(`${this.name} ACP timeout after ${timeout}ms`));
       }, timeout);
 
-      // ACP protocol handler
       const handleMessage = (message) => {
-        // Normalize ACP message to common format
         const normalized = this.protocolHandler(message, { sessionId, initialized });
         if (!normalized) {
-          // Check for initialization response
           if (message.id === 1 && message.result) {
             initialized = true;
           }
@@ -217,13 +231,13 @@ class AgentRunner {
 
       proc.stderr.on('data', (chunk) => {
         const errorText = chunk.toString();
+        stderrText += errorText;
         console.error(`[${this.id}] stderr:`, errorText);
         if (onError) {
           try { onError(errorText); } catch (e) {}
         }
       });
 
-      // Send ACP initialize request (protocolVersion must be an integer per ACP spec)
       const initRequest = {
         jsonrpc: '2.0',
         id: ++requestId,
@@ -245,12 +259,10 @@ class AgentRunner {
 
       let sessionCreated = false;
 
-      // Wait for initialization then create session and send prompt
       const checkInitAndSend = () => {
         if (initialized && !sessionCreated) {
           sessionCreated = true;
-          
-          // Step 1: Create a new session
+
           const sessionRequest = {
             jsonrpc: '2.0',
             id: ++requestId,
@@ -269,14 +281,11 @@ class AgentRunner {
       let promptId = null;
       let completed = false;
 
-      // Handle session creation response and send prompt
       const originalHandler = handleMessage;
       const enhancedHandler = (message) => {
-        // Check for session/new response
         if (message.id && message.result && message.result.sessionId) {
           sessionId = message.result.sessionId;
-          
-          // Step 2: Send the prompt
+
           promptId = ++requestId;
           const promptRequest = {
             jsonrpc: '2.0',
@@ -290,8 +299,7 @@ class AgentRunner {
           proc.stdin.write(JSON.stringify(promptRequest) + '\n');
           return;
         }
-        
-        // Check for prompt response (end of turn)
+
         if (message.id === promptId && message.result && message.result.stopReason) {
           completed = true;
           clearTimeout(timeoutHandle);
@@ -299,11 +307,10 @@ class AgentRunner {
           resolve({ outputs, sessionId });
           return;
         }
-        
+
         originalHandler(message);
       };
 
-      // Override the message handler
       buffer = '';
       proc.stdout.removeAllListeners('data');
       proc.stdout.on('data', (chunk) => {
@@ -317,12 +324,11 @@ class AgentRunner {
           if (line.trim()) {
             try {
               const message = JSON.parse(line);
-              
-              // Check for initialization response
+
               if (message.id === 1 && message.result) {
                 initialized = true;
               }
-              
+
               enhancedHandler(message);
             } catch (e) {
               console.error(`[${this.id}] JSON parse error:`, line.substring(0, 100));
@@ -340,7 +346,8 @@ class AgentRunner {
         if (code === 0 || outputs.length > 0) {
           resolve({ outputs, sessionId });
         } else {
-          reject(new Error(`${this.name} ACP exited with code ${code}`));
+          const detail = stderrText ? `: ${stderrText.substring(0, 200)}` : '';
+          reject(new Error(`${this.name} ACP exited with code ${code}${detail}`));
         }
       });
 
@@ -386,12 +393,15 @@ class AgentRegistry {
   }
 
   listACPAvailable() {
-    // Check which agents are actually installed
-    const { execSync } = require('child_process');
+    const { spawnSync } = require('child_process');
     return this.list().filter(agent => {
       try {
-        execSync(`which ${agent.command} 2>/dev/null`, { encoding: 'utf-8' });
-        return true;
+        const which = spawnSync('which', [agent.command], { encoding: 'utf-8', timeout: 3000 });
+        if (which.status !== 0) return false;
+        const binPath = (which.stdout || '').trim();
+        if (!binPath) return false;
+        const check = spawnSync(binPath, ['--version'], { encoding: 'utf-8', timeout: 10000 });
+        return check.status === 0 && (check.stdout || '').trim().length > 0;
       } catch {
         return false;
       }

package/package.json

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

package/server.js

@@ -23,6 +23,9 @@ const SYSTEM_PROMPT = `Write all responses as clean semantic HTML. Use tags like
 
 const activeExecutions = new Map();
 const messageQueues = new Map();
+const STUCK_AGENT_THRESHOLD_MS = 600000;
+const NO_PID_GRACE_PERIOD_MS = 60000;
+const STALE_SESSION_MIN_AGE_MS = 30000;
 
 const debugLog = (msg) => {
   const timestamp = new Date().toISOString();
@@ -648,7 +651,7 @@ function persistChunkWithRetry(sessionId, conversationId, sequence, blockType, b
 
 async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId) {
   const startTime = Date.now();
-  activeExecutions.set(conversationId, { pid: null, startTime, sessionId });
+  activeExecutions.set(conversationId, { pid: null, startTime, sessionId, lastActivity: startTime });
   queries.setIsStreaming(conversationId, true);
   queries.updateSession(sessionId, { status: 'active' });
 
@@ -665,6 +668,8 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
 
     const onEvent = (parsed) => {
       eventCount++;
+      const entry = activeExecutions.get(conversationId);
+      if (entry) entry.lastActivity = Date.now();
       debugLog(`[stream] Event ${eventCount}: type=${parsed.type}`);
 
       if (parsed.type === 'system') {
@@ -1045,25 +1050,27 @@ server.on('error', (err) => {
 function recoverStaleSessions() {
   try {
     const staleSessions = queries.getActiveSessions ? queries.getActiveSessions() : [];
+    const now = Date.now();
     let recoveredCount = 0;
     for (const session of staleSessions) {
-      if (!activeExecutions.has(session.conversationId)) {
-        queries.updateSession(session.id, {
-          status: 'error',
-          error: 'Agent died unexpectedly (server restart)',
-          completed_at: Date.now()
-        });
-        queries.setIsStreaming(session.conversationId, false);
-        broadcastSync({
-          type: 'streaming_error',
-          sessionId: session.id,
-          conversationId: session.conversationId,
-          error: 'Agent died unexpectedly (server restart)',
-          recoverable: false,
-          timestamp: Date.now()
-        });
-        recoveredCount++;
-      }
+      if (activeExecutions.has(session.conversationId)) continue;
+      const sessionAge = now - session.started_at;
+      if (sessionAge < STALE_SESSION_MIN_AGE_MS) continue;
+      queries.updateSession(session.id, {
+        status: 'error',
+        error: 'Agent died unexpectedly (server restart)',
+        completed_at: now
+      });
+      queries.setIsStreaming(session.conversationId, false);
+      broadcastSync({
+        type: 'streaming_error',
+        sessionId: session.id,
+        conversationId: session.conversationId,
+        error: 'Agent died unexpectedly (server restart)',
+        recoverable: false,
+        timestamp: now
+      });
+      recoveredCount++;
     }
     if (recoveredCount > 0) {
       console.log(`[RECOVERY] Recovered ${recoveredCount} stale active session(s)`);
@@ -1073,31 +1080,63 @@ function recoverStaleSessions() {
   }
 }
 
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === 'EPERM') return true;
+    return false;
+  }
+}
+
+function markAgentDead(conversationId, entry, reason) {
+  if (!activeExecutions.has(conversationId)) return;
+  activeExecutions.delete(conversationId);
+  queries.setIsStreaming(conversationId, false);
+  if (entry.sessionId) {
+    queries.updateSession(entry.sessionId, {
+      status: 'error',
+      error: reason,
+      completed_at: Date.now()
+    });
+  }
+  broadcastSync({
+    type: 'streaming_error',
+    sessionId: entry.sessionId,
+    conversationId,
+    error: reason,
+    recoverable: false,
+    timestamp: Date.now()
+  });
+  drainMessageQueue(conversationId);
+}
+
 function performAgentHealthCheck() {
+  const now = Date.now();
   for (const [conversationId, entry] of activeExecutions) {
-    if (!entry || !entry.pid) continue;
-    try {
-      process.kill(entry.pid, 0);
-    } catch (err) {
-      debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} is dead`);
-      activeExecutions.delete(conversationId);
-      queries.setIsStreaming(conversationId, false);
-      if (entry.sessionId) {
-        queries.updateSession(entry.sessionId, {
-          status: 'error',
-          error: 'Agent process died unexpectedly',
-          completed_at: Date.now()
+    if (!entry) continue;
+
+    if (entry.pid) {
+      if (!isProcessAlive(entry.pid)) {
+        debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} is dead`);
+        markAgentDead(conversationId, entry, 'Agent process died unexpectedly');
+      } else if (now - entry.lastActivity > STUCK_AGENT_THRESHOLD_MS) {
+        debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} has no activity for ${Math.round((now - entry.lastActivity) / 1000)}s`);
+        broadcastSync({
+          type: 'streaming_error',
+          sessionId: entry.sessionId,
+          conversationId,
+          error: 'Agent may be stuck (no activity for 10 minutes)',
+          recoverable: true,
+          timestamp: now
         });
       }
-      broadcastSync({
-        type: 'streaming_error',
-        sessionId: entry.sessionId,
-        conversationId,
-        error: 'Agent process died unexpectedly',
-        recoverable: false,
-        timestamp: Date.now()
-      });
-      drainMessageQueue(conversationId);
+    } else {
+      if (now - entry.startTime > NO_PID_GRACE_PERIOD_MS) {
+        debugLog(`[HEALTH] Agent for conv ${conversationId} never reported PID after ${Math.round((now - entry.startTime) / 1000)}s`);
+        markAgentDead(conversationId, entry, 'Agent failed to start (no PID reported)');
+      }
     }
   }
 }