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

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.5
+4.2.7

claude_mpm/cli/commands/dashboard.py

@@ -71,9 +71,11 @@ class DashboardCommand(BaseCommand):
         port = getattr(args, "port", 8765)
         host = getattr(args, "host", "localhost")
         background = getattr(args, "background", False)
+        use_stable = getattr(args, "stable", True)  # Default to stable server
+        debug = getattr(args, "debug", False)
 
         self.logger.info(
-            f"Starting dashboard on {host}:{port} (background: {background})"
+            f"Starting dashboard on {host}:{port} (background: {background}, stable: {use_stable})"
         )
 
         # Check if dashboard is already running
@@ -100,47 +102,102 @@ class DashboardCommand(BaseCommand):
                     },
                 )
             return CommandResult.error_result("Failed to start dashboard in background")
-        # Run in foreground mode - directly start the SocketIO server
-        try:
-            print(f"Starting dashboard server on {host}:{port}...")
-            print("Press Ctrl+C to stop the server")
-
-            # Create and start the Dashboard server (with monitor client)
-            self.server = DashboardServer(host=host, port=port)
-
-            # Set up signal handlers for graceful shutdown
-            def signal_handler(signum, frame):
-                print("\nShutting down dashboard server...")
+        
+        # Run in foreground mode
+        server_started = False
+        
+        # Try stable server first (or if explicitly requested)
+        if use_stable:
+            try:
+                self.logger.info("Starting stable dashboard server (no monitor dependency)...")
+                print(f"Starting stable dashboard server on {host}:{port}...")
+                print("Press Ctrl+C to stop the server")
+                print("\n✅ Using stable server - works without monitor service\n")
+                
+                # Create and run the stable server
+                from ...services.dashboard.stable_server import StableDashboardServer
+                stable_server = StableDashboardServer(host=host, port=port, debug=debug)
+                
+                # Set up signal handlers for graceful shutdown
+                def signal_handler(signum, frame):
+                    print("\nShutting down dashboard server...")
+                    sys.exit(0)
+                
+                signal.signal(signal.SIGINT, signal_handler)
+                signal.signal(signal.SIGTERM, signal_handler)
+                
+                # Run the server (blocking)
+                result = stable_server.run()
+                if result:
+                    # Server ran successfully and stopped normally
+                    server_started = True
+                    return CommandResult.success_result("Dashboard server stopped")
+                else:
+                    # Server failed to start (e.g., couldn't find templates)
+                    server_started = False
+                    self.logger.warning("Stable server failed to start, trying advanced server...")
+                    
+            except KeyboardInterrupt:
+                print("\nDashboard server stopped by user")
+                return CommandResult.success_result("Dashboard server stopped")
+            except Exception as e:
+                self.logger.warning(f"Stable server failed: {e}")
+                if not getattr(args, "no_fallback", False):
+                    print(f"\n⚠️ Stable server failed: {e}")
+                    print("Attempting fallback to advanced server...")
+                else:
+                    return CommandResult.error_result(f"Failed to start stable dashboard: {e}")
+        
+        # Fallback to advanced DashboardServer if stable server failed or not requested
+        if not server_started and not getattr(args, "stable_only", False):
+            try:
+                self.logger.info("Attempting to start advanced dashboard server with monitor...")
+                print(f"\nStarting advanced dashboard server on {host}:{port}...")
+                print("Note: This requires monitor service on port 8766")
+                print("Press Ctrl+C to stop the server")
+
+                # Create and start the Dashboard server (with monitor client)
+                self.server = DashboardServer(host=host, port=port)
+
+                # Set up signal handlers for graceful shutdown
+                def signal_handler(signum, frame):
+                    print("\nShutting down dashboard server...")
+                    if self.server:
+                        self.server.stop_sync()
+                    sys.exit(0)
+
+                signal.signal(signal.SIGINT, signal_handler)
+                signal.signal(signal.SIGTERM, signal_handler)
+
+                # Start the server (this starts in background thread)
+                self.server.start_sync()
+
+                # Keep the main thread alive while server is running
+                # The server runs in a background thread, so we need to block here
+                try:
+                    while self.server.is_running():
+                        time.sleep(1)
+                except KeyboardInterrupt:
+                    # Ctrl+C pressed, stop the server
+                    pass
+
+                # Server has stopped or user interrupted
                 if self.server:
                     self.server.stop_sync()
