claude-mpm 4.2.5__tar.gz → 4.2.6__tar.gz

claude_mpm-4.2.6/BUILD_NUMBER

@@ -0,0 +1 @@
+337

{claude_mpm-4.2.5 → claude_mpm-4.2.6}/PKG-INFO

@@ -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.6/VERSION

@@ -0,0 +1 @@
+4.2.6

{claude_mpm-4.2.5 → claude_mpm-4.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.2.5"
+version = "4.2.6"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -248,7 +248,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.2.5"
+version = "4.2.6"
 version_files = [
     "VERSION",
     "src/claude_mpm/VERSION",

claude_mpm-4.2.6/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.6

{claude_mpm-4.2.5 → claude_mpm-4.2.6}/src/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-4.2.5 → claude_mpm-4.2.6}/src/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 → claude_mpm-4.2.6}/src/claude_mpm.egg-info/PKG-INFO

@@ -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/BUILD_NUMBER

@@ -1 +0,0 @@
-336

claude_mpm-4.2.5/VERSION

@@ -1 +0,0 @@
-4.2.5

claude_mpm-4.2.5/src/claude_mpm/VERSION

@@ -1 +0,0 @@
-4.2.5