agentgui 1.0.39 → 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/package.json

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

package/AUTOMATIC_IMPORT.md

@@ -1,284 +0,0 @@
-# Automatic Continuous Importing Feature
-
-## Overview
-AgentGUI now automatically and continuously imports Claude Code conversations **without requiring any user action**. This ensures conversations are always available and up-to-date.
-
-## How It Works
-
-### Server-Side (Every 30 Seconds)
-```
-Server startup
-    ↓
-[IMMEDIATE] Import Claude Code conversations (first run)
-    ↓
-[EVERY 30 SECONDS] Auto-import new conversations
-    ↓
-If new conversations found:
-  • Add them to database
-  • Broadcast 'conversations_updated' event to all connected clients
-  • Log: "[AUTO-IMPORT] Imported X new Claude Code conversations"
-```
-
-### Frontend-Side
-```
-Page loads
-    ↓
-[IMMEDIATE] Fetch conversations from API
-    ↓
-[EVERY 10 SECONDS] Fetch conversations again (as fallback)
-    ↓
-[ON SYNC EVENT] Receive 'conversations_updated' from server
-    ↓
-Immediately refresh conversation list
-    ↓
-Users see new conversations appear in real-time
-```
-
-## Key Features
-
-✅ **Automatic**: No user action needed  
-✅ **Continuous**: Runs every 30 seconds (server) and 10 seconds (client)  
-✅ **Real-time**: New conversations appear immediately via WebSocket  
-✅ **No Duplicates**: Skips conversations already imported  
-✅ **Cross-tab**: Broadcasts via BroadcastChannel API  
-✅ **Resilient**: Fallback mechanism if WebSocket fails  
-✅ **Logging**: All imports logged for debugging  
-
-## Where Conversations Come From
-
-### Automatically Discovered From:
-1. **Claude Code Projects** (~/.claude/projects/)
-   - Scans sessions-index.json files
-   - Reads .jsonl message files
-   - Imports with "[project] title" format
-
-2. **Created in AgentGUI**
-   - New conversations created via UI
-   - Automatically stored in database
-
-## Example Flow
-
-### Scenario: User Uses Claude Code, Then Opens AgentGUI
-
-```
-11:00:00 - User creates conversation in Claude Code
-11:00:15 - AgentGUI server detects new conversation in ~/.claude/projects/
-11:00:20 - Server imports conversation automatically
-11:00:20 - Server broadcasts 'conversations_updated' event
-11:00:21 - All connected browser tabs receive update
-11:00:21 - Users see new conversation appear in sidebar
-```
-
-### Scenario: Multiple Tabs Open
-
-```
-Tab 1 opens AgentGUI
-Tab 2 opens AgentGUI (few seconds later)
-
-Tab 1 receives 'conversations_updated' from server
-Tab 1 uses BroadcastChannel to notify Tab 2
-Tab 2 also refreshes conversation list
-Both tabs show latest conversations in sync
-```
-
-## Server Logs
-
-You'll see logs like:
-```
-[AUTO-IMPORT] Imported 2 new Claude Code conversations (42 already exist)
-[AUTO-IMPORT] Imported 1 new Claude Code conversation (43 already exist)
-[AUTO-IMPORT] (nothing new this cycle)
-```
-
-## Client Logs
-
-In browser console:
-```
-[SYNC] Server imported 3 new conversations, refreshing...
-[DEBUG] Init: Auto-imported Claude Code conversations
-[DEBUG] Loaded conversations, total: 86
-```
-
-## Configuration
-
-### Import Frequency (Server)
-Current: **30 seconds**
-Location: `server.js` line `setInterval(performAutoImport, 30000);`
-
-To change:
-```javascript
-setInterval(performAutoImport, 60000); // 60 seconds
-setInterval(performAutoImport, 5000);  // 5 seconds
-```
-
-### Refresh Frequency (Client)
-Current: **10 seconds**
-Location: `app.js` line `setInterval(() => { ... }, 10000);`
-
-To change:
-```javascript
-}, 60000);  // 60 seconds
-}, 5000);   // 5 seconds
-```
-
-## Data Flow Diagram
-
-```
-┌─────────────────────────────────────────────────────┐
-│ Claude Code                                          │
-│ ~/.claude/projects/*/sessions-index.json            │
-└─────────────────┬───────────────────────────────────┘
-                  │ (monitors every 30s)
-                  ↓
-┌─────────────────────────────────────────────────────┐
-│ AgentGUI Server                                      │
-│ • queries.importClaudeCodeConversations()           │
-│ • Stores in ~/.gmgui/data.db                        │
-│ • Broadcasts via WebSocket                          │
-└──────┬──────────────────────────┬────────────────────┘
-       │                          │
-       │ (WebSocket event)        │ (HTTP API)
-       ↓                          ↓
-┌─────────────────────────────────────────────────────┐
-│ Browser (Frontend)                                   │
-│ • Listens on sync WebSocket                         │
-│ • Receives 'conversations_updated' event            │
-│ • Calls fetchConversations()                        │
-│ • Calls renderChatHistory()                         │
-└──────┬──────────────────────────────────────────────┘
-       │
-       ↓
-┌─────────────────────────────────────────────────────┐
-│ Chat Sidebar                                         │
-│ • Displays conversation list                        │
-│ • User can click to view conversation               │
-└─────────────────────────────────────────────────────┘
-```
-
-## Troubleshooting
-
-### Conversations Not Appearing
-
-**Check 1: Server Auto-Import**
-```bash
-# Look for these logs in server output
-grep "\[AUTO-IMPORT\]" server.log
-
-# If no logs, auto-import might not be running
-```
-
-**Check 2: Claude Code Availability**
-```bash
-# Check if Claude Code projects exist
-ls -la ~/.claude/projects/
-
-# Count projects with conversations
-find ~/.claude/projects -name "sessions-index.json" | wc -l
-```
-
-**Check 3: Browser Sync**
-```javascript
-// In browser console
-// Check if WebSocket is connected
-console.log('WebSocket state:', app.syncWs.ws?.readyState);
-
-// Try manual refresh
-await app.fetchConversations();
-app.renderChatHistory();
-```
-
-**Check 4: Database**
-```bash
-# Check total conversations in DB
-node -e "
-const DB = require('better-sqlite3');
-const db = new DB(process.env.HOME + '/.gmgui/data.db');
-const count = db.prepare('SELECT COUNT(*) as c FROM conversations').get();
-console.log('Database has:', count.c, 'conversations');
-db.close();
-"
-```
-
-### Too Many Import Logs
-
-If server logs are too verbose:
-1. Increase `setInterval` time (30000 → 60000 or more)
-2. Add log level filtering
-
-### Conversations Take Too Long to Appear
-
-If new conversations take > 1 minute:
-1. Check server auto-import interval (default 30s)
-2. Check client refresh interval (default 10s)
-3. Check network connectivity
-4. Check browser console for errors
-
-## Performance Considerations
-
-### Import Impact
-- **Minimal**: Import skips existing conversations
-- **Fast**: Only processes new conversations
-- **Efficient**: Uses database transactions
-
-### Client Impact
-- **WebSocket**: Real-time updates, low bandwidth
-- **Polling**: Every 10 seconds, minimal traffic
-- **Rendering**: Only updates when conversations change
-
-## Security Notes
-
-- Only imports from user's local `.claude/projects/`
-- No external network access needed
-- All conversations stored locally
-- Respects filesystem permissions
-
-## Future Enhancements
-
-Potential improvements:
-- Configurable import interval via UI
-- Import from multiple sources
-- Batch import optimization
-- Import history/logs viewer
-- Import statistics dashboard
-- Per-project import settings
-
-## Testing
-
-### Manual Test: Add Claude Code Conversation
-```bash
-# 1. Use Claude Code (creates ~/.claude/projects/*/sessions-index.json)
-# 2. Wait up to 30 seconds
-# 3. Check browser - should see new conversation appear
-# 4. Confirm console logs show "[AUTO-IMPORT] Imported X..."
-```
-
-### Manual Test: Force Import
-```javascript
-// In browser console
-await fetch('/gm/api/import/claude-code')
-  .then(r => r.json())
-  .then(d => console.log('Manual import result:', d));
-
-// Then refresh
-await app.fetchConversations();
-app.renderChatHistory();
-```
-
-## Related Files
-
-- `server.js` - Server auto-import implementation
-- `app.js` - Frontend sync handling
-- `database.js` - Query functions
-- `acp-launcher.js` - Claude Code connection
-
-## Changelog
-
-### Version 1.1.0 (Current)
-- ✅ Added automatic server-side importing every 30 seconds
-- ✅ Added WebSocket broadcast for instant updates
-- ✅ Added client-side sync event handler
-- ✅ Integrated with existing periodic sync
-
-### Version 1.0.0 (Previous)
-- Manual import on demand via `/api/import/claude-code`
-- No automatic background importing