-                sys.exit(0)
 
-            signal.signal(signal.SIGINT, signal_handler)
-            signal.signal(signal.SIGTERM, signal_handler)
+                return CommandResult.success_result("Dashboard server stopped")
 
-            # Start the server (this starts in background thread)
-            self.server.start_sync()
-
-            # Keep the main thread alive while server is running
-            # The server runs in a background thread, so we need to block here
-            try:
-                while self.server.is_running():
-                    time.sleep(1)
             except KeyboardInterrupt:
-                # Ctrl+C pressed, stop the server
-                pass
-
-            # Server has stopped or user interrupted
-            if self.server:
-                self.server.stop_sync()
-
-            return CommandResult.success_result("Dashboard server stopped")
-
-        except KeyboardInterrupt:
-            print("\nDashboard server stopped by user")
-            return CommandResult.success_result("Dashboard server stopped")
-        except Exception as e:
-            return CommandResult.error_result(f"Failed to start dashboard: {e}")
+                print("\nDashboard server stopped by user")
+                return CommandResult.success_result("Dashboard server stopped")
+            except Exception as e:
+                # If both servers fail, provide helpful error message
+                error_msg = f"Failed to start dashboard: {e}\n\n"
+                error_msg += "💡 Troubleshooting tips:\n"
+                error_msg += f"  - Check if port {port} is already in use\n"
+                error_msg += "  - Try running with --stable flag for standalone mode\n"
+                error_msg += "  - Use --debug flag for more details\n"
+                return CommandResult.error_result(error_msg)
 
     def _stop_dashboard(self, args) -> CommandResult:
         """Stop the dashboard server."""

claude_mpm/cli/parsers/__init__.py

@@ -1,29 +0,0 @@
-"""
-CLI parsers package for claude-mpm.
-
-This package contains modular parser components that were extracted from the
-monolithic parser.py file to improve maintainability and organization.
-
-WHY: The original parser.py was 1,166 lines with a single 961-line function.
-Breaking it into focused modules makes it easier to maintain and test.
-
-DESIGN DECISION: Each parser module handles a specific command domain:
-- base_parser.py: Common arguments and main parser setup
-- run_parser.py: Run command arguments
-- agent_parser.py: Agent management commands
-- memory_parser.py: Memory management commands
-- tickets_parser.py: Ticket management commands
-- config_parser.py: Configuration commands
-- monitor_parser.py: Monitoring commands
-- mcp_parser.py: MCP Gateway commands
-"""
-
-from .base_parser import add_common_arguments, create_parser, preprocess_args
-from .run_parser import add_run_arguments
-
-__all__ = [
-    "add_common_arguments",
-    "add_run_arguments",
-    "create_parser",
-    "preprocess_args",
-]

claude_mpm/services/dashboard/stable_server.py

