claude-mpm 4.24.0__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/dashboard/static/js/components/working-directory.js

@@ -177,7 +177,7 @@ class WorkingDirectoryManager {
         console.log('[WORKING-DIR-DEBUG] setWorkingDirectory called with:', this.repr(dir));
 
         this.currentWorkingDir = dir;
-        
+
         // Store in session storage for persistence during the session
         if (dir && this.validateDirectoryPath(dir)) {
             sessionStorage.setItem('currentWorkingDirectory', dir);
@@ -316,13 +316,13 @@ class WorkingDirectoryManager {
      */
     getDefaultWorkingDir() {
         console.log('[WORKING-DIR-DEBUG] getDefaultWorkingDir called');
-        
+
         // Try to get from the current working directory if set
         if (this.currentWorkingDir && this.validateDirectoryPath(this.currentWorkingDir)) {
             console.log('[WORKING-DIR-DEBUG] Using current working directory:', this.currentWorkingDir);
             return this.currentWorkingDir;
         }
-        
+
         // Try to get from header display
         const headerWorkingDir = document.querySelector('.working-dir-text');
         if (headerWorkingDir?.textContent?.trim()) {
@@ -367,11 +367,11 @@ class WorkingDirectoryManager {
             const eventsWithDir = window.socketClient.events
                 .filter(e => e.data && (e.data.working_directory || e.data.cwd || e.data.working_dir))
                 .reverse();
-            
+
             if (eventsWithDir.length > 0) {
                 const recentEvent = eventsWithDir[0];
-                const dir = recentEvent.data.working_directory || 
-                           recentEvent.data.cwd || 
+                const dir = recentEvent.data.working_directory ||
+                           recentEvent.data.cwd ||
                            recentEvent.data.working_dir;
                 console.log('[WORKING-DIR-DEBUG] Using working directory from recent event:', dir);
                 return dir;
@@ -393,7 +393,7 @@ class WorkingDirectoryManager {
             console.log('[WORKING-DIR-DEBUG] Using session storage working directory:', this.repr(sessionWorkingDir));
             return sessionWorkingDir;
         }
-        
+
         // Try to get the current working directory from environment/process
         // This should be the directory where claude-mpm was started from
         const processWorkingDir = window.processWorkingDirectory || process?.cwd?.() || null;
@@ -401,7 +401,7 @@ class WorkingDirectoryManager {
             console.log('[WORKING-DIR-DEBUG] Using process working directory:', this.repr(processWorkingDir));
             return processWorkingDir;
         }
-        
+
         // Final fallback - use current working directory if available, otherwise home directory
         // Never default to root "/" as it's not a useful default for code viewing
         const homeDir = window.homeDirectory || process?.env?.HOME || process?.env?.USERPROFILE || null;

claude_mpm/dashboard/static/js/connection-manager.js

@@ -1,6 +1,6 @@
 /**
  * Enhanced Connection Manager for Dashboard
- * 
+ *
  * Provides robust connection management with:
  * - Persistent client ID across reconnections
  * - Event sequence tracking and replay
@@ -29,11 +29,11 @@ class EnhancedConnectionManager {
         this.lastPongTime = null;
         this.missedHeartbeats = 0;
         this.maxMissedHeartbeats = 3;
-        
+
         // Event buffering for offline mode
         this.eventBuffer = [];
         this.maxEventBuffer = 100;
-        
+
         // Connection metrics
         this.metrics = {
             connectTime: null,
@@ -44,16 +44,16 @@ class EnhancedConnectionManager {
             eventsAcked: 0,
             lastActivity: null
         };
-        
+
         // Status update callbacks
         this.statusCallbacks = new Set();
         this.qualityCallbacks = new Set();
-        
+
         // Initialize
         this.setupEventHandlers();
         this.startHealthMonitoring();
     }
-    
+
     /**
      * Load or generate client ID for persistent identification
      */
@@ -65,7 +65,7 @@ class EnhancedConnectionManager {
         }
         return clientId;
     }
-    
+
     /**
      * Load last received event sequence for replay
      */
@@ -73,7 +73,7 @@ class EnhancedConnectionManager {
         const sequence = localStorage.getItem('claude_mpm_last_sequence');
         return sequence ? parseInt(sequence, 10) : 0;
     }
-    
+
     /**
      * Save last received event sequence
      */
@@ -81,16 +81,16 @@ class EnhancedConnectionManager {
         this.lastSequence = sequence;
         localStorage.setItem('claude_mpm_last_sequence', sequence.toString());
     }
-    
+
     /**
      * Connect with enhanced options and authentication
      */
     connect(port = '8765') {
         const url = `http://localhost:${port}`;
-        
+
         console.log(`[ConnectionManager] Connecting to ${url} with client ID: ${this.clientId}`);
         this.updateConnectionState('connecting');
-        
+
         // Create socket with enhanced options
         this.socket = io(url, {
             auth: {
@@ -106,11 +106,11 @@ class EnhancedConnectionManager {
             pingInterval: 25000,
             pingTimeout: 20000
         });
-        
+
         this.setupSocketHandlers();
         this.socketClient.socket = this.socket;
     }
-    
+
     /**
      * Calculate exponential backoff delay for reconnection
      */
@@ -121,13 +121,13 @@ class EnhancedConnectionManager {
         );
         return delay + Math.random() * 1000; // Add jitter
     }
-    
+
     /**
      * Setup socket event handlers
      */
     setupSocketHandlers() {
         if (!this.socket) return;
-        
+
         // Connection established
         this.socket.on('connection_established', (data) => {
             console.log('[ConnectionManager] Connection established:', data);
@@ -138,60 +138,60 @@ class EnhancedConnectionManager {
             this.missedHeartbeats = 0;
             this.updateConnectionState('connected');
             this.startHeartbeat();
-            
+
             // Flush buffered events if any
             this.flushEventBuffer();
         });
-        
+
         // Event replay after reconnection
         this.socket.on('event_replay', (data) => {
             console.log(`[ConnectionManager] Replaying ${data.count} events from sequence ${data.from_sequence}`);
-            
+
             if (data.events && data.events.length > 0) {
                 data.events.forEach(event => {
                     // Update sequence
                     if (event.sequence) {
                         this.saveLastSequence(event.sequence);
                     }
-                    
+
                     // Process replayed event
                     this.socketClient.handleEvent('claude_event', event);
                 });
-                
+
                 this.showNotification(`Replayed ${data.count} missed events`, 'info');
             }
         });
-        
+
         // Normal event with sequence tracking
         this.socket.on('claude_event', (event) => {
             if (event.sequence) {
                 this.saveLastSequence(event.sequence);
-                
+
                 // Send acknowledgment
                 this.socket.emit('acknowledge_event', {
                     sequence: event.sequence
                 });
-                
+
                 this.metrics.eventsAcked++;
             }
-            
+
             this.metrics.totalEvents++;
             this.metrics.lastActivity = Date.now();
         });
-        
+
         // Heartbeat response
         this.socket.on('heartbeat_response', (data) => {
             this.missedHeartbeats = 0;
             this.updateConnectionQuality(1.0);
         });
-        
+
         // Pong response
         this.socket.on('pong', (data) => {
             this.lastPongTime = Date.now();
             const latency = this.lastPongTime - this.lastPingTime;
             this.updateLatency(latency);
         });
-        
+
         // Connection stats response
         this.socket.on('connection_stats', (data) => {
             console.log('[ConnectionManager] Connection stats:', data);
@@ -199,7 +199,7 @@ class EnhancedConnectionManager {
                 this.updateConnectionQuality(data.connection.quality);
             }
         });
-        
+
         // Standard Socket.IO events
         this.socket.on('connect', () => {
             console.log('[ConnectionManager] Socket connected');
@@ -209,13 +209,13 @@ class EnhancedConnectionManager {
                 this.metrics.totalReconnections++;
             }
         });
-        
+
         this.socket.on('disconnect', (reason) => {
             console.log('[ConnectionManager] Socket disconnected:', reason);
             this.metrics.disconnectTime = Date.now();
             this.updateConnectionState('disconnected');
             this.stopHeartbeat();
-            
+
             // Handle different disconnect reasons
             if (reason === 'io server disconnect') {
                 // Server initiated disconnect
@@ -225,11 +225,11 @@ class EnhancedConnectionManager {
                 this.showNotification('Connection timeout - attempting to reconnect', 'warning');
             }
         });
-        
+
         this.socket.on('connect_error', (error) => {
             console.error('[ConnectionManager] Connection error:', error.message);
             this.reconnectAttempts++;
-            
+
             if (this.reconnectAttempts >= this.maxReconnectAttempts) {
                 this.updateConnectionState('failed');
                 this.showNotification('Failed to connect after multiple attempts', 'error');
@@ -241,34 +241,34 @@ class EnhancedConnectionManager {
                 );
             }
         });
-        
+
         this.socket.on('reconnect', (attemptNumber) => {
             console.log(`[ConnectionManager] Reconnected after ${attemptNumber} attempts`);
             this.showNotification('Reconnected successfully', 'success');
-            
+
             // Request event replay
             this.socket.emit('request_replay', {
                 last_sequence: this.lastSequence
             });
         });
-        
+
         this.socket.on('reconnect_attempt', (attemptNumber) => {
             console.log(`[ConnectionManager] Reconnection attempt ${attemptNumber}`);
             this.updateConnectionState('reconnecting');
         });
     }
-    
+
     /**
      * Start heartbeat monitoring
      */
     startHeartbeat() {
         this.stopHeartbeat();
-        
+
         this.heartbeatTimer = setInterval(() => {
             if (this.socket && this.socket.connected) {
                 this.socket.emit('heartbeat');
                 this.missedHeartbeats++;
-                
+
                 if (this.missedHeartbeats >= this.maxMissedHeartbeats) {
                     console.warn('[ConnectionManager] Too many missed heartbeats, connection may be stale');
                     this.updateConnectionQuality(0.3);
@@ -276,7 +276,7 @@ class EnhancedConnectionManager {
                 }
             }
         }, this.heartbeatInterval);
-        
+
         // Also start ping monitoring for latency
         this.pingTimer = setInterval(() => {
             if (this.socket && this.socket.connected) {
@@ -285,7 +285,7 @@ class EnhancedConnectionManager {
             }
         }, 10000); // Every 10 seconds
     }
-    
+
     /**
      * Stop heartbeat monitoring
      */
@@ -294,13 +294,13 @@ class EnhancedConnectionManager {
             clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = null;
         }
-        
+
         if (this.pingTimer) {
             clearInterval(this.pingTimer);
             this.pingTimer = null;
         }
     }
-    
+
     /**
      * Start health monitoring
      */
@@ -311,7 +311,7 @@ class EnhancedConnectionManager {
                 this.socket.emit('get_connection_stats');
             }
         }, 60000); // Every minute
-        
+
         // Activity timeout detection
         setInterval(() => {
             if (this.connectionState === 'connected' && this.metrics.lastActivity) {
@@ -323,20 +323,20 @@ class EnhancedConnectionManager {
             }
         }, 30000); // Check every 30 seconds
     }
-    
+
     /**
      * Update connection state and notify listeners
      */
     updateConnectionState(state) {
         const previousState = this.connectionState;
         this.connectionState = state;
-        
+
         if (previousState !== state) {
             console.log(`[ConnectionManager] State change: ${previousState} -> ${state}`);
-            
+
             // Update UI
             this.updateConnectionUI(state);
-            
+
             // Notify callbacks
             this.statusCallbacks.forEach(callback => {
                 try {
@@ -347,13 +347,13 @@ class EnhancedConnectionManager {
             });
         }
     }
-    
+
     /**
      * Update connection quality score
      */
     updateConnectionQuality(quality) {
         this.connectionQuality = Math.max(0, Math.min(1, quality));
-        
+
         // Notify callbacks
         this.qualityCallbacks.forEach(callback => {
             try {
@@ -362,11 +362,11 @@ class EnhancedConnectionManager {
                 console.error('Error in quality callback:', error);
             }
         });
-        
+
         // Update UI indicator
         this.updateQualityUI(this.connectionQuality);
     }
-    
+
     /**
      * Update latency display
      */
@@ -374,7 +374,7 @@ class EnhancedConnectionManager {
         const latencyElement = document.getElementById('connection-latency');
         if (latencyElement) {
             latencyElement.textContent = `${latency}ms`;
-            
+
             // Color code based on latency
             if (latency < 50) {
                 latencyElement.className = 'latency-good';
@@ -385,14 +385,14 @@ class EnhancedConnectionManager {
             }
         }
     }
-    
+
     /**
      * Update connection UI based on state
      */
     updateConnectionUI(state) {
         const statusElement = document.getElementById('connection-status');
         if (!statusElement) return;
-        
+
         const stateConfig = {
             'connecting': { text: 'Connecting...', class: 'status-connecting', icon: '⟳' },
             'connected': { text: 'Connected', class: 'status-connected', icon: '●' },
@@ -401,23 +401,23 @@ class EnhancedConnectionManager {
             'stale': { text: 'Connection Stale', class: 'status-stale', icon: '⚠' },
             'failed': { text: 'Connection Failed', class: 'status-failed', icon: '✕' }
         };
-        
+
         const config = stateConfig[state] || stateConfig['disconnected'];
         statusElement.innerHTML = `<span>${config.icon}</span> ${config.text}`;
         statusElement.className = `status-badge ${config.class}`;
     }
-    
+
     /**
      * Update connection quality UI
      */
     updateQualityUI(quality) {
         const qualityElement = document.getElementById('connection-quality');
         if (!qualityElement) return;
-        
+
         const percentage = Math.round(quality * 100);
         let qualityClass = 'quality-good';
         let qualityText = 'Excellent';
-        
+
         if (quality < 0.3) {
             qualityClass = 'quality-poor';
             qualityText = 'Poor';
@@ -425,7 +425,7 @@ class EnhancedConnectionManager {
             qualityClass = 'quality-moderate';
             qualityText = 'Fair';
         }
-        
+
         qualityElement.innerHTML = `
             <div class="quality-bar ${qualityClass}">
                 <div class="quality-fill" style="width: ${percentage}%"></div>
@@ -433,7 +433,7 @@ class EnhancedConnectionManager {
             <span class="quality-text">${qualityText} (${percentage}%)</span>
         `;
     }
-    
+
     /**
      * Buffer events when disconnected
      */
@@ -441,68 +441,68 @@ class EnhancedConnectionManager {
         if (this.eventBuffer.length >= this.maxEventBuffer) {
             this.eventBuffer.shift(); // Remove oldest
         }
-        
+
         this.eventBuffer.push({
             ...event,
             buffered_at: Date.now()
         });
-        
+
         // Save to localStorage for persistence
         localStorage.setItem('claude_mpm_event_buffer', JSON.stringify(this.eventBuffer));
     }
-    
+
     /**
      * Flush buffered events after reconnection
      */
     flushEventBuffer() {
         if (this.eventBuffer.length === 0) return;
-        
+
         console.log(`[ConnectionManager] Flushing ${this.eventBuffer.length} buffered events`);
-        
+
         // Process buffered events
         this.eventBuffer.forEach(event => {
             this.socketClient.handleEvent('claude_event', event);
         });
-        
+
         // Clear buffer
         this.eventBuffer = [];
         localStorage.removeItem('claude_mpm_event_buffer');
     }
-    
+
     /**
      * Show notification to user
      */
     showNotification(message, type = 'info') {
         const notificationArea = document.getElementById('connection-notifications');
         if (!notificationArea) return;
-        
+
         const notification = document.createElement('div');
         notification.className = `notification notification-${type}`;
         notification.textContent = message;
-        
+
         notificationArea.appendChild(notification);
-        
+
         // Auto-remove after 5 seconds
         setTimeout(() => {
             notification.style.opacity = '0';
             setTimeout(() => notification.remove(), 300);
         }, 5000);
     }
-    
+
     /**
      * Register status change callback
      */
     onStatusChange(callback) {
         this.statusCallbacks.add(callback);
     }
-    
+
     /**
      * Register quality change callback
      */
     onQualityChange(callback) {
         this.qualityCallbacks.add(callback);
     }
-    
+
     /**
      * Get connection metrics
      */
@@ -516,18 +516,18 @@ class EnhancedConnectionManager {
             bufferedEvents: this.eventBuffer.length
         };
     }
-    
+
     /**
      * Disconnect and cleanup
      */
     disconnect() {
         this.stopHeartbeat();
-        
+
         if (this.socket) {
             this.socket.disconnect();
             this.socket = null;
         }
-        
+
         this.updateConnectionState('disconnected');
     }
 }