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

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.5
+4.2.6

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,98 @@ 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)
+                if stable_server.run():
+                    server_started = True
+                    return CommandResult.success_result("Dashboard server stopped")
+                else:
+                    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/services/dashboard/stable_server.py

@@ -168,6 +168,8 @@ class StableDashboardServer:
         self.dashboard_path = None
         self.app = None
         self.sio = None
+        self.server_runner = None
+        self.server_site = None
 
     def setup(self) -> bool:
         """Set up the server components."""
@@ -184,13 +186,22 @@ class StableDashboardServer:
             print("Please ensure Claude MPM is 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
@@ -220,8 +231,13 @@ class StableDashboardServer:
 
         @self.sio.event
         async def connect(sid, environ):
-            print(f"✅ SocketIO client connected: {sid}")
-            print(f"   Client info: {environ.get('HTTP_USER_AGENT', 'Unknown')}")
+            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 a test message to confirm connection
             await self.sio.emit(
                 "connection_test", {"status": "connected", "server": "stable"}, room=sid
@@ -229,13 +245,15 @@ class StableDashboardServer:
 
         @self.sio.event
         async def disconnect(sid):
-            print(f"❌ SocketIO client disconnected: {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 +261,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 +279,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,14 +303,16 @@ 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)
 
     async def _serve_dashboard(self, request):
@@ -417,14 +442,19 @@ class StableDashboardServer:
 
         print(f"🚀 Starting stable dashboard server at http://{self.host}:{self.port}")
         print("✅ Server ready: HTTP + SocketIO on same port")
+        print("🎯 This is a standalone server - no monitor service required")
         print("📡 SocketIO events registered:")
         print("   - connect/disconnect")
-        print("   - code_analyze_file (from 'code:analyze:file')")
+        print("   - code:analyze:file (code analysis)")
+        print("   - Various dashboard events")
         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("   - GET /api/directory/list (directory listing)")
+        print("   - GET /api/file/read (file content)")
+        print("   - GET /version.json (version info)")
+        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 +462,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)
+                # 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
+                    )
                 break  # Server started successfully
             except KeyboardInterrupt:
                 print("\n🛑 Server stopped by user")
                 break
             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 +493,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.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.5
+Version: 4.2.6
 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.6.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=y3hGbi5SzvubCW71VVd9sntScYZDVej66mVma8oVl-k,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=68IZaSMFKnroaclKsORYaVu7jYV9jWH9sAeD1QHolIo,14097
 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
@@ -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=151lEl_uz28szFpUNc9lSCsNoTBP48IqxXuF_KpmYHU,19984
 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.6.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.6.dist-info/METADATA,sha256=w4lTcx_Man2orXEGeND6EOxlXQQb6kc1UcF6-XaDeeQ,13776
+claude_mpm-4.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.6.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.6.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.6.dist-info/RECORD,,