@@ -12,11 +12,18 @@ DESIGN DECISIONS:
 - Graceful fallbacks for missing dependencies
 """
 
+import asyncio
 import glob
+import json
+import logging
 import os
 import sys
+import time
+import traceback
+from collections import deque
+from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Deque, Dict, Optional
 
 try:
     import aiohttp
@@ -30,6 +37,13 @@ except ImportError:
     aiohttp = None
     web = None
 
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
 
 def find_dashboard_files() -> Optional[Path]:
     """Find dashboard files across different installation methods."""
@@ -168,6 +182,27 @@ class StableDashboardServer:
         self.dashboard_path = None
         self.app = None
         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'
+        if self.persist_events:
+            self.event_log_path.parent.mkdir(parents=True, exist_ok=True)
 
     def setup(self) -> bool:
         """Set up the server components."""
@@ -177,24 +212,50 @@ class StableDashboardServer:
             )
             return False
 
-        # Find dashboard files
-        self.dashboard_path = find_dashboard_files()
+        # Find dashboard files only if not already set (for testing)
         if not self.dashboard_path:
-            print("❌ Error: Could not find dashboard files")
-            print("Please ensure Claude MPM is properly installed")
+            self.dashboard_path = find_dashboard_files()
+            if not self.dashboard_path:
+                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")
             return False
 
+        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()
+            static_exists = (self.dashboard_path / "static").exists()
+            print(f"   - templates/index.html: {template_exists}")
+            print(f"   - static directory: {static_exists}")
+
         print(f"📁 Using dashboard files from: {self.dashboard_path}")
 
         # Create SocketIO server with improved timeout settings
+        logger_enabled = self.debug  # Only enable verbose logging in debug mode
         self.sio = socketio.AsyncServer(
             cors_allowed_origins="*",
-            logger=True,
-            engineio_logger=True,
+            logger=logger_enabled,
+            engineio_logger=logger_enabled,
             ping_interval=30,  # Match client's 30 second ping interval
             ping_timeout=60,  # Match client's 60 second timeout
             max_http_buffer_size=1e8,  # Allow larger messages
         )
+        # Create app WITHOUT any static file handlers to prevent directory listing
+        # This is critical - we only want explicit routes we define
         self.app = web.Application()
         self.sio.attach(self.app)
         print("✅ SocketIO server created and attached")
@@ -209,33 +270,61 @@ class StableDashboardServer:
 
     def _setup_routes(self):
         """Set up HTTP routes."""
+        # 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("/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)
 
     def _setup_socketio_events(self):
         """Set up SocketIO event handlers."""
 
         @self.sio.event
         async def connect(sid, environ):
-            print(f"✅ SocketIO client connected: {sid}")
-            print(f"   Client info: {environ.get('HTTP_USER_AGENT', 'Unknown')}")
-            # Send a test message to confirm connection
+            self.connected_clients.add(sid)
+            if self.debug:
+                print(f"✅ SocketIO client connected: {sid}")
+                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
+                recent_events = list(self.event_history)[-20:]
+                for event in recent_events:
+                    await self.sio.emit("claude_event", event, room=sid)
 
         @self.sio.event
         async def disconnect(sid):
-            print(f"❌ SocketIO client disconnected: {sid}")
+            self.connected_clients.discard(sid)
+            if self.debug:
+                print(f"📤 SocketIO client disconnected: {sid}")
 
         @self.sio.event
         async def code_analyze_file(sid, data):
-            print(
-                f"📡 Received file analysis request from {sid}: {data.get('path', 'unknown')}"
-            )
+            if self.debug:
+                print(
+                    f"📡 Received file analysis request from {sid}: {data.get('path', 'unknown')}"
+                )
 
             file_path = data.get("path", "")
             file_name = file_path.split("/")[-1] if file_path else "unknown"
@@ -243,15 +332,17 @@ class StableDashboardServer:
             # Create mock response
             response = create_mock_ast_data(file_path, file_name)
 
-            print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+            if self.debug:
+                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
         @self.sio.on("code:analyze:file")
         async def handle_code_analyze_file(sid, data):
-            print(
-                f"📡 Received code:analyze:file from {sid}: {data.get('path', 'unknown')}"
-            )
+            if self.debug:
+                print(
+                    f"📡 Received code:analyze:file from {sid}: {data.get('path', 'unknown')}"
+                )
 
             file_path = data.get("path", "")
             file_name = file_path.split("/")[-1] if file_path else "unknown"
@@ -259,20 +350,23 @@ class StableDashboardServer:
             # Create mock response
             response = create_mock_ast_data(file_path, file_name)
 
-            print(f"📤 Sending analysis response: {len(response['elements'])} elements")
+            if self.debug:
+                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
         @self.sio.event
         async def get_git_branch(sid, data):
-            print(f"📡 Received git branch request from {sid}: {data}")
+            if self.debug:
+                print(f"📡 Received git branch request from {sid}: {data}")
             await self.sio.emit(
                 "git_branch_response", {"branch": "main", "path": data}, room=sid
             )
 
         @self.sio.event
         async def request_status(sid, data):
-            print(f"📡 Received status request from {sid}")
+            if self.debug:
+                print(f"📡 Received status request from {sid}")
             await self.sio.emit(
                 "status_response", {"status": "running", "server": "stable"}, room=sid
             )
@@ -280,24 +374,198 @@ class StableDashboardServer:
         # Handle the event with dots (SocketIO converts colons to dots sometimes)
         @self.sio.event
         async def request_dot_status(sid, data):
-            print(f"📡 Received request.status from {sid}")
+            if self.debug:
+                print(f"📡 Received request.status from {sid}")
             await self.sio.emit(
                 "status_response", {"status": "running", "server": "stable"}, room=sid
             )
 
         @self.sio.event
         async def code_discover_top_level(sid, data):
-            print(f"📡 Received top-level discovery request from {sid}")
+            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),
+            "timestamp": datetime.now().isoformat(),
+            "source": "mock",
+            "data": {
+                "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)
+            },
+            "session_id": "mock-session",
+            "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
+                ):
+                    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
+        except Exception as e:
+            logger.error(f"Mock event generator error: {e}")
 
     async def _serve_dashboard(self, request):
-        """Serve the main dashboard HTML."""
-        dashboard_file = self.dashboard_path / "templates" / "index.html"
-        if dashboard_file.exists():
-            with open(dashboard_file) as f:
-                content = f.read()
-            return web.Response(text=content, content_type="text/html")
-        return web.Response(text="Dashboard not found", status=404)
+        """Serve the main dashboard HTML with fallback."""
+        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:
+                    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 = '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Claude MPM Dashboard - Fallback Mode</title>
+    <style>
+        body { font-family: system-ui, -apple-system, sans-serif; margin: 0; padding: 20px; background: #1e1e1e; color: #e0e0e0; }
+        .container { max-width: 1200px; margin: 0 auto; }
+        .header { background: #2d2d2d; padding: 20px; border-radius: 8px; margin-bottom: 20px; }
+        .status { background: #2d2d2d; padding: 15px; border-radius: 8px; margin-bottom: 20px; }
+        .status.healthy { border-left: 4px solid #4caf50; }
+        .status.degraded { border-left: 4px solid #ff9800; }
+        .events { background: #2d2d2d; padding: 20px; border-radius: 8px; }
+        .event { background: #1e1e1e; padding: 10px; margin: 10px 0; border-radius: 4px; }
+        h1 { color: #fff; margin: 0; }
+        .subtitle { color: #999; margin-top: 5px; }
+        .metric { display: inline-block; margin-right: 20px; }
+        .metric-label { color: #999; font-size: 12px; }
+        .metric-value { color: #fff; font-size: 20px; font-weight: bold; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <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">
+                <div class="metric-label">Health</div>
+                <div class="metric-value" id="health">Loading...</div>
+            </div>
+            <div class="metric">
+                <div class="metric-label">Uptime</div>
+                <div class="metric-value" id="uptime">Loading...</div>
+            </div>
+            <div class="metric">
+                <div class="metric-label">Events</div>
+                <div class="metric-value" id="events">Loading...</div>
+            </div>
+        </div>
+        
+        <div class="events">
+            <h3>Recent Events</h3>
+            <div id="event-list">
+                <div class="event">Waiting for events...</div>
+            </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');
+            const eventDiv = document.createElement('div');
+            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")
 
     async def _serve_static(self, request):
         """Serve static files."""
@@ -398,33 +666,232 @@ class StableDashboardServer:
         except Exception as e:
             return web.json_response({"error": str(e)}, status=500)
 
+    async def _health_check(self, request):
+        """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,
+            "retry_count": self.retry_count,
+            "health_check_failures": self.health_check_failures,
+            "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)
+            },
+            "connections": {
+                "active": len(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
+            },
+            "features": [
+                "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
+            }
+        }
+        return web.json_response(status_info)
+    
+    async def _serve_event_history(self, request):
+        """Serve recent event history."""
+        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
+        })
+    
+    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
+            }
+            
+            # 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')
+                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")
+            
+            # Return success response
+            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
+            )
+        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
+            )
+    
     async def _serve_version(self, request):
         """Serve version information."""
         version_info = {
-            "version": "4.2.2",
+            "version": "4.2.3",
             "server": "stable",
-            "features": ["http", "socketio", "mock_ast"],
-            "status": "running",
+            "features": ["http", "socketio", "event_bridge", "resilience"],
+            "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")
+        if hours > 0:
+            parts.append(f"{hours}h")
+        if minutes > 0:
+            parts.append(f"{minutes}m")
+        parts.append(f"{secs}s")
+        
+        return " ".join(parts)
 
     def run(self):
