agentgui 1.0.39 → 1.0.41

package/acp-launcher.js

@@ -1,37 +1,4 @@
-import { spawn } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-// Common paths where claude-code-acp might be installed
-const CLAUDE_CODE_ACP_PATHS = [
-  '/config/.gmweb/npm-global/bin/claude-code-acp',
-  '/usr/local/bin/claude-code-acp',
-  '/usr/bin/claude-code-acp',
-  path.join(os.homedir(), '.local/bin/claude-code-acp'),
-  path.join(os.homedir(), '.gmweb/npm-global/bin/claude-code-acp'),
-  'claude-code-acp', // fallback to PATH
-];
-
-// Common paths where opencode might be installed
-const OPENCODE_PATHS = [
-  '/usr/local/bin/opencode',
-  '/usr/bin/opencode',
-  path.join(os.homedir(), '.local/bin/opencode'),
-  'opencode', // fallback to PATH
-];
-
-function findBinary(paths) {
-  for (const p of paths) {
-    try {
-      fs.accessSync(p, fs.constants.X_OK);
-      return p;
-    } catch (_) {
-      continue;
-    }
-  }
-  return null;
-}
+import { createClient } from 'claude-code-acp';
 
 const RIPPLEUI_SYSTEM_PROMPT = `CRITICAL INSTRUCTION: You are responding in a web-based HTML interface. EVERY response must be formatted as beautiful, styled HTML using RippleUI and Tailwind CSS. This is NOT a text-based interface - users see raw HTML rendered in their browser.
 
@@ -94,289 +61,138 @@ MANDATORY RULES:
 ✓ Use color classes: text-gray-700, bg-blue-50, border-blue-500
 ✓ Make visual hierarchy clear: use different font sizes, colors, cards
 
-EXAMPLES OF COMPLETE RESPONSES:
-
-Example 1 - Answer:
-<div class="space-y-4 p-6"><h2 class="text-2xl font-bold">Explanation</h2><p class="text-gray-700">Here is the detailed explanation...</p></div>
-
-Example 2 - Code:
-<div class="space-y-4 p-6"><h3 class="text-xl font-bold">JavaScript Function</h3><pre class="bg-gray-900 text-white p-4 rounded overflow-x-auto"><code>const greet = () => console.log('Hello');</code></pre></div>
-
-Example 3 - Multiple sections:
-<div class="space-y-4 p-6"><h2 class="text-2xl font-bold">Topic</h2><div class="card bg-white shadow p-4"><h3 class="font-bold">Section 1</h3><p>Content here</p></div><div class="card bg-white shadow p-4"><h3 class="font-bold">Section 2</h3><p>More content</p></div></div>
-
 YOU MUST ALWAYS OUTPUT VALID, COMPLETE HTML.
 The user's interface shows YOUR HTML directly - make it beautiful, well-organized, and professional.`;
 
 export default class ACPConnection {
   constructor() {
-    this.child = null;
-    this.buffer = '';
-    this.nextRequestId = 1;
-    this.pendingRequests = new Map();
+    this.client = null;
     this.sessionId = null;
     this.onUpdate = null;
-    this.printMode = false;
-    this.cwd = '/config';
   }
 
+  /**
+   * Connect to ACP bridge and create session
+   */
   async connect(agentType, cwd) {
-    this.cwd = cwd;
-
-    const acpSetup = async () => {
-      await this._spawnACP(agentType, cwd);
-      await this.sendRequest('initialize', {
-        protocolVersion: 1,
-        clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
-      }, 10000);
-      const result = await this.sendRequest('session/new', { cwd, mcpServers: [] }, 30000);
-      this.sessionId = result.sessionId;
-      await this.sendRequest('session/set_mode', { sessionId: this.sessionId, modeId: 'bypassPermissions' }, 10000);
-    };
-
-    const deadline = new Promise((_, reject) => setTimeout(() => reject(new Error('ACP handshake timeout (60s)')), 60000));
-
     try {
-      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();
-      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();
-    }
-  }
-
-  _spawnACP(agentType, cwd) {
-    return new Promise((resolve, reject) => {
-      const env = { ...process.env };
-      delete env.NODE_OPTIONS;
-      delete env.NODE_INSPECT;
-      delete env.NODE_DEBUG;
-
-      // Ensure npm global bin directories are in PATH
-      const npmGlobalBins = [
-        '/config/.gmweb/npm-global/bin',
-        path.join(os.homedir(), '.gmweb/npm-global/bin'),
-        path.join(os.homedir(), '.local/bin'),
-        '/usr/local/bin',
-      ];
-      const currentPath = env.PATH || '';
-      const newPathEntries = npmGlobalBins.filter(p => !currentPath.includes(p));
-      if (newPathEntries.length > 0) {
-        env.PATH = [...newPathEntries, currentPath].join(':');
-      }
+      console.log(`[ACP] Connecting to ${agentType}...`);
 
-      try {
-        let cmd;
-        let args;
-        if (agentType === 'opencode') {
-          cmd = findBinary(OPENCODE_PATHS);
-          args = ['acp'];
-        } else {
-          cmd = findBinary(CLAUDE_CODE_ACP_PATHS);
-          args = [];
-        }
-
-        if (!cmd) {
-          reject(new Error(`Could not find ${agentType} ACP binary. Please ensure ${agentType === 'opencode' ? 'opencode' : 'claude-code-acp'} is installed and in your PATH.`));
-          return;
-        }
-
-        this.child = spawn(cmd, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env, shell: false });
-      } catch (err) {
-        reject(new Error(`Failed to spawn ACP: ${err.message}`));
-        return;
-      }
-
-      this.child.stderr.on('data', d => console.error(`[ACP:stderr]`, d.toString().trim()));
-      this.child.on('error', err => reject(new Error(`ACP spawn error: ${err.message}`)));
-      this.child.on('exit', () => {
-        this.child = null;
-        for (const [id, req] of this.pendingRequests) {
-          req.reject(new Error('ACP process exited'));
-          clearTimeout(req.timeoutId);
-        }
-        this.pendingRequests.clear();
-      });
-
-      this.child.stdout.setEncoding('utf8');
-      this.child.stdout.on('data', data => {
-        this.buffer += data;
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop() || '';
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try { this.handleMessage(JSON.parse(line)); }
-          catch (e) { console.error('[ACP:parse]', line.substring(0, 200), e.message); }
-        }
+      // Create client directly from npm module
+      this.client = await createClient({
+        agent: agentType === 'opencode' ? 'opencode' : 'claude-code',
+        cwd
       });
 
-      setTimeout(resolve, 300);
-    });
-  }
-
-  handleMessage(msg) {
-    if (msg.method) { this.handleIncoming(msg); return; }
-    if (msg.id !== undefined && this.pendingRequests.has(msg.id)) {
-      const req = this.pendingRequests.get(msg.id);
-      this.pendingRequests.delete(msg.id);
-      clearTimeout(req.timeoutId);
-      if (msg.error) req.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-      else req.resolve(msg.result);
+      console.log(`[ACP] ✅ Connected to ${agentType} (direct module)`);
+    } catch (err) {
+      console.error(`[ACP] ❌ FATAL: Connection failed: ${err.message}`);
+      throw new Error(`ACP connection failed for ${agentType}: ${err.message}`);
     }
   }
 
-  handleIncoming(msg) {
-    if (msg.method === 'session/update' && msg.params) {
-      if (this.onUpdate) this.onUpdate(msg.params);
-      this.resetPromptTimeout();
-      return;
-    }
-    if (msg.method === 'session/request_permission' && msg.id !== undefined) {
-      this.sendResponse(msg.id, { outcome: { outcome: 'selected', optionId: 'allow' } });
-      this.resetPromptTimeout();
-      return;
-    }
-    if (msg.method === 'fs/read_text_file' && msg.id !== undefined) {
-      try { this.sendResponse(msg.id, { content: fs.readFileSync(msg.params?.path, 'utf-8') }); }
-      catch (e) { this.sendError(msg.id, -32000, e.message); }
-      return;
-    }
-    if (msg.method === 'fs/write_text_file' && msg.id !== undefined) {
-      try { fs.writeFileSync(msg.params?.path, msg.params?.content, 'utf-8'); this.sendResponse(msg.id, null); }
-      catch (e) { this.sendError(msg.id, -32000, e.message); }
-      return;
-    }
-  }
-
-  resetPromptTimeout() {
-    for (const [id, req] of this.pendingRequests) {
-      if (req.method === 'session/prompt') {
-        clearTimeout(req.timeoutId);
-        req.timeoutId = setTimeout(() => {
-          this.pendingRequests.delete(id);
-          req.reject(new Error('session/prompt timeout'));
-        }, 300000);
-      }
-    }
-  }
-
-  sendRequest(method, params, timeoutMs = 60000) {
-    return new Promise((resolve, reject) => {
-      if (!this.child) { reject(new Error('ACP not connected')); return; }
-      const id = this.nextRequestId++;
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error(`${method} timeout (${timeoutMs}ms)`));
-      }, timeoutMs);
-      this.pendingRequests.set(id, { resolve, reject, timeoutId, method });
-      this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, ...(params && { params }) }) + '\n');
-    });
-  }
-
-  sendResponse(id, result) {
-    if (!this.child) return;
-    this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
-  }
-
-  sendError(id, code, message) {
-    if (!this.child) return;
-    this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n');
-  }
-
+  /**
+   * Initialize ACP session
+   */
   async initialize() {
-    if (this.printMode) return {};
-    return this.sendRequest('initialize', {
+    if (!this.client) throw new Error('ACP not connected');
+    return this.client.request('initialize', {
       protocolVersion: 1,
-      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
+      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } }
     });
   }
 