package/CONVERSATION_DISPLAY_FIX.md

@@ -1,125 +0,0 @@
-# Conversation Display Issue
-
-## Problem
-Imported Claude Code conversations are not visible in the UI when opening the application, even though they exist in the database (83 conversations found).
-
-## Root Cause Analysis
-
-Possible issues:
-1. **Conversations not loading on page load** - fetchConversations() may fail silently
-2. **Rendering issue** - chatList element may not be rendering properly
-3. **CSS hiding** - Conversations may be present but hidden (display:none, opacity:0)
-4. **Empty state** - renderChatHistory() shows "No chats yet" because this.conversations is empty
-5. **Filter/agent selection** - Conversations filtered by agent selection not matching
-
-## Investigation Steps
-
-### Check 1: Network Request
-- Open browser DevTools (F12)
-- Network tab: Look for `/api/conversations` request
-- Should return 83 conversations with agent IDs
-
-### Check 2: Console Errors
-- Console tab: Look for any JavaScript errors
-- Look for "fetchConversations:" logs
-
-### Check 3: DOM Elements
-- Elements tab: Inspect #chatList
-- Check if it has children
-- Check CSS display property (should be visible)
-
-### Check 4: Data Binding
-- Console: `app.conversations.size` - should show 83
-- Console: `app.conversations` - should contain conversation objects
-
-## Solution Areas
-
-### Frontend (static/app.js)
-
-1. **Add logging to fetchConversations()**
-   - Log when fetch starts/completes
-   - Log number of conversations received
-   - Log any errors
-
-2. **Add logging to renderChatHistory()**
-   - Log conversations.size
-   - Log if condition triggers "No chats yet"
-
-3. **Force initial render**
-   - Ensure renderChatHistory() is called after fetchConversations()
-   - Add retry logic if conversations empty on first load
-
-### Server (server.js)
-
-1. **Verify /api/conversations endpoint**
-   - Check it returns all conversations
-   - Verify no filtering happening
-   - Check response format
-
-2. **Verify import endpoint**
-   - Check /api/import/claude-code works
-   - Ensure conversations are created with proper agentId
-
-## Implementation
-
-Add debug logging to identify where conversations are lost:
-
-```javascript
-async fetchConversations() {
-  try {
-    const res = await fetch(BASE_URL + '/api/conversations');
-    const data = await res.json();
-    console.log('fetchConversations response:', data);
-    console.log('Conversations count:', data.conversations?.length);
-    
-    if (data.conversations) {
-      this.conversations.clear();
-      data.conversations.forEach(c => {
-        console.log('Adding conversation:', c.id, c.title);
-        this.conversations.set(c.id, c);
-      });
-      console.log('Final conversations.size:', this.conversations.size);
-    }
-  } catch (e) {
-    console.error('fetchConversations error:', e);
-  }
-}
-
-renderChatHistory() {
-  const list = document.getElementById('chatList');
-  if (!list) {
-    console.error('chatList element not found!');
-    return;
-  }
-  
-  console.log('renderChatHistory - conversations.size:', this.conversations.size);
-  
-  if (this.conversations.size === 0) {
-    console.warn('No conversations to display');
-    list.innerHTML = '<p>No chats yet</p>';
-    return;
-  }
-  
-  // ... rest of rendering
-}
-```
-
-## Expected Behavior
-
-1. Page loads
-2. fetchConversations() retrieves 83 conversations from API
-3. conversations Map populated with all 83 items
-4. renderChatHistory() iterates over conversations
-5. Chat list displays 83 conversation items
-6. User can click to view any conversation
-
-## Testing
-
-```bash
-# Verify conversations in database
-curl http://localhost:9897/gm/api/conversations | python3 -m json.tool | grep -c '"id"'
-
-# Verify a conversation has messages (pick one)
-curl http://localhost:9897/gm/api/conversations/CONV_ID/messages
-```
-