-        """Run the server with automatic port conflict resolution."""
-        print("🔧 Setting up server...")
-        if not self.setup():
-            print("❌ Server setup failed")
-            return False
+        """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})")
+                
+                # 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")
+                    
+                    # Set up minimal server without dashboard files
+                    self.sio = socketio.AsyncServer(
+                        cors_allowed_origins="*",
+                        logger=self.debug,
+                        engineio_logger=self.debug,
+                        ping_interval=30,
+                        ping_timeout=60,
+                        max_http_buffer_size=1e8,
+                    )
+                    self.app = web.Application()
+                    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
+                    print(f"🔄 Restarting server in {wait_time} seconds...")
+                    time.sleep(wait_time)
+                else:
+                    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."""
 
         print(f"🚀 Starting stable dashboard server at http://{self.host}:{self.port}")
-        print("✅ Server ready: HTTP + SocketIO on same port")
-        print("📡 SocketIO events registered:")
-        print("   - connect/disconnect")
-        print("   - code_analyze_file (from 'code:analyze:file')")
-        print("🌐 HTTP endpoints available:")
-        print("   - GET / (dashboard)")
-        print("   - GET /static/* (static files)")
-        print("   - GET /api/directory/list (directory API)")
-        print(f"🔗 Open in browser: http://{self.host}:{self.port}")
+        print("✅ Server ready: HTTP + SocketIO with resilience features")
+        print("🛡️  Resilience features enabled:")
+        print("   - Automatic restart on crash")
+        print("   - Health monitoring endpoint (/health)")
+        print("   - Event history buffer (500 events)")
+        print("   - Graceful degradation")
+        print("   - Connection retry logic")
+        print("📡 SocketIO events:")
+        print("   - claude_event (real-time events from hooks)")
+        print("   - code:analyze:file (code analysis)")
+        print("   - connection management")
+        print("🌐 HTTP endpoints:")
+        print("   - GET /             (dashboard)")
+        print("   - GET /health       (health check)")
+        print("   - POST /api/events  (receive hook events)")
+        print("   - GET /api/status   (detailed status)")
+        print("   - GET /api/events/history (event history)")
+        print("   - GET /api/directory/list")
+        print("   - GET /api/file/read")
+        print(f"\n🔗 Open in browser: http://{self.host}:{self.port}")
+        print("\n   Press Ctrl+C to stop the server\n")
 
         # Try to start server with port conflict handling
         max_port_attempts = 10