+  /**
+   * Create new session
+   */
   async newSession(cwd) {
-    if (this.printMode) {
-      this.cwd = cwd;
-      return { sessionId: this.sessionId };
-    }
-    const result = await this.sendRequest('session/new', { cwd, mcpServers: [] }, 120000);
+    if (!this.client) throw new Error('ACP not connected');
+    const result = await this.client.request('session/new', { cwd, mcpServers: [] });
     this.sessionId = result.sessionId;
     return result;
   }
 
+  /**
+   * Set session mode
+   */
   async setSessionMode(modeId) {
-    if (this.printMode) return {};
-    return this.sendRequest('session/set_mode', { sessionId: this.sessionId, modeId });
+    if (!this.client) throw new Error('ACP not connected');
+    return this.client.request('session/set_mode', { sessionId: this.sessionId, modeId });
   }
 
+  /**
+   * Inject skills and system prompt
+   */
   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;
-    }
+    if (!this.client) throw new Error('ACP not connected');
+
+    const systemPrompt = additionalContext
+      ? `${RIPPLEUI_SYSTEM_PROMPT}\n\n---\n\n${additionalContext}`
+      : RIPPLEUI_SYSTEM_PROMPT;
+
+    return this.client.request('session/skill_inject', {
+      sessionId: this.sessionId,
+      skills: [],
+      notification: [{ type: 'text', text: systemPrompt }]
+    });
   }
 
   /**
-   * Inject system prompt as initial context
+   * Inject system 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;
-    }
+    if (!this.client) throw new Error('ACP not connected');
+
+    return this.client.request('session/context', {
+      sessionId: this.sessionId,
+      context: RIPPLEUI_SYSTEM_PROMPT,
+      role: 'system'
+    });
   }
 
+  /**
+   * Send prompt and stream updates
+   */
   async sendPrompt(prompt) {
-    if (this.printMode) return this._sendPrintPrompt(prompt);
+    if (!this.client) throw new Error('ACP not connected');
+
     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.');
+    // Setup update handler before sending
+    if (this.onUpdate) {
+      this.client.on('update', (update) => {
+        // Forward updates immediately with no delay
+        this.onUpdate({ update });
+      });
+    }
+
+    // Send prompt and get result
+    return this.client.request('session/prompt', {
+      sessionId: this.sessionId,
+      prompt: promptContent
+    }, 300000);
   }
 