package/DEBUG_GUIDE.md

@@ -1,136 +0,0 @@
-# Debug Guide - Conversation Display Issue
-
-## Problem
-Imported Claude Code conversations (83 total) are not visible in the chat list when the application loads, despite being stored in the database and returned by the API.
-
-## API Status - ✅ VERIFIED
-- Server is running on `http://localhost:9897`
-- API endpoint `/api/conversations` returns 83 conversations
-- Response structure is correct with proper ID, agentId, title, created_at, updated_at, status fields
-
-## Debug Logging Added
-We've added comprehensive debug logging to trace the initialization flow. The logging will help identify where conversations are being lost.
-
-### Enhanced Logging Points:
-1. **Init sequence** - Logs each step of initialization
-2. **fetchConversations** - Logs API request, response status, data received
-3. **renderAll** - Logs conversation count before rendering
-4. **renderChatHistory** - Logs final conversation count and whether empty state is shown
-
-## How to Debug
-
-### Step 1: Open the Application
-1. Open your web browser
-2. Navigate to: `http://localhost:9897/gm/`
-3. Press **F12** to open Developer Tools
-4. Go to the **Console** tab
-
-### Step 2: Look for Debug Logs
-Watch for logs starting with `[DEBUG]`. You should see:
-
-```
-[DEBUG] Init: Starting initialization
-[DEBUG] Init: Fetched home
-[DEBUG] Init: Fetched agents, count: X
-[DEBUG] Init: Auto-imported Claude Code conversations
-[DEBUG] fetchConversations: Starting fetch from http://localhost:9897/gm/api/conversations
-[DEBUG] fetchConversations: Response status: 200
-[DEBUG] fetchConversations response count: 83
-[DEBUG] fetchConversations response data: {...}
-[DEBUG] fetchConversations: Cleared conversations map
-[DEBUG] Loaded conversations, total: 83
-[DEBUG] First few conversation IDs: [...]
-[DEBUG] Init: Fetched conversations, count: 83
-[DEBUG] Init: About to renderAll with 83 conversations
-[DEBUG] renderAll: Called with 83 conversations
-[DEBUG] renderChatHistory - conversations.size: 83
-[DEBUG] renderChatHistory - sorted conversations count: 83
-[DEBUG] Init: renderAll completed
-```
-
-### Step 3: Analyze the Logs
-
-Check these specific values:
-
-| Log | Expected | Issue If Different |
-|-----|----------|-------------------|
-| `response count: 83` | 83 | API not returning conversations |
-| `Loaded conversations, total: 83` | 83 | Data not being added to map |
-| `About to renderAll with 83 conversations` | 83 | Conversations lost between fetch and render |
-| `renderChatHistory - conversations.size: 83` | 83 | Size changes between renderAll and renderChatHistory |
-| `No conversations to display - showing empty state` | Should NOT appear | renderChatHistory shows empty when size > 0 |
-
-### Step 4: Check Browser State
-In the Console, type:
-```javascript
-// Check if conversations were loaded into the app
-app.conversations.size
-
-// Check the actual conversations
-app.conversations
-
-// Check first conversation
-Array.from(app.conversations.values())[0]
-
-// Check if BASE_URL is correct
-BASE_URL
-```
-
-### Step 5: Check Network Tab
-1. Go to **Network** tab in DevTools
-2. Filter for `/api/conversations` request
-3. Check:
-   - Request Status: Should be 200
-   - Response body: Should contain array of 83 conversations
-   - Response headers: Should show correct content-type
-
-## Possible Issues and Solutions
-
-### Issue 1: API returns 0 conversations
-**Symptom**: `response count: 0`
-- Check: Is the database populated?
-- Command: `sqlite3 /config/workspace/agentgui/data/gmgui.db "SELECT COUNT(*) FROM conversations;"`
-- Fix: Import conversations or check database connection
-
-### Issue 2: API returns data but conversations.size is 0
-**Symptom**: `response count: 83` but `Loaded conversations, total: 0`
-- Likely cause: Data structure mismatch or forEach not working
-- Fix: Check if data.conversations is an array
-- Check: Are the conversation objects being created properly?
-
-### Issue 3: Conversations loaded but renderChatHistory shows empty
-**Symptom**: `About to renderAll with 83 conversations` but `No conversations to display`
-- Likely cause: Something clears conversations.map between renderAll and renderChatHistory
-- Check: Look for any handleSyncEvent calls that might clear or reset conversations
-- Fix: Add logging to sync event handlers
-
-### Issue 4: Conversations load but don't display in UI
-**Symptom**: All debug logs show 83 conversations, but chat list still shows "No chats yet"
-- Likely cause: CSS hiding, DOM structure issue, or rendering issue
-- Check: Look at HTML element with id="chatList" - is it hidden?
-- Check: Are chat items being created in the DOM?
-- Solution: Open Elements tab and expand chatList to see if items exist
-
-## Next Steps After Debugging
-
-1. **Identify the root cause** using the logs above
-2. **Document which log shows the problem**
-3. **Implement the appropriate fix**:
-   - If API issue: Fix server endpoint
-   - If data structure issue: Fix response parsing
-   - If sync issue: Fix sync event handlers
-   - If UI issue: Fix CSS or rendering logic
-4. **Verify fix** with the debug logs
-5. **Commit changes** to git
-
-## File Locations
-- Frontend code: `/config/workspace/agentgui/static/app.js`
-- Server code: `/config/workspace/agentgui/server.js`
-- Database: `/config/workspace/agentgui/data/gmgui.db`
-- API responses return from: `/api/conversations` endpoint in server.js
-
-## Important Notes
-- Hot reload is enabled for CSS/HTML/frontend JS
-- Debug logs will auto-reload in browser when app.js changes
-- Check DevTools console IMMEDIATELY after loading the page
-- Some logs may scroll off - use DevTools console filter to search for `[DEBUG]`