claude-mpm 4.2.7__py3-none-any.whl → 4.2.9__py3-none-any.whl

claude_mpm/services/dashboard/stable_server.py

@@ -39,8 +39,7 @@ except ImportError:
 
 # Set up logging
 logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
@@ -184,23 +183,25 @@ class StableDashboardServer:
         self.sio = None
         self.server_runner = None
         self.server_site = None
-        
+
         # Event storage with circular buffer (keep last 500 events)
         self.event_history: Deque[Dict[str, Any]] = deque(maxlen=500)
         self.event_count = 0
         self.server_start_time = time.time()
         self.last_event_time = None
         self.connected_clients = set()
-        
+
         # Resilience features
         self.retry_count = 0
         self.max_retries = 3
         self.health_check_failures = 0
         self.is_healthy = True
-        
+
         # Persistent event storage (optional)
-        self.persist_events = os.environ.get('CLAUDE_MPM_PERSIST_EVENTS', 'false').lower() == 'true'
-        self.event_log_path = Path.home() / '.claude' / 'dashboard_events.jsonl'
+        self.persist_events = (
+            os.environ.get("CLAUDE_MPM_PERSIST_EVENTS", "false").lower() == "true"
+        )
+        self.event_log_path = Path.home() / ".claude" / "dashboard_events.jsonl"
         if self.persist_events:
             self.event_log_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -219,16 +220,16 @@ class StableDashboardServer:
                 print("❌ Error: Could not find dashboard files")
                 print("Please ensure Claude MPM is properly installed")
                 return False
-        
+
         # Validate that the dashboard path has the required files
         template_path = self.dashboard_path / "templates" / "index.html"
         static_path = self.dashboard_path / "static"
-        
+
         if not template_path.exists():
             print(f"❌ Error: Dashboard template not found at {template_path}")
             print("Please ensure Claude MPM dashboard files are properly installed")
             return False
-        
+
         if not static_path.exists():
             print(f"❌ Error: Dashboard static files not found at {static_path}")
             print("Please ensure Claude MPM dashboard files are properly installed")
@@ -236,8 +237,10 @@ class StableDashboardServer:
 
         if self.debug:
             print(f"🔍 Debug: Dashboard path resolved to: {self.dashboard_path}")
-            print(f"🔍 Debug: Checking for required files...")
-            template_exists = (self.dashboard_path / "templates" / "index.html").exists()
+            print("🔍 Debug: Checking for required files...")
+            template_exists = (
+                self.dashboard_path / "templates" / "index.html"
+            ).exists()
             static_exists = (self.dashboard_path / "static").exists()
             print(f"   - templates/index.html: {template_exists}")
             print(f"   - static directory: {static_exists}")
@@ -273,17 +276,19 @@ class StableDashboardServer:
         # IMPORTANT: Only add explicit routes, never add static file serving for root
         # This prevents aiohttp from serving directory listings
         self.app.router.add_get("/", self._serve_dashboard)
-        self.app.router.add_get("/index.html", self._serve_dashboard)  # Also handle /index.html
+        self.app.router.add_get(
+            "/index.html", self._serve_dashboard
+        )  # Also handle /index.html
         self.app.router.add_get("/static/{path:.*}", self._serve_static)
         self.app.router.add_get("/api/directory/list", self._list_directory)
         self.app.router.add_get("/api/file/read", self._read_file)
         self.app.router.add_get("/version.json", self._serve_version)
-        
+
         # New resilience endpoints
         self.app.router.add_get("/health", self._health_check)
         self.app.router.add_get("/api/status", self._serve_status)
         self.app.router.add_get("/api/events/history", self._serve_event_history)
-        
+
         # CRITICAL: Add the missing /api/events endpoint for receiving events
         self.app.router.add_post("/api/events", self._receive_event)
 
@@ -295,17 +300,17 @@ class StableDashboardServer:
             self.connected_clients.add(sid)
             if self.debug:
                 print(f"✅ SocketIO client connected: {sid}")
-                user_agent = environ.get('HTTP_USER_AGENT', 'Unknown')
+                user_agent = environ.get("HTTP_USER_AGENT", "Unknown")
                 # Truncate long user agents for readability
                 if len(user_agent) > 80:
                     user_agent = user_agent[:77] + "..."
                 print(f"   Client info: {user_agent}")
-            
+
             # Send connection confirmation
             await self.sio.emit(
                 "connection_test", {"status": "connected", "server": "stable"}, room=sid
             )