+  /**
+   * Check if connection is running
+   */
   isRunning() {
-    if (this.printMode) return true;
-    return this.child && !this.child.killed;
+    return this.client !== null;
   }
 
+  /**
+   * Terminate connection
+   */
   async terminate() {
-    if (this.printMode) { this.printMode = false; return; }
-    if (!this.child) return;
-    this.child.stdin.end();
-    this.child.kill('SIGTERM');
-    await new Promise(r => { this.child?.on('exit', r); setTimeout(r, 5000); });
-    this.child = null;
+    if (!this.client) return;
+
+    try {
+      await this.client.close();
+    } catch (err) {
+      console.error(`[ACP] Error during terminate: ${err.message}`);
+    } finally {
+      this.client = null;
+      this.sessionId = null;
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -18,15 +18,11 @@
   "homepage": "https://github.com/AnEntrypoint/agentgui#readme",
   "scripts": {
     "start": "node server.js",
-    "start:bun": "bun run server-bun.js",
-    "dev": "node server.js --watch",
-    "dev:bun": "bun run server-bun.js --watch",
-    "test": "node run-browser-tests.js",
-    "test:integration": "./test-integration.sh",
-    "test:all": "npm run test:integration && npm run test"
+    "dev": "node server.js --watch"
   },
   "dependencies": {
     "better-sqlite3": "^12.6.2",
+    "claude-code-acp": "^1.0.0",
     "ws": "^8.14.2"
   }
 }

package/server.js

@@ -551,10 +551,10 @@ async function processMessage(conversationId, messageId, sessionId, content, age
     console.error(`[processMessage] State history: ${JSON.stringify(summary, null, 2)}`);
 
   } finally {
-    // Cleanup: remove from state store after completion
-    setTimeout(() => {
+    // Cleanup: remove from state store immediately (async to not block)
+    setImmediate(() => {
       sessionStateStore.remove(sessionId);
-    }, 5000);
+    });
 
     // Log final state
     console.log(`[processMessage] Final state: ${stateManager.getState()}`);

package/stream-handler.js

@@ -62,15 +62,9 @@ export class StreamHandler {
       this.sequence = persistedUpdate.sequence;
       this.updateCount++;
 
-      // Validate consistency after write
-      const validation = StateValidator.validateSession(this.sessionId);
-      if (!validation.valid) {
-        console.error(`[StreamHandler] State validation failed after update:`, validation);
-        // Log but continue - database is still source of truth
-      }
-
       // CRITICAL: Broadcast happens AFTER database write confirms
       // This ensures clients see data that's already persisted
+      // Broadcast immediately with zero delay
       this.broadcastFn({
         type: 'stream_update',
         sessionId: this.sessionId,
@@ -79,8 +73,19 @@ export class StreamHandler {
         update: persistedUpdate.content,
         sequence: this.sequence,
         persisted: true,
-        timestamp: persistedUpdate.created_at,
-        validation: validation.valid ? undefined : { error: validation.error }
+        timestamp: persistedUpdate.created_at
+      });
+
+      // Validate consistency asynchronously (don't block broadcast)
+      setImmediate(() => {
+        try {
+          const validation = StateValidator.validateSession(this.sessionId);
+          if (!validation.valid) {
+            console.error(`[StreamHandler] State validation failed: ${validation.error}`);
+          }
+        } catch (validationErr) {
+          console.error(`[StreamHandler] Validation error: ${validationErr.message}`);
+        }
       });
     } catch (err) {
       console.error(`[StreamHandler] Error persisting update: ${err.message}`);