agentgui 1.0.38 → 1.0.40

package/acp-launcher.js

@@ -116,7 +116,6 @@ export default class ACPConnection {
     this.pendingRequests = new Map();
     this.sessionId = null;
     this.onUpdate = null;
-    this.printMode = false;
     this.cwd = '/config';
   }
 
@@ -140,18 +139,13 @@ export default class ACPConnection {
       await Promise.race([acpSetup(), deadline]);
       console.log(`[ACP] Connected via ACP bridge (${agentType})`);
     } catch (acpErr) {
-      console.log(`[ACP] Bridge failed: ${acpErr.message}`);
-      console.log(`[ACP] Falling back to claude --print mode`);
-      this.printMode = true;
-      this.sessionId = 'print-' + Date.now();
+      console.error(`[ACP] ❌ FATAL: Bridge failed: ${acpErr.message}`);
+      console.error(`[ACP] The ACP bridge is REQUIRED. Please install the bridge for ${agentType}.`);
       if (this.child) {
         try { this.child.kill('SIGTERM'); } catch (_) {}
         this.child = null;
       }
-      for (const [id, req] of this.pendingRequests) {
-        clearTimeout(req.timeoutId);
-      }
-      this.pendingRequests.clear();
+      throw acpErr;
     }
   }
 
@@ -294,7 +288,6 @@ export default class ACPConnection {
   }
 
   async initialize() {
-    if (this.printMode) return {};
     return this.sendRequest('initialize', {
       protocolVersion: 1,
       clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
@@ -302,77 +295,47 @@ export default class ACPConnection {
   }
 
   async newSession(cwd) {
-    if (this.printMode) {
-      this.cwd = cwd;
-      return { sessionId: this.sessionId };
-    }
     const result = await this.sendRequest('session/new', { cwd, mcpServers: [] }, 120000);
     this.sessionId = result.sessionId;
     return result;
   }
 
   async setSessionMode(modeId) {
-    if (this.printMode) return {};
     return this.sendRequest('session/set_mode', { sessionId: this.sessionId, modeId });
   }
 
   async injectSkills(additionalContext = '') {
-    if (this.printMode) return {};
-    
     // Combine the system prompt with any additional context
     const systemPrompt = additionalContext ? `${RIPPLEUI_SYSTEM_PROMPT}\n\n---\n\n${additionalContext}` : RIPPLEUI_SYSTEM_PROMPT;
-    
-    try {
-      const result = await this.sendRequest('session/skill_inject', {
-        sessionId: this.sessionId,
-        skills: [],
-        notification: [{ type: 'text', text: systemPrompt }]
-      });
-      return result;
-    } catch (e) {
-      // skill_inject may not be supported, try alternative methods
-      console.log(`[ACP] skill_inject failed (may not be supported): ${e.message}`);
-      return null;
-    }
+
+    return this.sendRequest('session/skill_inject', {
+      sessionId: this.sessionId,
+      skills: [],
+      notification: [{ type: 'text', text: systemPrompt }]
+    });
   }
 
   /**
    * Inject system prompt as initial context
    */
   async injectSystemContext() {
-    if (this.printMode) return {};
-    
-    // Some versions may need the system prompt sent as the first message context
-    try {
-      await this.sendRequest('session/context', {
-        sessionId: this.sessionId,
-        context: RIPPLEUI_SYSTEM_PROMPT,
-        role: 'system'
-      });
-      return { success: true };
-    } catch (e) {
-      // This method may not be supported, silently fail
-      return null;
-    }
+    return this.sendRequest('session/context', {
+      sessionId: this.sessionId,
+      context: RIPPLEUI_SYSTEM_PROMPT,
+      role: 'system'
+    });
   }
 
   async sendPrompt(prompt) {
-    if (this.printMode) return this._sendPrintPrompt(prompt);
     const promptContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: prompt }];
     return this.sendRequest('session/prompt', { sessionId: this.sessionId, prompt: promptContent }, 300000);
   }
 
-  async _sendPrintPrompt(prompt) {
-    throw new Error('Claude Code uses OAuth and requires the ACP bridge. The fallback to direct API calls is not supported because OAuth tokens cannot be used with the Anthropic API directly. Please ensure claude-code-acp is available in your PATH.');
-  }
-
   isRunning() {
-    if (this.printMode) return true;
     return this.child && !this.child.killed;
   }
 
   async terminate() {
-    if (this.printMode) { this.printMode = false; return; }
     if (!this.child) return;
     this.child.stdin.end();
     this.child.kill('SIGTERM');

package/database.js

@@ -89,6 +89,21 @@ function initSchema() {
     );
 
     CREATE INDEX IF NOT EXISTS idx_idempotency_created ON idempotencyKeys(created_at);
+
+    CREATE TABLE IF NOT EXISTS stream_updates (
+      id TEXT PRIMARY KEY,
+      sessionId TEXT NOT NULL,
+      conversationId TEXT NOT NULL,
+      updateType TEXT NOT NULL,
+      content TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (sessionId) REFERENCES sessions(id),
+      FOREIGN KEY (conversationId) REFERENCES conversations(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_stream_updates_session ON stream_updates(sessionId);
+    CREATE INDEX IF NOT EXISTS idx_stream_updates_created ON stream_updates(created_at);
   `);
 }
 
@@ -596,6 +611,55 @@ export const queries = {
     }
 
     return imported;
+  },
+
+  createStreamUpdate(sessionId, conversationId, updateType, content) {
+    const id = generateId('upd');
+    const now = Date.now();
+
+    // Use transaction to ensure atomic sequence number assignment
+    const transaction = db.transaction(() => {
+      const maxSequence = db.prepare(
+        'SELECT MAX(sequence) as max FROM stream_updates WHERE sessionId = ?'
+      ).get(sessionId);
+      const sequence = (maxSequence?.max || -1) + 1;
+
+      db.prepare(
+        `INSERT INTO stream_updates (id, sessionId, conversationId, updateType, content, sequence, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(id, sessionId, conversationId, updateType, JSON.stringify(content), sequence, now);
+
+      return sequence;
+    });
+
+    const sequence = transaction();
+
+    return {
+      id,
+      sessionId,
+      conversationId,
+      updateType,
+      content,
+      sequence,
+      created_at: now
+    };
+  },
+
+  getSessionStreamUpdates(sessionId) {
+    const stmt = db.prepare(
+      `SELECT id, sessionId, conversationId, updateType, content, sequence, created_at
+       FROM stream_updates WHERE sessionId = ? ORDER BY sequence ASC`
+    );
+    const rows = stmt.all(sessionId);
+    return rows.map(row => ({
+      ...row,
+      content: JSON.parse(row.content)
+    }));
+  },
+
+  clearSessionStreamUpdates(sessionId) {
+    const stmt = db.prepare('DELETE FROM stream_updates WHERE sessionId = ?');
+    stmt.run(sessionId);
   }
 };
 

package/package.json

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

package/server.js

@@ -10,6 +10,8 @@ import ACPConnection from './acp-launcher.js';
 import { ResponseFormatter } from './response-formatter.js';
 import { HTMLWrapper } from './html-wrapper.js';
 import { SessionStateStore } from './state-manager.js';
+import { StreamHandler } from './stream-handler.js';
+import { StateValidator } from './state-validator.js';
 
 // Debug logging to file
 const debugLog = (msg) => {
@@ -253,6 +255,38 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    const streamUpdatesMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/stream-updates$/);
+    if (streamUpdatesMatch && req.method === 'GET') {
+      const sessionId = streamUpdatesMatch[1];
+      const updates = queries.getSessionStreamUpdates(sessionId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ sessionId, updates, count: updates.length }));
+      return;
+    }
+
+    const stateRecoveryMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/state-recovery$/);
+    if (stateRecoveryMatch && req.method === 'GET') {
+      const sessionId = stateRecoveryMatch[1];
+      const state = StateValidator.getSessionState(sessionId);
+      if (!state) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Session not found' }));
+        return;
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(state));
+      return;
+    }
+
+    const stateValidationMatch = routePath.match(/^\/api\/sessions\/([^/]+)\/validate$/);
+    if (stateValidationMatch && req.method === 'GET') {
+      const sessionId = stateValidationMatch[1];
+      const validation = StateValidator.validateSession(sessionId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(validation));
+      return;
+    }
+
     if (routePath === '/api/import/claude-code' && req.method === 'GET') {
       const result = queries.importClaudeCodeConversations();
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -360,13 +394,13 @@ function serveFile(filePath, res) {
 }
 
 /**
- * Process a user message through the Claude Code ACP with explicit state tracking
- * This is now fully predictable with no hidden failures
+ * Process a user message through the Claude Code ACP with real-time streaming
+ * Updates are persisted to database and broadcast to clients immediately
  */
 async function processMessage(conversationId, messageId, sessionId, content, agentId, folderContext) {
   // Create state manager for this session
   const stateManager = sessionStateStore.create(sessionId, conversationId, messageId, 120000);
-  
+
   try {
     console.log(`[processMessage] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
     console.log(`[processMessage] Initial state: ${stateManager.getState()}`);
@@ -379,35 +413,26 @@ async function processMessage(conversationId, messageId, sessionId, content, age
 
     const cwd = folderContext?.path || '/config';
     const actualAgentId = agentId || 'claude-code';
-    
+
     try {
       const conn = await getACP(actualAgentId, cwd);
-      
+
       // STATE: ACQUIRING_ACP → ACP_ACQUIRED
       stateManager.transition(stateManager.constructor.STATES.ACP_ACQUIRED, {
         reason: 'ACP connection established',
         data: { acpConnectionTime: Date.now() }
       });
 
+      // Create stream handler for real-time persistence and broadcasting
+      const streamHandler = new StreamHandler(sessionId, conversationId, broadcastSync);
       let fullText = '';
-      const blocks = [];
-      const updateChunks = [];
 
-      // Setup response accumulation
+      // Setup response streaming
       conn.onUpdate = (params) => {
+        streamHandler.handleUpdate(params, BASE_URL);
         const u = params.update;
-        if (!u) return;
-        const kind = u.sessionUpdate;
-        if (kind === 'agent_message_chunk' && u.content?.text) {
+        if (u?.sessionUpdate === 'agent_message_chunk' && u.content?.text) {
           fullText += u.content.text;
-          updateChunks.push({ type: 'text', content: u.content.text, timestamp: Date.now() });
-        } else if (kind === 'html_content' && u.content?.html) {
-          blocks.push({ type: 'html', html: u.content.html, title: u.content.title, id: u.content.id });
-          updateChunks.push({ type: 'html', content: u.content.html, title: u.content.title, timestamp: Date.now() });
-        } else if (kind === 'image_content' && u.content?.path) {
-          const imageUrl = BASE_URL + '/api/image/' + encodeURIComponent(u.content.path);
-          blocks.push({ type: 'image', path: u.content.path, url: imageUrl, title: u.content.title, alt: u.content.alt });
-          updateChunks.push({ type: 'image', path: u.content.path, url: imageUrl, title: u.content.title, timestamp: Date.now() });
         }
       };
 
@@ -427,61 +452,64 @@ async function processMessage(conversationId, messageId, sessionId, content, age
         data: { promptSentTime: Date.now(), responseReceivedTime: Date.now() }
       });
 
-      console.log(`[processMessage] ACP returned: stopReason=${result?.stopReason}, fullText=${fullText.length} chars`);
+      console.log(`[processMessage] ACP returned: stopReason=${result?.stopReason}, streamUpdates=${streamHandler.getUpdateCount()}`);
 
-      // Format response
+      // Use full text if available, otherwise use result
       let responseText = fullText || result?.result || (result?.stopReason ? `Completed: ${result.stopReason}` : 'No response.');
-      
-      // Wrap response in HTML if needed
+
+      // Only wrap plain text in HTML - don't wrap if already HTML
       const isHTML = responseText.trim().startsWith('<');
       if (!isHTML) {
         responseText = HTMLWrapper.wrapResponse(responseText);
       }
-      
+
       // Segment and format
       const segments = ResponseFormatter.segmentResponse(responseText);
       const metadata = ResponseFormatter.extractMetadata(responseText);
-      
-      const messageContent = blocks.length > 0 ? { 
-        text: responseText, 
-        blocks,
-        segments,
-        metadata,
-        updateChunks,
-        isHTML: true
-      } : {
+      const blocks = streamHandler.getBlocks();
+
+      const messageContent = {
         text: responseText,
+        blocks: blocks.length > 0 ? blocks : undefined,
         segments,
         metadata,
-        updateChunks,
+        streamUpdatesCount: streamHandler.getUpdateCount(),
         isHTML: true
       };
 
-      // Save response to database
+      // Save consolidated response to database
       const assistantMessage = queries.createMessage(conversationId, 'assistant', messageContent);
-      queries.updateSession(sessionId, { status: 'completed', response: { text: responseText, messageId: assistantMessage.id }, completed_at: Date.now() });
+      queries.updateSession(sessionId, {
+        status: 'completed',
+        response: { text: responseText, messageId: assistantMessage.id },
+        completed_at: Date.now()
+      });
       queries.createEvent('session.completed', { messageId: assistantMessage.id }, conversationId, sessionId);
 
-      // Broadcast to connected clients
-      broadcastSync({ type: 'session_updated', sessionId, status: 'completed', message: assistantMessage });
+      // Broadcast final consolidated response
+      broadcastSync({
+        type: 'session_updated',
+        sessionId,
+        status: 'completed',
+        message: assistantMessage
+      });
 
       // STATE: PROCESSING → COMPLETED
       stateManager.transition(stateManager.constructor.STATES.COMPLETED, {
         reason: 'Response successfully generated and saved',
         data: {
-          fullText,
-          blocks,
           responseLength: responseText.length,
-          messageId: assistantMessage.id
+          messageId: assistantMessage.id,
+          streamUpdates: streamHandler.getUpdateCount()
         }
       });
 
-      console.log(`[processMessage] ✅ Session completed: ${stateManager.getSummary().duration}`);
+      console.log(`[processMessage] ✅ Session completed with ${streamHandler.getUpdateCount()} stream updates: ${stateManager.getSummary().duration}`);
 
     } catch (acpError) {
       console.error(`[processMessage] ACP Error: ${acpError.message}`);
       console.error(`[processMessage] Stack: ${acpError.stack}`);
-      
+
       // STATE: → ERROR
       stateManager.transition(stateManager.constructor.STATES.ERROR, {
         reason: `ACP error: ${acpError.message}`,
@@ -546,16 +574,70 @@ wss.on('connection', (ws, req) => {
   } else if (wsPath === '/sync') {
     syncClients.add(ws);
     ws.isAlive = true;
-    ws.send(JSON.stringify({ type: 'sync_connected' }));
+    ws.subscriptions = new Set();
+    ws.clientId = `client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    ws.send(JSON.stringify({
+      type: 'sync_connected',
+      clientId: ws.clientId,
+      timestamp: Date.now()
+    }));
+
+    ws.on('message', (msg) => {
+      try {
+        const data = JSON.parse(msg);
+        if (data.type === 'subscribe') {
+          ws.subscriptions.add(data.sessionId);
+          // On subscribe, send current state for recovery
+          const state = StateValidator.getSessionState(data.sessionId);
+          if (state) {
+            ws.send(JSON.stringify({
+              type: 'state_snapshot',
+              sessionId: data.sessionId,
+              state,
+              timestamp: Date.now()
+            }));
+          }
+        } else if (data.type === 'unsubscribe') {
+          ws.subscriptions.delete(data.sessionId);
+        } else if (data.type === 'recovery_request') {
+          // Client asking to recover from a checkpoint
+          const state = StateValidator.getSessionState(data.sessionId);
+          if (state) {
+            ws.send(JSON.stringify({
+              type: 'recovery_response',
+              sessionId: data.sessionId,
+              state,
+              timestamp: Date.now()
+            }));
+          }
+        }
+      } catch (e) {
+        console.error('WebSocket message parse error:', e.message);
+      }
+    });
+
     ws.on('pong', () => { ws.isAlive = true; });
-    ws.on('close', () => { syncClients.delete(ws); });
+    ws.on('close', () => {
+      syncClients.delete(ws);
+      console.log(`[WebSocket] Client ${ws.clientId} disconnected`);
+    });
   }
 });
 
 function broadcastSync(event) {
   const data = JSON.stringify(event);
   for (const ws of syncClients) {
-    if (ws.readyState === 1) ws.send(data);
+    if (ws.readyState === 1) {
+      // CRITICAL: Only send if client subscribed to this session
+      if (event.sessionId) {
+        if (!ws.subscriptions || !ws.subscriptions.has(event.sessionId)) {
+          continue;
+        }
+      }
+      // Send immediately - no buffering
+      ws.send(data);
+    }
   }
 }
 

package/state-validator.js

@@ -0,0 +1,150 @@
+import { queries } from './database.js';
+import crypto from 'crypto';
+
+export class StateValidator {
+  /**
+   * Validates data consistency by checking:
+   * 1. Sequence numbers are consecutive (no gaps)
+   * 2. Stream updates match database
+   * 3. Final message matches aggregated stream updates
+   */
+  static validateSession(sessionId) {
+    try {
+      const session = queries.getSession(sessionId);
+      if (!session) return { valid: false, error: 'Session not found' };
+
+      const updates = queries.getSessionStreamUpdates(sessionId);
+
+      // Check 1: Sequence continuity
+      const sequenceGaps = [];
+      for (let i = 0; i < updates.length - 1; i++) {
+        if (updates[i + 1].sequence !== updates[i].sequence + 1) {
+          sequenceGaps.push({ expected: updates[i].sequence + 1, actual: updates[i + 1].sequence });
+        }
+      }
+
+      if (sequenceGaps.length > 0) {
+        return {
+          valid: false,
+          error: 'Sequence gaps detected',
+          gaps: sequenceGaps
+        };
+      }
+
+      // Check 2: Stream update count matches
+      const textUpdates = updates.filter(u => u.updateType === 'text');
+      const htmlUpdates = updates.filter(u => u.updateType === 'html');
+      const imageUpdates = updates.filter(u => u.updateType === 'image');
+
+      // Check 3: Sequence starts at 0
+      if (updates.length > 0 && updates[0].sequence !== 0) {
+        return {
+          valid: false,
+          error: 'Sequence should start at 0',
+          firstSequence: updates[0].sequence
+        };
+      }
+
+      return {
+        valid: true,
+        sessionId,
+        updateCount: updates.length,
+        textCount: textUpdates.length,
+        htmlCount: htmlUpdates.length,
+        imageCount: imageUpdates.length,
+        latestSequence: updates.length > 0 ? updates[updates.length - 1].sequence : -1,
+        checkpoint: this.createChecksum(updates)
+      };
+    } catch (err) {
+      return {
+        valid: false,
+        error: err.message
+      };
+    }
+  }
+
+  /**
+   * Creates checksum of stream updates for integrity verification
+   */
+  static createChecksum(updates) {
+    const data = updates
+      .map(u => `${u.sequence}:${u.updateType}:${u.created_at}`)
+      .join('|');
+    return crypto.createHash('sha256').update(data).digest('hex');
+  }
+
+  /**
+   * Verifies checksum hasn't changed (data integrity)
+   */
+  static verifyChecksum(updates, expectedChecksum) {
+    return this.createChecksum(updates) === expectedChecksum;
+  }
+
+  /**
+   * Gets current state for client recovery
+   */
+  static getSessionState(sessionId) {
+    const session = queries.getSession(sessionId);
+    if (!session) return null;
+
+    const updates = queries.getSessionStreamUpdates(sessionId);
+    const validation = this.validateSession(sessionId);
+
+    return {
+      session: {
+        id: session.id,
+        conversationId: session.conversationId,
+        status: session.status,
+        started_at: session.started_at,
+        completed_at: session.completed_at
+      },
+      updates: updates.map(u => ({
+        sequence: u.sequence,
+        updateType: u.updateType,
+        content: u.content,
+        created_at: u.created_at
+      })),
+      validation,
+      checkpoint: validation.checkpoint,
+      recoveryPoint: {
+        lastSequence: updates.length > 0 ? updates[updates.length - 1].sequence : -1,
+        totalUpdates: updates.length,
+        timestamp: Date.now()
+      }
+    };
+  }
+
+  /**
+   * Validates incoming update against current state
+   */
+  static validateUpdate(sessionId, incomingUpdate, lastKnownSequence) {
+    const updates = queries.getSessionStreamUpdates(sessionId);
+    const maxSequence = updates.length > 0 ? updates[updates.length - 1].sequence : -1;
+
+    // Check if this is the next expected sequence
+    const expectedSequence = maxSequence + 1;
+    if (incomingUpdate.sequence !== expectedSequence) {
+      return {
+        valid: false,
+        error: 'Sequence out of order',
+        expected: expectedSequence,
+        received: incomingUpdate.sequence,
+        action: 'FETCH_MISSING_UPDATES'
+      };
+    }
+
+    // Check for duplicates (same sequence already exists)
+    if (updates.some(u => u.sequence === incomingUpdate.sequence)) {
+      return {
+        valid: false,
+        error: 'Duplicate update detected',
+        sequence: incomingUpdate.sequence,
+        action: 'IGNORE_DUPLICATE'
+      };
+    }
+
+    return { valid: true, sequence: expectedSequence };
+  }
+}
+
+export default StateValidator;