-            
+
             # Send recent event history to new client
             if self.event_history:
                 # Send last 20 events to catch up new client
@@ -333,7 +338,9 @@ class StableDashboardServer:
             response = create_mock_ast_data(file_path, file_name)
 
             if self.debug:
-                print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+                print(
+                    f"📤 Sending analysis response: {len(response['elements'])} elements"
+                )
             await self.sio.emit("code:file:analyzed", response, room=sid)
 
         # CRITICAL: Handle the actual event name with colons that the client sends
@@ -351,7 +358,9 @@ class StableDashboardServer:
             response = create_mock_ast_data(file_path, file_name)
 
             if self.debug:
-                print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+                print(
+                    f"📤 Sending analysis response: {len(response['elements'])} elements"
+                )
             await self.sio.emit("code:file:analyzed", response, room=sid)
 
         # Handle other events the dashboard sends
@@ -385,28 +394,28 @@ class StableDashboardServer:
             if self.debug:
                 print(f"📡 Received top-level discovery request from {sid}")
             await self.sio.emit("code:top_level:discovered", {"status": "ok"}, room=sid)
-        
+
         # Mock event generator when no real events
         @self.sio.event
         async def request_mock_event(sid, data):
             """Generate a mock event for testing."""
             if self.debug:
                 print(f"📡 Mock event requested by {sid}")
-            
+
             mock_event = self._create_mock_event()
             # Store and broadcast like a real event
             self.event_count += 1
             self.last_event_time = datetime.now()
             self.event_history.append(mock_event)
             await self.sio.emit("claude_event", mock_event)
-    
+
     def _create_mock_event(self) -> Dict[str, Any]:
         """Create a mock event for testing/demo purposes."""
         import random
-        
+
         event_types = ["file", "command", "test", "build", "deploy"]
         event_subtypes = ["start", "progress", "complete", "error", "warning"]
-        
+
         return {
             "type": random.choice(event_types),
             "subtype": random.choice(event_subtypes),
@@ -416,31 +425,31 @@ class StableDashboardServer:
                 "message": f"Mock {random.choice(['operation', 'task', 'process'])} {random.choice(['started', 'completed', 'in progress'])}",
                 "file": f"/path/to/file_{random.randint(1, 100)}.py",
                 "line": random.randint(1, 500),
-                "progress": random.randint(0, 100)
+                "progress": random.randint(0, 100),
             },
             "session_id": "mock-session",
-            "server_event_id": self.event_count + 1
+            "server_event_id": self.event_count + 1,
         }
-    
+
     async def _start_mock_event_generator(self):
         """Start generating mock events if no real events for a while."""
         try:
             while True:
                 await asyncio.sleep(30)  # Check every 30 seconds
-                
+
                 # If no events in last 60 seconds and clients connected, generate mock
                 if self.connected_clients and (
-                    not self.last_event_time or 
-                    (datetime.now() - self.last_event_time).total_seconds() > 60
+                    not self.last_event_time
+                    or (datetime.now() - self.last_event_time).total_seconds() > 60
                 ):
                     if self.debug:
                         print("⏰ No recent events, generating mock event")
-                    
+
                     mock_event = self._create_mock_event()
                     self.event_count += 1
                     self.last_event_time = datetime.now()
                     self.event_history.append(mock_event)
-                    
+
                     await self.sio.emit("claude_event", mock_event)
         except asyncio.CancelledError:
             pass
@@ -449,20 +458,24 @@ class StableDashboardServer:
 
     async def _serve_dashboard(self, request):
         """Serve the main dashboard HTML with fallback."""
-        dashboard_file = self.dashboard_path / "templates" / "index.html" if self.dashboard_path else None
-        
+        dashboard_file = (
+            self.dashboard_path / "templates" / "index.html"
+            if self.dashboard_path
+            else None
+        )
+
         # Try to serve actual dashboard
         if dashboard_file and dashboard_file.exists():
             try:
-                with open(dashboard_file, 'r', encoding='utf-8') as f:
+                with open(dashboard_file, encoding="utf-8") as f:
                     content = f.read()
                 return web.Response(text=content, content_type="text/html")
             except Exception as e:
                 logger.error(f"Error reading dashboard template: {e}")
                 # Fall through to fallback HTML
-        
+
         # Fallback HTML if template missing or error