@@ -432,18 +899,29 @@ class StableDashboardServer:
 
         for attempt in range(max_port_attempts):
             try:
-                web.run_app(self.app, host=self.host, port=self.port, access_log=None)
-                break  # Server started successfully
+                # Use the print_func parameter to control access log output
+                if self.debug:
+                    web.run_app(self.app, host=self.host, port=self.port)
+                else:
+                    web.run_app(
+                        self.app, 
+                        host=self.host, 
+                        port=self.port, 
+                        access_log=None,
+                        print=lambda *args: None  # Suppress startup messages in non-debug mode
+                    )
+                return True  # Server started successfully
             except KeyboardInterrupt:
                 print("\n🛑 Server stopped by user")
-                break
+                return True
             except OSError as e:
-                if "[Errno 48]" in str(e) or "Address already in use" in str(e):
-                    # Port is already in use, try next port
+                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():
+                    # Port is already in use
                     if attempt < max_port_attempts - 1:
                         self.port += 1
                         print(
-                            f"⚠️ Port {self.port - 1} in use, trying port {self.port}..."
+                            f"⚠️  Port {self.port - 1} is in use, trying port {self.port}..."
                         )
                         # Recreate the app with new port
                         self.setup()
@@ -452,21 +930,23 @@ 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("   You can stop it with: claude-mpm dashboard stop")
                         return False
                 else:
                     # Other OS error
                     print(f"❌ Server error: {e}")
                     if self.debug:
                         import traceback
