agentgui 1.0.396 → 1.0.398

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.396",
+  "version": "1.0.398",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -17,7 +17,8 @@
   "homepage": "https://github.com/AnEntrypoint/agentgui#readme",
   "scripts": {
     "start": "node server.js",
-    "dev": "node server.js --watch"
+    "dev": "node server.js --watch",
+    "postinstall": "node scripts/patch-fsbrowse.js"
   },
   "dependencies": {
     "@anthropic-ai/claude-code": "^2.1.37",

package/scripts/patch-fsbrowse.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Patch script to fix Windows path duplication issue in fsbrowse
+ * Fixes: Error ENOENT: no such file or directory, scandir 'C:\C:\dev'
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const fsbrowsePath = path.join(__dirname, '..', 'node_modules', 'fsbrowse', 'index.js');
+
+if (!fs.existsSync(fsbrowsePath)) {
+  console.warn('[PATCH] fsbrowse not found, skipping patch');
+  process.exit(0);
+}
+
+try {
+  let content = fs.readFileSync(fsbrowsePath, 'utf8');
+
+  // Check if patch is already applied
+  if (content.includes('sanitizedIsAbsoluteOnDrive')) {
+    console.log('[PATCH] fsbrowse Windows path fix already applied');
+    process.exit(0);
+  }
+
+  // Replace the makeResolver function with the fixed version
+  const oldMakeResolver = `function makeResolver(baseDir) {
+  return function resolveWithBaseDir(relPath) {
+    const sanitized = sanitizePath(relPath);
+    const fullPath = path.resolve(baseDir, sanitized);
+    if (!fullPath.startsWith(baseDir)) {
+      return { ok: false, error: 'EPATHINJECTION' };
+    }
+    return { ok: true, path: fullPath };
+  };
+}`;
+
+  const newMakeResolver = `function makeResolver(baseDir) {
+  const normalizedBase = path.normalize(baseDir);
+  const baseDriveLetter = normalizedBase.match(/^[A-Z]:/i)?.[0];
+
+  return function resolveWithBaseDir(relPath) {
+    const sanitized = sanitizePath(relPath);
+    let fullPath;
+
+    // Extract drive letter from both paths to check for same-drive duplication on Windows
+    const sanitizedDriveLetter = sanitized.match(/^[A-Z]:/i)?.[0];
+    const sanitizedIsAbsoluteOnDrive = /^[A-Z]:/i.test(sanitized);
+
+    // If both paths are on the same Windows drive, strip the drive letter from relPath
+    // to avoid duplication like C:\\C:\\dev
+    if (baseDriveLetter && sanitizedIsAbsoluteOnDrive && sanitizedDriveLetter === baseDriveLetter) {
+      // Remove drive letter and leading slashes to make it relative
+      const relativePath = sanitized.replace(/^[A-Z]:[\/\\]?/i, '');
+      fullPath = path.resolve(normalizedBase, relativePath);
+    } else {
+      fullPath = path.resolve(normalizedBase, sanitized);
+    }
+
+    // Normalize for consistent comparison
+    const normalizedFullPath = path.normalize(fullPath);
+    const normalizedComparisonBase = path.normalize(normalizedBase);
+
+    // Check path injection - convert backslashes to forward slashes for comparison
+    const normalizedCheck = normalizedFullPath.replace(/\\\\/g, '/');
+    const normalizedBaseCheck = normalizedComparisonBase.replace(/\\\\/g, '/');
+
+    if (!normalizedCheck.startsWith(normalizedBaseCheck)) {
+      return { ok: false, error: 'EPATHINJECTION' };
+    }
+    return { ok: true, path: normalizedFullPath };
+  };
+}`;
+
+  if (content.includes(oldMakeResolver)) {
+    content = content.replace(oldMakeResolver, newMakeResolver);
+    fs.writeFileSync(fsbrowsePath, content, 'utf8');
+    console.log('[PATCH] fsbrowse Windows path fix applied successfully');
+  } else {
+    console.warn('[PATCH] Could not find makeResolver function to patch');
+  }
+} catch (err) {
+  console.error('[PATCH] Error applying fsbrowse patch:', err.message);
+  process.exit(1);
+}

package/server.js

@@ -295,8 +295,10 @@ expressApp.use(BASE_URL + '/files/:conversationId', (req, res, next) => {
   if (!conv || !conv.workingDirectory) {
     return res.status(404).json({ error: 'Conversation not found or no working directory' });
   }
+  // Normalize the working directory path to avoid Windows path duplication issues
+  const normalizedWorkingDir = path.resolve(conv.workingDirectory);
   // Create a fresh fsbrowse router for this conversation's directory
-  const router = fsbrowse({ baseDir: conv.workingDirectory, name: 'Files' });
+  const router = fsbrowse({ baseDir: normalizedWorkingDir, name: 'Files' });
   // Strip the conversationId param from the path before passing to fsbrowse
   req.baseUrl = BASE_URL + '/files/' + req.params.conversationId;
   router(req, res, next);
@@ -1073,7 +1075,9 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly === '/api/conversations' && req.method === 'POST') {
       const body = await parseBody(req);
-      const conversation = queries.createConversation(body.agentId, body.title, body.workingDirectory || null, body.model || null);
+      // Normalize working directory to avoid Windows path issues
+      const normalizedWorkingDir = body.workingDirectory ? path.resolve(body.workingDirectory) : null;
+      const conversation = queries.createConversation(body.agentId, body.title, normalizedWorkingDir, body.model || null);
       queries.createEvent('conversation.created', { agentId: body.agentId, workingDirectory: conversation.workingDirectory, model: conversation.model }, conversation.id);
       broadcastSync({ type: 'conversation_created', conversation });
             sendJSON(req, res, 201, { conversation });
@@ -1099,6 +1103,10 @@ const server = http.createServer(async (req, res) => {
 
       if (req.method === 'POST' || req.method === 'PUT') {
         const body = await parseBody(req);
+        // Normalize working directory if present to avoid Windows path issues
+        if (body.workingDirectory) {
+          body.workingDirectory = path.resolve(body.workingDirectory);
+        }
         const conv = queries.updateConversation(convMatch[1], body);
         if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
         queries.createEvent('conversation.updated', body, convMatch[1]);

package/static/js/conversations.js

@@ -420,8 +420,10 @@ class ConversationManager {
     const isStreaming = this.streamingConversations.has(conv.id);
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';
+    const agent = this.getAgentDisplayName(conv.agentId || conv.agentType);
+    const modelLabel = conv.model ? ` (${conv.model})` : '';
     const wd = conv.workingDirectory ? pathBasename(conv.workingDirectory) : '';
-    const metaParts = [timestamp];
+    const metaParts = [agent + modelLabel, timestamp];
     if (wd) metaParts.push(wd);
 
     const titleEl = el.querySelector('.conversation-item-title');
@@ -446,8 +448,10 @@ class ConversationManager {
 
     const title = conv.title || `Conversation ${conv.id.slice(0, 8)}`;
     const timestamp = conv.created_at ? new Date(conv.created_at).toLocaleDateString() : 'Unknown';
-    const wd = conv.workingDirectory ? conv.workingDirectory.split('/').pop() : '';
-    const metaParts = [timestamp];
+    const agent = this.getAgentDisplayName(conv.agentId || conv.agentType);
+    const modelLabel = conv.model ? ` (${conv.model})` : '';
+    const wd = conv.workingDirectory ? pathBasename(conv.workingDirectory) : '';
+    const metaParts = [agent + modelLabel, timestamp];
     if (wd) metaParts.push(wd);
 
     const streamingBadge = isStreaming

package/test-wave4-ui.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * Wave 4 UI Consistency Test
+ * Tests agent/model persistence and display consolidation
+ */
+
+import http from 'http';
+
+const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
+const API_BASE = `${BASE_URL}/gm/api`;
+
+function request(method, path, body = null) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, API_BASE);
+    const options = {
+      method,
+      headers: body ? { 'Content-Type': 'application/json' } : {}
+    };
+
+    const req = http.request(url, options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: data ? JSON.parse(data) : null });
+        } catch (e) {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+async function test() {
+  console.log('=== Wave 4 UI Consistency Tests ===\n');
+
+  try {
+    // Test 1: Create conversation with specific agent and model
+    console.log('Test 1: Create conversation with agent and model');
+    const createRes = await request('POST', '/conversations', {
+      agentId: 'claude-code',
+      title: 'Wave 4 Test Conversation',
+      workingDirectory: '/tmp/test',
+      model: 'claude-sonnet-4-5'
+    });
+
+    if (createRes.status !== 200) {
+      console.error('❌ Failed to create conversation:', createRes.status);
+      return;
+    }
+
+    const conversation = createRes.data.conversation;
+    console.log('✓ Created conversation:', conversation.id);
+    console.log('  - agentId:', conversation.agentId);
+    console.log('  - model:', conversation.model);
+
+    // Test 2: Fetch conversation and verify agent/model are returned
+    console.log('\nTest 2: Fetch conversation via /full endpoint');
+    const fullRes = await request('GET', `/conversations/${conversation.id}/full`);
+
+    if (fullRes.status !== 200) {
+      console.error('❌ Failed to fetch conversation:', fullRes.status);
+      return;
+    }
+
+    const fullConv = fullRes.data.conversation;
+    console.log('✓ Fetched conversation');
+    console.log('  - agentId:', fullConv.agentId);
+    console.log('  - agentType:', fullConv.agentType);
+    console.log('  - model:', fullConv.model);
+
+    if (!fullConv.agentId && !fullConv.agentType) {
+      console.error('❌ agentId/agentType missing from response');
+    } else {
+      console.log('✓ agentId/agentType present');
+    }
+
+    if (!fullConv.model) {
+      console.error('❌ model missing from response');
+    } else {
+      console.log('✓ model present');
+    }
+
+    // Test 3: List conversations and verify agent/model in list
+    console.log('\nTest 3: List conversations');
+    const listRes = await request('GET', '/conversations');
+
+    if (listRes.status !== 200) {
+      console.error('❌ Failed to list conversations:', listRes.status);
+      return;
+    }
+
+    const listedConv = listRes.data.conversations.find(c => c.id === conversation.id);
+    if (!listedConv) {
+      console.error('❌ Conversation not found in list');
+      return;
+    }
+
+    console.log('✓ Conversation in list');
+    console.log('  - agentId:', listedConv.agentId);
+    console.log('  - agentType:', listedConv.agentType);
+    console.log('  - model:', listedConv.model);
+
+    // Test 4: Update conversation model
+    console.log('\nTest 4: Update conversation model');
+    const updateRes = await request('POST', `/conversations/${conversation.id}`, {
+      model: 'claude-opus-4-6'
+    });
+
+    if (updateRes.status !== 200) {
+      console.error('❌ Failed to update conversation:', updateRes.status);
+      return;
+    }
+
+    const updatedConv = updateRes.data.conversation;
+    console.log('✓ Updated conversation');
+    console.log('  - model:', updatedConv.model);
+
+    if (updatedConv.model !== 'claude-opus-4-6') {
+      console.error('❌ Model not updated correctly');
+    } else {
+      console.log('✓ Model updated correctly');
+    }
+
+    // Cleanup
+    console.log('\nCleanup: Deleting test conversation');
+    await request('DELETE', `/conversations/${conversation.id}`);
+    console.log('✓ Deleted test conversation');
+
+    console.log('\n=== All Tests Passed ===');
+  } catch (error) {
+    console.error('❌ Test error:', error.message);
+    process.exit(1);
+  }
+}
+
+test();