-        fallback_html = '''
+        fallback_html = """
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -491,7 +504,7 @@ class StableDashboardServer:
             <h1>Claude MPM Dashboard</h1>
             <div class="subtitle">Fallback Mode - Template not found</div>
         </div>
-        
+
         <div id="status" class="status healthy">
             <h3>Server Status</h3>
             <div class="metric">
@@ -507,7 +520,7 @@ class StableDashboardServer:
                 <div class="metric-value" id="events">Loading...</div>
             </div>
         </div>
-        
+
         <div class="events">
             <h3>Recent Events</h3>
             <div id="event-list">
@@ -515,29 +528,29 @@ class StableDashboardServer:
             </div>
         </div>
     </div>
-    
+
     <script src="https://cdn.socket.io/4.5.4/socket.io.min.js"></script>
     <script>
         // Fallback dashboard JavaScript
         const socket = io();
-        
+
         // Update status periodically
         async function updateStatus() {
             try {
                 const response = await fetch('/api/status');
                 const data = await response.json();
-                
+
                 document.getElementById('health').textContent = data.status;
                 document.getElementById('uptime').textContent = data.uptime.human;
                 document.getElementById('events').textContent = data.events.total;
-                
+
                 const statusDiv = document.getElementById('status');
                 statusDiv.className = data.status === 'running' ? 'status healthy' : 'status degraded';
             } catch (e) {
                 console.error('Failed to fetch status:', e);
             }
         }
-        
+
         // Listen for events
         socket.on('claude_event', (event) => {
             const eventList = document.getElementById('event-list');
@@ -545,25 +558,25 @@ class StableDashboardServer:
             eventDiv.className = 'event';
             eventDiv.textContent = JSON.stringify(event, null, 2);
             eventList.insertBefore(eventDiv, eventList.firstChild);
-            
+
             // Keep only last 10 events
             while (eventList.children.length > 10) {
                 eventList.removeChild(eventList.lastChild);
             }
         });
-        
+
         socket.on('connect', () => {
             console.log('Connected to dashboard server');
         });
-        
+
         // Initial load and periodic updates
         updateStatus();
         setInterval(updateStatus, 5000);
     </script>
 </body>
 </html>
-        '''
-        
+        """
+
         logger.warning("Serving fallback dashboard HTML")
         return web.Response(text=fallback_html, content_type="text/html")
 
@@ -636,6 +649,10 @@ class StableDashboardServer:
             return web.json_response({"error": "Not a file"}, status=400)
 
         try:
+            # Determine file type
+            file_ext = os.path.splitext(abs_path)[1].lower()
+            is_json = file_ext in [".json", ".jsonl", ".geojson"]
+
             # Read file with appropriate encoding
             encodings = ["utf-8", "latin-1", "cp1252"]
             content = None
@@ -651,13 +668,29 @@ class StableDashboardServer:
             if content is None:
                 return web.json_response({"error": "Could not decode file"}, status=400)
 
+            # Format JSON files for better readability
+            formatted_content = content
+            is_valid_json = False
+            if is_json:
+                try:
+                    import json
+
+                    parsed = json.loads(content)
+                    formatted_content = json.dumps(parsed, indent=2, sort_keys=False)
+                    is_valid_json = True
+                except json.JSONDecodeError:
+                    # Not valid JSON, return as-is
+                    is_valid_json = False
+
             return web.json_response(
                 {
                     "path": abs_path,
                     "name": os.path.basename(abs_path),
-                    "content": content,
-                    "lines": len(content.splitlines()),
+                    "content": formatted_content,
+                    "lines": len(formatted_content.splitlines()),
                     "size": os.path.getsize(abs_path),
+                    "type": "json" if is_json else "text",
+                    "is_valid_json": is_valid_json,
                 }
             )
 
@@ -670,121 +703,130 @@ class StableDashboardServer:
         """Health check endpoint for monitoring."""
         uptime = time.time() - self.server_start_time
         status = "healthy" if self.is_healthy else "degraded"
-        
+
         health_info = {
             "status": status,
             "uptime_seconds": round(uptime, 2),
             "connected_clients": len(self.connected_clients),
             "event_count": self.event_count,
-            "last_event": self.last_event_time.isoformat() if self.last_event_time else None,
+            "last_event": (
+                self.last_event_time.isoformat() if self.last_event_time else None
+            ),
             "retry_count": self.retry_count,
             "health_check_failures": self.health_check_failures,
-            "event_history_size": len(self.event_history)
+            "event_history_size": len(self.event_history),
         }
-        
+
         status_code = 200 if self.is_healthy else 503
         return web.json_response(health_info, status=status_code)
-    
+
     async def _serve_status(self, request):
         """Detailed server status endpoint."""
         uptime = time.time() - self.server_start_time
-        
+
         status_info = {
             "server": "stable",
             "version": "4.2.3",
             "status": "running" if self.is_healthy else "degraded",
             "uptime": {
                 "seconds": round(uptime, 2),
-                "human": self._format_uptime(uptime)
+                "human": self._format_uptime(uptime),
             },
             "connections": {
                 "active": len(self.connected_clients),
-                "clients": list(self.connected_clients)
+                "clients": list(self.connected_clients),
             },
             "events": {
                 "total": self.event_count,
                 "buffered": len(self.event_history),
-                "last_received": self.last_event_time.isoformat() if self.last_event_time else None
+                "last_received": (
+                    self.last_event_time.isoformat() if self.last_event_time else None
+                ),
             },
             "features": [
-                "http", "socketio", "event_bridge", "health_monitoring",
-                "auto_retry", "event_history", "graceful_degradation"
+                "http",
+                "socketio",
+                "event_bridge",
+                "health_monitoring",
+                "auto_retry",
+                "event_history",
+                "graceful_degradation",
             ],
             "resilience": {
                 "retry_count": self.retry_count,
                 "max_retries": self.max_retries,
                 "health_failures": self.health_check_failures,
-                "persist_events": self.persist_events
-            }
+                "persist_events": self.persist_events,
+            },
         }
         return web.json_response(status_info)
-    
+
     async def _serve_event_history(self, request):
         """Serve recent event history."""
-        limit = int(request.query.get('limit', '100'))
+        limit = int(request.query.get("limit", "100"))
         events = list(self.event_history)[-limit:]
-        return web.json_response({
-            "events": events,
-            "count": len(events),
-            "total_events": self.event_count
-        })
-    
+        return web.json_response(
+            {"events": events, "count": len(events), "total_events": self.event_count}
+        )
+
     async def _receive_event(self, request):
         """Receive events from hook system via HTTP POST."""
         try:
             # Parse event data
             data = await request.json()
-            
+
             # Add server metadata
             event = {
                 **data,
                 "received_at": datetime.now().isoformat(),
-                "server_event_id": self.event_count + 1
+                "server_event_id": self.event_count + 1,
             }
-            
+
             # Update tracking
             self.event_count += 1
             self.last_event_time = datetime.now()
-            
+
             # Store in circular buffer
             self.event_history.append(event)
-            
+
             # Persist to disk if enabled
             if self.persist_events:
                 try:
-                    with open(self.event_log_path, 'a') as f:
-                        f.write(json.dumps(event) + '\n')
+                    with open(self.event_log_path, "a") as f:
+                        f.write(json.dumps(event) + "\n")
                 except Exception as e:
                     logger.error(f"Failed to persist event: {e}")
-            
+
             # Emit to all connected SocketIO clients
             if self.sio and self.connected_clients:
                 await self.sio.emit("claude_event", event)
                 if self.debug:
-                    print(f"📡 Forwarded event to {len(self.connected_clients)} clients")
-            
+                    print(
+                        f"📡 Forwarded event to {len(self.connected_clients)} clients"
+                    )
+
             # Return success response
-            return web.json_response({
-                "status": "received",
-                "event_id": event["server_event_id"],
-                "clients_notified": len(self.connected_clients)
-            })
-            
+            return web.json_response(
+                {
+                    "status": "received",
+                    "event_id": event["server_event_id"],
+                    "clients_notified": len(self.connected_clients),
+                }
+            )
+
         except json.JSONDecodeError as e:
             logger.error(f"Invalid JSON in event request: {e}")
             return web.json_response(
-                {"error": "Invalid JSON", "details": str(e)},
-                status=400
+                {"error": "Invalid JSON", "details": str(e)}, status=400
             )
         except Exception as e:
             logger.error(f"Error processing event: {e}")
             if self.debug:
                 traceback.print_exc()
             return web.json_response(
-                {"error": "Failed to process event", "details": str(e)},
-                status=500
+                {"error": "Failed to process event", "details": str(e)}, status=500
             )
-    
+
     async def _serve_version(self, request):
         """Serve version information."""
         version_info = {
@@ -794,14 +836,14 @@ class StableDashboardServer:
             "status": "running" if self.is_healthy else "degraded",
         }
         return web.json_response(version_info)
-    
+
     def _format_uptime(self, seconds: float) -> str:
         """Format uptime in human-readable format."""
         days = int(seconds // 86400)
         hours = int((seconds % 86400) // 3600)
         minutes = int((seconds % 3600) // 60)
         secs = int(seconds % 60)
-        
+
         parts = []
         if days > 0:
             parts.append(f"{days}d")
@@ -810,31 +852,35 @@ class StableDashboardServer:
         if minutes > 0:
             parts.append(f"{minutes}m")
         parts.append(f"{secs}s")
-        
+
         return " ".join(parts)
 
     def run(self):
         """Run the server with automatic restart on crash."""
         restart_attempts = 0
         max_restart_attempts = 5
-        
+
         while restart_attempts < max_restart_attempts:
             try:
-                print(f"🔧 Setting up server... (attempt {restart_attempts + 1}/{max_restart_attempts})")
-                
+                print(
+                    f"🔧 Setting up server... (attempt {restart_attempts + 1}/{max_restart_attempts})"
+                )
+
                 # Reset health status on restart
                 self.is_healthy = True
                 self.health_check_failures = 0
-                
+
                 if not self.setup():
                     if not DEPENDENCIES_AVAILABLE:
                         print("❌ Missing required dependencies")
                         return False
-                    
+
                     # Continue with fallback mode even if dashboard files not found
                     print("⚠️  Dashboard files not found - running in fallback mode")
-                    print("   Server will provide basic functionality and receive events")
-                    
+                    print(
+                        "   Server will provide basic functionality and receive events"
+                    )
+
                     # Set up minimal server without dashboard files
                     self.sio = socketio.AsyncServer(
                         cors_allowed_origins="*",
@@ -848,25 +894,29 @@ class StableDashboardServer:
                     self.sio.attach(self.app)
                     self._setup_routes()
                     self._setup_socketio_events()
-                
+
                 return self._run_with_resilience()
-                
+
             except Exception as e:
                 restart_attempts += 1
                 logger.error(f"Server crashed: {e}")
                 if self.debug:
                     traceback.print_exc()
-                
+
                 if restart_attempts < max_restart_attempts:
-                    wait_time = min(2 ** restart_attempts, 30)  # Exponential backoff, max 30s
+                    wait_time = min(
+                        2**restart_attempts, 30
+                    )  # Exponential backoff, max 30s
                     print(f"🔄 Restarting server in {wait_time} seconds...")
                     time.sleep(wait_time)
                 else:
-                    print(f"❌ Server failed after {max_restart_attempts} restart attempts")
+                    print(
+                        f"❌ Server failed after {max_restart_attempts} restart attempts"
+                    )
                     return False
-        
+
         return False
-    
+
     def _run_with_resilience(self):
         """Run server with port conflict resolution and error handling."""
 
@@ -904,11 +954,11 @@ class StableDashboardServer:
                     web.run_app(self.app, host=self.host, port=self.port)
                 else:
                     web.run_app(
-                        self.app, 
-                        host=self.host, 
-                        port=self.port, 
+                        self.app,
+                        host=self.host,
+                        port=self.port,
                         access_log=None,
-                        print=lambda *args: None  # Suppress startup messages in non-debug mode
+                        print=lambda *args: None,  # Suppress startup messages in non-debug mode
                     )
                 return True  # Server started successfully
             except KeyboardInterrupt:
@@ -916,7 +966,11 @@ class StableDashboardServer:
                 return True
             except OSError as e:
                 error_str = str(e)
-                if "[Errno 48]" in error_str or "Address already in use" in error_str or "address already in use" in error_str.lower():
+                if (
+                    "[Errno 48]" in error_str
+                    or "Address already in use" in error_str
+                    or "address already in use" in error_str.lower()
+                ):
                     # Port is already in use
                     if attempt < max_port_attempts - 1:
                         self.port += 1
@@ -930,7 +984,9 @@ class StableDashboardServer:
                             f"❌ Could not find available port after {max_port_attempts} attempts"
                         )
                         print(f"   Ports {original_port} to {self.port} are all in use")
-                        print("\n💡 Tip: Check if another dashboard instance is running")
+                        print(
+                            "\n💡 Tip: Check if another dashboard instance is running"
+                        )
                         print("   You can stop it with: claude-mpm dashboard stop")
                         return False
                 else:
@@ -938,12 +994,14 @@ class StableDashboardServer:
                     print(f"❌ Server error: {e}")
                     if self.debug:
                         import traceback
+
                         traceback.print_exc()
                     return False
             except Exception as e:
                 print(f"❌ Unexpected server error: {e}")
                 if self.debug:
                     import traceback
+
                     traceback.print_exc()
                 else:
                     print("\n💡 Run with --debug flag for more details")