agentgui 1.0.63 → 1.0.65

package/acp-launcher.js

@@ -8,16 +8,56 @@ import { query } from '@anthropic-ai/claude-code';
  * - Actual filesystem operations
  * - Streaming responses with onUpdate callbacks
  * - No subprocess spawning needed (SDK handles it)
+ * - Integrated glootie-cc MCP servers for full capabilities
  */
 export default class ACPConnection {
   constructor() {
     this.sessionId = null;
     this.onUpdate = null;
     this.cwd = process.cwd();
+    this.mcpServers = this.buildMcpServers();
+  }
+
+  buildMcpServers() {
+    const mcpServers = {};
+
+    // Add glootie-cc MCP servers for full execution capabilities
+    if (process.env.CLAUDE_PLUGIN_ROOT) {
+      const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+      mcpServers['dev'] = {
+        type: 'stdio',
+        command: 'bunx',
+        args: ['mcp-glootie@latest'],
+        timeout: 360000
+      };
+      mcpServers['code-search'] = {
+        type: 'stdio',
+        command: 'bunx',
+        args: ['codebasesearch@latest'],
+        timeout: 360000
+      };
+    } else {
+      // Fallback to standard MCP configuration
+      mcpServers['dev'] = {
+        type: 'stdio',
+        command: 'bunx',
+        args: ['mcp-glootie@latest'],
+        timeout: 360000
+      };
+      mcpServers['code-search'] = {
+        type: 'stdio',
+        command: 'bunx',
+        args: ['codebasesearch@latest'],
+        timeout: 360000
+      };
+    }
+
+    return mcpServers;
   }
 
   async connect(agentType, cwd) {
     console.log(`[ACP] Using @anthropic-ai/claude-code SDK (${agentType})`);
+    console.log(`[ACP] MCP servers configured: ${Object.keys(this.mcpServers).join(', ')}`);
     if (cwd) {
       this.cwd = cwd;
     }
@@ -46,7 +86,7 @@ export default class ACPConnection {
   }
 
   async injectSystemContext() {
-    return { context: 'Using Claude Code SDK with real plugins' };
+    return { context: 'Using Claude Code SDK with glootie-cc MCP integration' };
   }
 
   async sendPrompt(prompt) {
@@ -55,12 +95,42 @@ export default class ACPConnection {
     try {
       console.log(`[ACP] Sending prompt (${promptText.length} chars) in ${this.cwd}`);
 
+      // Build environment with proper permissions and working directory setup
+      const env = {
+        ...process.env,
+        HOME: process.env.HOME || '/config',
+        USER: process.env.USER || 'abc',
+        PATH: process.env.PATH || '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
+        // Ensure file operations are fully enabled
+        CLAUDE_CODE_ALLOW_ALL: 'true',
+        CLAUDE_CODE_BYPASS_PERMISSIONS: 'true'
+      };
+
+      // Build permission updates to allow directory access
+      const permissionUpdates = [
+        {
+          type: 'addDirectories',
+          directories: ['/tmp/test-projects', this.cwd, '/tmp', '/config'],
+          destination: 'session'
+        },
+        {
+          type: 'addRules',
+          rules: ['*'],
+          behavior: 'allow',
+          destination: 'session'
+        }
+      ];
+
       // Use the SDK directly to execute the prompt
       // The SDK handles plugins, system prompt, and all real execution
       const session = await query({
         prompt: promptText,
         options: {
-          cwd: this.cwd
+          cwd: this.cwd,
+          env: env,
+          mcpServers: this.mcpServers,
+          permissionMode: 'acceptEdits',
+          additionalDirectories: ['/tmp/test-projects', this.cwd, '/tmp', '/config']
         }
       });
 

package/package.json

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

package/server.js

@@ -199,7 +199,7 @@ const server = http.createServer(async (req, res) => {
         const idempotencyKey = body.idempotencyKey || null;
         const message = queries.createMessage(conversationId, 'user', body.content, idempotencyKey);
         queries.createEvent('message.created', { role: 'user', messageId: message.id }, conversationId);
-        broadcastSync({ type: 'message_created', conversationId, message });
+        broadcastSync({ type: 'message_created', conversationId, message, timestamp: Date.now() });
         const session = queries.createSession(conversationId);
         queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, conversationId, session.id);
          res.writeHead(201, { 'Content-Type': 'application/json' });
@@ -475,12 +475,14 @@ async function processMessage(conversationId, messageId, sessionId, content, age
       });
       queries.createEvent('session.completed', { messageId: assistantMessage.id }, conversationId, sessionId);
 
-      // Broadcast final consolidated response
+      // Broadcast final consolidated response with full message content
       broadcastSync({
         type: 'session_updated',
         sessionId,
+        conversationId,
         status: 'completed',
-        message: assistantMessage
+        message: assistantMessage,
+        timestamp: Date.now()
       });
 
       // STATE: PROCESSING → COMPLETED
@@ -510,10 +512,10 @@ async function processMessage(conversationId, messageId, sessionId, content, age
 
       // Save error to database
       const errorMsg = `ACP Error: ${acpError.message}`;
-      queries.createMessage(conversationId, 'assistant', errorMsg);
+      const errorMessage = queries.createMessage(conversationId, 'assistant', errorMsg);
       queries.updateSession(sessionId, { status: 'error', error: acpError.message, completed_at: Date.now() });
       queries.createEvent('session.error', { error: acpError.message, stack: acpError.stack }, conversationId, sessionId);
-      broadcastSync({ type: 'session_updated', sessionId, status: 'error', error: acpError.message });
+      broadcastSync({ type: 'session_updated', sessionId, conversationId, status: 'error', error: acpError.message, message: errorMessage, timestamp: Date.now() });
 
       // Clean up ACP connection on error
       acpPool.delete(actualAgentId);

package/static/app.js

@@ -265,14 +265,14 @@ class GMGUIApp {
 
   handleSyncEvent(event, fromBroadcast = false) {
     // CRITICAL: Server is the authoritative source of truth
-    // On ANY event, fetch fresh state from server to ensure consistency
-    // Never rely on event data alone - always verify with server
-    
+    // Real-time WebSocket events for messages arrive immediately
+    // Subscribe to conversation to receive message updates
+
     console.log('[STATE SYNC] Event received:', event.type);
-    
+
     switch (event.type) {
       case 'sync_connected':
-        console.log('[STATE SYNC] Connected to sync bus - fetching full state');
+        console.log('[STATE SYNC] Connected to sync bus - subscribing to all active sessions');
         // On connection, always do a full state refresh
         this.fetchConversations().then(() => this.renderChatHistory());
         break;
@@ -325,32 +325,54 @@ class GMGUIApp {
         break;
 
       case 'message_created':
-        console.log('[STATE SYNC] Message created, fetching full state');
-        // A message was created - refresh everything to see updated timestamps
-        this.fetchConversations().then(() => {
-          this.renderChatHistory();
-          // If we're viewing this conversation, refresh it
-          if (this.currentConversation === event.conversationId) {
-            this.displayConversation(event.conversationId);
+        console.log('[STATE SYNC] Message created via WebSocket - real-time push');
+        // User message was created - add it immediately without polling
+        if (this.currentConversation === event.conversationId && event.message) {
+          console.log('[STATE SYNC] Adding user message to display immediately');
+          // Stop any existing polling for this conversation
+          this.stopPollingMessages();
+          // Add message directly to display
+          this.addMessageToDisplay(event.message);
+          // Update conversation metadata
+          this.fetchConversations().then(() => this.renderChatHistory());
+          // Auto-scroll to new message
+          if (this.settings.autoScroll) {
+            setTimeout(() => {
+              const div = document.getElementById('chatMessages');
+              if (div) div.scrollTop = div.scrollHeight;
+            }, 50);
           }
-        });
+        } else {
+          // Not viewing this conversation, just update timestamps
+          this.fetchConversations().then(() => this.renderChatHistory());
+        }
         if (!fromBroadcast && this.broadcastChannel) {
           this.broadcastChannel.postMessage(event);
         }
         break;
 
       case 'session_updated':
-        console.log('[STATE SYNC] Session updated:', event.status, '- fetching full state');
-        // Session completed with a message - ALWAYS fetch fresh state
-        // This ensures the conversation's updated_at timestamp is synced
-        this.fetchConversations().then(() => {
-          this.renderChatHistory(); // Update sidebar with new timestamps
-          
-          // If viewing this conversation, show the message
-          if (this.currentConversation === event.conversationId) {
-            this.displayConversation(event.conversationId);
+        console.log('[STATE SYNC] Session updated via WebSocket:', event.status, '- real-time push');
+        // Session completed - agent response arrived via WebSocket push (no polling!)
+        if (this.currentConversation === event.conversationId && event.message) {
+          console.log('[STATE SYNC] Adding assistant message to display immediately (real-time push)');
+          // Stop polling immediately
+          this.stopPollingMessages();
+          // Add message directly to display
+          this.addMessageToDisplay(event.message);
+          // Update conversation metadata
+          this.fetchConversations().then(() => this.renderChatHistory());
+          // Auto-scroll to new message
+          if (this.settings.autoScroll) {
+            setTimeout(() => {
+              const div = document.getElementById('chatMessages');
+              if (div) div.scrollTop = div.scrollHeight;
+            }, 50);
           }
-        });
+        } else {
+          // Not viewing this conversation, just update timestamps
+          this.fetchConversations().then(() => this.renderChatHistory());
+        }
         if (!fromBroadcast && this.broadcastChannel) {
           this.broadcastChannel.postMessage(event);
         }
@@ -1350,56 +1372,20 @@ class GMGUIApp {
     this.addMessageToDisplay({ role: 'system', content: text });
   }
 
-  startPollingMessages(conversationId) {
-    if (this.pollingInterval) clearInterval(this.pollingInterval);
-
-    let pollCount = 0;
-    const maxNoResponsePolls = 60;
-    let lastKnownIds = new Set(
-      Array.from(document.querySelectorAll('#chatMessages [data-message-id]'))
-        .map(el => el.dataset.messageId)
-        .filter(id => id && !id.startsWith('pending-'))
-    );
-
-    this.pollingInterval = setInterval(async () => {
-      try {
-        const res = await this.apiFetch(`${BASE_URL}/api/conversations/${conversationId}/messages`);
-        const data = await res.json();
-        const messages = data.messages || [];
-
-        let added = false;
-        messages.forEach(msg => {
-          if (msg.id && !lastKnownIds.has(msg.id)) {
-            const existingEl = document.querySelector(`[data-message-id="${msg.id}"]`);
-            if (!existingEl) {
-              this.addMessageToDisplay(msg);
-              added = true;
-            }
-            lastKnownIds.add(msg.id);
-          }
-        });
-        if (added) {
-          pollCount = 0;
-
-          if (this.settings.autoScroll) {
-            const div = document.getElementById('chatMessages');
-            if (div) div.scrollTop = div.scrollHeight;
-          }
-        } else {
-          pollCount++;
-        }
+  stopPollingMessages() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+      console.log('[POLLING] Polling stopped - using WebSocket push instead');
+    }
+  }
 
-        // Stop polling if no changes for a while
-        if (pollCount > maxNoResponsePolls) {
-          clearInterval(this.pollingInterval);
-          this.pollingInterval = null;
-        }
-      } catch (e) {
-        console.error('Polling error:', e);
-        clearInterval(this.pollingInterval);
-        this.pollingInterval = null;
-      }
-    }, 500); // Poll every 500ms
+  startPollingMessages(conversationId) {
+    // DEPRECATED: Polling mechanism replaced with WebSocket push
+    // This method is kept for backwards compatibility but does nothing
+    // Messages now arrive via WebSocket in real-time via handleSyncEvent
+    console.log('[POLLING] Polling requested but disabled - WebSocket handles real-time updates');
+    this.stopPollingMessages();
   }
 
   createThoughtBlock() {