-
                         traceback.print_exc()
                     return False
             except Exception as e:
-                print(f"❌ Server error: {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")
                 return False
 
         return True

{claude_mpm-4.2.5.dist-info → claude_mpm-4.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.5
+Version: 4.2.7
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.2.5.dist-info → claude_mpm-4.2.7.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=rwXIWtsOJVrhT-T2eEOfESQ3sLYYzm_WGcjbp4g3dRE,6
+claude_mpm/VERSION,sha256=Ja49LMTSh-SA00LxW0FQuEWoJY55Ua7HEZO5p1DeXIM,6
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=I946iCQzIIPRZVVJ8aO7lA4euiyDnNw2IX7EelAOkIE,5915
@@ -71,7 +71,7 @@ claude_mpm/cli/commands/cleanup_orphaned_agents.py,sha256=JR8crvgrz7Sa6d-SI-gKyw
 claude_mpm/cli/commands/config.py,sha256=Yfi8WO-10_MYz2QipFw-yEzVvHKNQ6iSQXeyW5J85Cg,18559
 claude_mpm/cli/commands/configure.py,sha256=OsuISDoctmQyJpd0wn4LUFRR1AdoVLveT-pU6JJdW60,55439
 claude_mpm/cli/commands/configure_tui.py,sha256=VYLlm2B7QN8P3HtKMEO5Z7A9TpRicWvsojtNh4NxVWQ,66760
-claude_mpm/cli/commands/dashboard.py,sha256=dh9B39Da1Y4ppqHZyzXu7vzCIpA7SvoID4Gy5AZkELI,11053
+claude_mpm/cli/commands/dashboard.py,sha256=N6LFEx7azVAexvsAXM2RLfKvTRKrEDN3dwUEQmw0Pd4,14316
 claude_mpm/cli/commands/debug.py,sha256=lupNJRzpPHeisREYmbQ-9E3A3pvKjSHsapYFJVH8sbc,47056
 claude_mpm/cli/commands/doctor.py,sha256=bOZzDNxEMNMZYrJnu_V82tyZ12r5FiBRQNLVfSVvRIQ,5774
 claude_mpm/cli/commands/info.py,sha256=_hWH7uNv9VLO0eZh9Ua6qc5L1Z66kYj9ATzU4Q8UkSM,7377
@@ -89,7 +89,7 @@ claude_mpm/cli/commands/mpm_init_handler.py,sha256=-pCB0XL3KipqGtnta8CC7Lg5TPMws
 claude_mpm/cli/commands/run.py,sha256=HrqRWCxmtCKcOxygXRM4KYlN1FDxBXrt4lxz0WunPTs,43390
 claude_mpm/cli/commands/socketio_monitor.py,sha256=GHHY5pKg0XCffoqLoO0l0Nxa9HQY4gdrpYebLVahzl4,9540
 claude_mpm/cli/commands/tickets.py,sha256=kl2dklTBnG3Y4jUUJ_PcEVsTx4CtVJfkGWboWBx_mQM,21234
-claude_mpm/cli/parsers/__init__.py,sha256=f0Fm1DDXorlVOZPLxUpjC-GIvLh01G-FZOK7TEV1L3I,1005
+claude_mpm/cli/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 claude_mpm/cli/parsers/agent_manager_parser.py,sha256=8HuGpTnHSOnTOqOHriBTzi8EzKLMSfqH2eFHs0dEuu4,8009
 claude_mpm/cli/parsers/agents_parser.py,sha256=DxAZMotptyaJbROqbRbTipOKLLJ96ATrXhwiFK6Dbm0,5450
 claude_mpm/cli/parsers/analyze_code_parser.py,sha256=cpJSMFbc3mqB4qrMBIEZiikzPekC2IQX-cjt9U2fHW4,5356
@@ -433,7 +433,7 @@ claude_mpm/services/core/interfaces/agent.py,sha256=EaPYn6k9HjB2DRTiZIMJwEIBABZF
 claude_mpm/services/core/interfaces/communication.py,sha256=evwtLbYCFa3Zb8kEfL10LOBVdwP4-n3a3wa7NqIHmKQ,8887
 claude_mpm/services/core/interfaces/infrastructure.py,sha256=eLtr_dFhA3Ux3mPOV_4DbWhGjHpfpGnj6xOhfQcgZGk,10037
 claude_mpm/services/core/interfaces/service.py,sha256=hNfHXe45LcPCp_dToOmZCfnUZBF5axMf_TdxqCSm2-I,11536
-claude_mpm/services/dashboard/stable_server.py,sha256=vUiWXutYX5kMkSB3_FBuCp9qnlSAT0bnXjNlI9ybe3Q,17752
+claude_mpm/services/dashboard/stable_server.py,sha256=xksZD-iYEvq-MQFnKPZRKFJku4HLiHTMF_5ufP00HyE,38157
 claude_mpm/services/diagnostics/__init__.py,sha256=WTRucANR9EwNi53rotjkeE4k75s18RjHJ8s1BfBj7ic,614
 claude_mpm/services/diagnostics/diagnostic_runner.py,sha256=cpCZ7JBvRIpGEchiwYsojmiGaI99Wf-hGxk8eem7xXQ,9164
 claude_mpm/services/diagnostics/doctor_reporter.py,sha256=Z8hYLqUbGC02gL7nX9kZKbLWRzOmTORRINfCr7EHbBI,10537
@@ -615,9 +615,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=zgiwLqh_17WxHpySvUPH65pb4bzIeUGOAYUJ
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=3Lo6LK-Mw9IdnL_bd3zl_R6FkgSVDYKUUM7EeVVD3jc,20865
 claude_mpm/validation/frontmatter_validator.py,sha256=u8g4Eyd_9O6ugj7Un47oSGh3kqv4wMkuks2i_CtWRvM,7028
-claude_mpm-4.2.5.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.2.5.dist-info/METADATA,sha256=y8K0gWlLWR4tW2V8YD-qp3Q8m9MbjNxVYodwr1oLKQs,13776
-claude_mpm-4.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.2.5.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.2.5.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.2.5.dist-info/RECORD,,
+claude_mpm-4.2.7.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.7.dist-info/METADATA,sha256=sXlWAEREXV1KNO3rmseVO7v1T2wbcvgCByu9WzrrexU,13776
+claude_mpm-4.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.7.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.7.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.7.dist-info/RECORD,,