agentgui 1.0.109 → 1.0.111

package/static/js/client.js

@@ -155,11 +155,15 @@ class AgentGUIClient {
 
   /**
    * Router state management: restore conversation from URL
-   * Format: ?conversation=<id>&session=<id>
+   * Format: /conversations/<conversationId>?session=<sessionId>
    */
   restoreStateFromUrl() {
+    // Parse path-based URL: /conversations/<conversationId>
+    const pathMatch = window.location.pathname.match(/\/conversations\/([^\/]+)$/);
+    const conversationId = pathMatch ? pathMatch[1] : null;
+    
+    // Session ID still in query params
     const params = new URLSearchParams(window.location.search);
-    const conversationId = params.get('conversation');
     const sessionId = params.get('session');
 
     if (conversationId && this.isValidId(conversationId)) {
@@ -184,6 +188,7 @@ class AgentGUIClient {
   /**
    * Update URL when conversation is selected
    * Uses History API (pushState) for clean URLs
+   * Format: /conversations/<conversationId>?session=<sessionId>
    */
   updateUrlForConversation(conversationId, sessionId) {
     if (!this.isValidId(conversationId)) return;
@@ -193,13 +198,15 @@ class AgentGUIClient {
       this.routerState.currentSessionId = sessionId;
     }
 
-    const params = new URLSearchParams();
-    params.set('conversation', conversationId);
+    // Use path-based URL for conversation
+    const basePath = window.location.pathname.replace(/\/conversations\/[^\/]+$/, '').replace(/\/$/, '');
+    let url = `${basePath}/conversations/${conversationId}`;
+    
+    // Session ID still in query params for optional state
     if (sessionId && this.isValidId(sessionId)) {
-      params.set('session', sessionId);
+      url += `?session=${sessionId}`;
     }
-
-    const url = `${window.location.pathname}?${params.toString()}`;
+    
     window.history.pushState({ conversationId, sessionId }, '', url);
   }
 

package/static/js/conversations.js

@@ -233,14 +233,53 @@ class ConversationManager {
     if (wd) metaParts.push(wd);
 
     li.innerHTML = `
-      <div class="conversation-item-title">${this.escapeHtml(title)}</div>
-      <div class="conversation-item-meta">${metaParts.join(' \u2022 ')}</div>
+      <div class="conversation-item-content">
+        <div class="conversation-item-title">${this.escapeHtml(title)}</div>
+        <div class="conversation-item-meta">${metaParts.join(' • ')}</div>
+      </div>
+      <button class="conversation-item-delete" title="Delete conversation" data-delete-conv="${conv.id}">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <polyline points="3 6 5 6 21 6"></polyline>
+          <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path>
+        </svg>
+      </button>
     `;
 
+    // Handle delete button click
+    const deleteBtn = li.querySelector('[data-delete-conv]');
+    deleteBtn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      this.confirmDelete(conv.id, title);
+    });
+
     li.addEventListener('click', () => this.select(conv.id));
     return li;
   }
 
+  async confirmDelete(convId, title) {
+    const confirmed = confirm(`Delete conversation "${title || 'Untitled'}"?\n\nThis will also delete any associated Claude Code session data. This action cannot be undone.`);
+    if (!confirmed) return;
+
+    try {
+      const res = await fetch((window.__BASE_URL || '') + `/api/conversations/${convId}`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' }
+      });
+
+      if (res.ok) {
+        console.log(`[ConversationManager] Deleted conversation ${convId}`);
+        // Remove from local list immediately for responsive UI
+        this.deleteConversation(convId);
+      } else {
+        const error = await res.json().catch(() => ({ error: 'Failed to delete' }));
+        alert('Failed to delete conversation: ' + (error.error || 'Unknown error'));
+      }
+    } catch (err) {
+      console.error('[ConversationManager] Delete error:', err);
+      alert('Failed to delete conversation: ' + err.message);
+    }
+  }
+
   select(convId) {
     this.activeId = convId;
 

package/conversation-importer.js

@@ -1,63 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { queries } from './database.js';
-
-export class ConversationImporter {
-  static async importClaudeCodeSessions() {
-    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-    if (!fs.existsSync(projectsDir)) return [];
-
-    const imported = [];
-    const projects = fs.readdirSync(projectsDir);
-
-    for (const projectName of projects) {
-      const indexPath = path.join(projectsDir, projectName, 'sessions-index.json');
-      if (!fs.existsSync(indexPath)) continue;
-
-      try {
-        const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-        const entries = index.entries || [];
-
-        for (const entry of entries) {
-          try {
-            const existing = queries.getConversationByExternalId('claude-code', entry.sessionId);
-            if (existing) continue;
-
-            const conversation = {
-              externalId: entry.sessionId,
-              agentType: 'claude-code',
-              title: entry.summary || entry.firstPrompt || `Conversation ${entry.sessionId.slice(0, 8)}`,
-              firstPrompt: entry.firstPrompt,
-              messageCount: entry.messageCount || 0,
-              created: new Date(entry.created).getTime(),
-              modified: new Date(entry.modified).getTime(),
-              projectPath: entry.projectPath,
-              gitBranch: entry.gitBranch,
-              sourcePath: entry.fullPath,
-              source: 'imported'
-            };
-
-            queries.createImportedConversation(conversation);
-            imported.push(conversation);
-          } catch (err) {
-            console.error(`[Importer] Error importing session ${entry.sessionId}:`, err.message);
-          }
-        }
-      } catch (err) {
-        console.error(`[Importer] Error reading ${indexPath}:`, err.message);
-      }
-    }
-
-    return imported;
-  }
-
-  static async importAll() {
-    console.log('[Importer] Starting conversation import...');
-    const claudeCode = await this.importClaudeCodeSessions();
-    console.log(`[Importer] Imported ${claudeCode.length} Claude Code conversations`);
-    return claudeCode;
-  }
-}
-
-export default ConversationImporter;

package/hot-reload-manager.js

@@ -1,186 +0,0 @@
-/**
- * Hot Reload Manager
- * Enables live reloading of client code and graceful server restarts without losing connections
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export class HotReloadManager {
-  constructor(staticDir, options = {}) {
-    this.staticDir = staticDir;
-    this.watchedFiles = new Map();
-    this.hotReloadClients = [];
-    this.debounceTimers = new Map();
-    this.debounceDelay = options.debounceDelay || 300;
-    this.enabled = options.enabled !== false;
-  }
-
-  /**
-   * Start watching files for changes
-   */
-  start() {
-    if (!this.enabled) return;
-    
-    try {
-      this.watchDirectory(this.staticDir);
-      console.log('[HotReload] Watching for changes:', this.staticDir);
-    } catch (e) {
-      console.error('[HotReload] Failed to start:', e.message);
-    }
-  }
-
-  /**
-   * Watch directory recursively
-   */
-  watchDirectory(dir) {
-    try {
-      const files = fs.readdirSync(dir, { withFileTypes: true });
-      
-      for (const file of files) {
-        const fullPath = path.join(dir, file.name);
-        
-        if (file.isDirectory()) {
-          this.watchDirectory(fullPath);
-        } else {
-          this.watchFile(fullPath);
-        }
-      }
-    } catch (e) {
-      console.error('[HotReload] Error watching directory:', e.message);
-    }
-  }
-
-  /**
-   * Watch individual file for changes
-   */
-  watchFile(filePath) {
-    if (this.watchedFiles.has(filePath)) return;
-
-    try {
-      fs.watchFile(filePath, { interval: 100 }, (curr, prev) => {
-        if (curr.mtime > prev.mtime) {
-          this.onFileChanged(filePath);
-        }
-      });
-
-      this.watchedFiles.set(filePath, true);
-    } catch (e) {
-      console.error('[HotReload] Error watching file:', e.message);
-    }
-  }
-
-  /**
-   * Handle file change with debouncing
-   */
-  onFileChanged(filePath) {
-    // Clear existing timer for this file
-    if (this.debounceTimers.has(filePath)) {
-      clearTimeout(this.debounceTimers.get(filePath));
-    }
-
-    // Set new debounced timer
-    const timer = setTimeout(() => {
-      this.debounceTimers.delete(filePath);
-      const relPath = path.relative(this.staticDir, filePath);
-      
-      console.log(`[HotReload] File changed: ${relPath}`);
-      this.broadcastReload();
-    }, this.debounceDelay);
-
-    this.debounceTimers.set(filePath, timer);
-  }
-
-  /**
-   * Register a WebSocket client for hot reload
-   */
-  registerClient(ws) {
-    if (!this.enabled) return;
-    this.hotReloadClients.push(ws);
-    
-    ws.on('close', () => {
-      const idx = this.hotReloadClients.indexOf(ws);
-      if (idx > -1) this.hotReloadClients.splice(idx, 1);
-    });
-  }
-
-  /**
-   * Broadcast reload signal to all connected clients
-   */
-  broadcastReload() {
-    const message = JSON.stringify({ type: 'reload', timestamp: Date.now() });
-    
-    for (const ws of this.hotReloadClients) {
-      if (ws.readyState === 1) { // WebSocket.OPEN
-        try {
-          ws.send(message);
-        } catch (e) {
-          // Client may have disconnected
-        }
-      }
-    }
-  }
-
-  /**
-   * Cleanup watchers
-   */
-  stop() {
-    for (const filePath of this.watchedFiles.keys()) {
-      try {
-        fs.unwatchFile(filePath);
-      } catch (e) {}
-    }
-    
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    
-    this.watchedFiles.clear();
-    this.debounceTimers.clear();
-    this.hotReloadClients = [];
-  }
-
-  /**
-   * Get HTML snippet to inject for hot reload
-   */
-  getClientScript(baseUrl = '') {
-    if (!this.enabled) return '';
-
-    return `
-<script>
-(function() {
-  const baseUrl = '${baseUrl}';
-  const ws = new WebSocket((location.protocol === 'https:' ? 'wss:' : 'ws:') + '//' + location.host + baseUrl + '/hot-reload');
-  
-  ws.onmessage = function(event) {
-    try {
-      const data = JSON.parse(event.data);
-      if (data.type === 'reload') {
-        console.log('[HotReload] Reloading page...');
-        location.reload();
-      }
-    } catch (e) {
-      console.error('[HotReload] Error parsing message:', e);
-    }
-  };
-  
-  ws.onerror = function(e) {
-    console.log('[HotReload] WebSocket error:', e);
-  };
-  
-  ws.onclose = function() {
-    console.log('[HotReload] Connection closed, will attempt to reconnect...');
-    setTimeout(function() {
-      location.reload();
-    }, 2000);
-  };
-})();
-</script>
-    `;
-  }
-}
-
-export default HotReloadManager;