claude-mpm 4.0.28__py3-none-any.whl → 4.0.30__py3-none-any.whl

claude_mpm/services/socketio/handlers/registry.py

@@ -70,21 +70,31 @@ class EventHandlerRegistry:
             )
             return
 
+        # Add debug logging for deployment context
+        try:
+            from ....core.unified_paths import PathContext
+            deployment_context = PathContext.detect_deployment_context()
+            self.logger.info(f"Initializing event handlers in {deployment_context.value} mode")
+        except Exception as e:
+            self.logger.debug(f"Could not detect deployment context: {e}")
+
         handler_classes = handler_classes or self.DEFAULT_HANDLERS
+        self.logger.debug(f"Initializing {len(handler_classes)} handler classes")
 
         for handler_class in handler_classes:
             try:
+                self.logger.debug(f"Creating instance of {handler_class.__name__}")
                 handler = handler_class(self.server)
                 self.handlers.append(handler)
-                self.logger.info(f"Initialized handler: {handler_class.__name__}")
+                self.logger.info(f"✅ Initialized handler: {handler_class.__name__}")
             except Exception as e:
-                self.logger.error(f"Failed to initialize {handler_class.__name__}: {e}")
+                self.logger.error(f"❌ Failed to initialize {handler_class.__name__}: {e}")
                 import traceback
 
                 self.logger.error(f"Stack trace: {traceback.format_exc()}")
 
         self._initialized = True
-        self.logger.info(f"Registry initialized with {len(self.handlers)} handlers")
+        self.logger.info(f"🎯 Registry initialized with {len(self.handlers)} handlers")
 
     def register_all_events(self) -> None:
         """Register all events from all handlers.
@@ -97,27 +107,49 @@ class EventHandlerRegistry:
             self.logger.error("Registry not initialized. Call initialize() first.")
             raise RuntimeError("EventHandlerRegistry not initialized")
 
+        self.logger.info(f"🔄 Starting event registration for {len(self.handlers)} handlers")
+        
+        # Verify Socket.IO server is available
+        if not hasattr(self.server, 'core') or not self.server.core or not self.server.core.sio:
+            self.logger.error("❌ Socket.IO server instance not available for event registration")
+            raise RuntimeError("Socket.IO server not available")
+        
+        self.logger.debug(f"Socket.IO server available: {type(self.server.core.sio)}")
+
         registered_count = 0
         for handler in self.handlers:
             try:
+                self.logger.debug(f"Registering events for {handler.__class__.__name__}")
+                
+                # Get the number of registered events before and after
+                sio_events_before = len(getattr(self.server.core.sio, 'handlers', {}))
+                
                 handler.register_events()
+                
+                sio_events_after = len(getattr(self.server.core.sio, 'handlers', {}))
+                events_added = sio_events_after - sio_events_before
+                
                 registered_count += 1
-                self.logger.info(f"Registered events for {handler.__class__.__name__}")
+                self.logger.info(f"✅ Registered {events_added} events for {handler.__class__.__name__}")
+                
             except NotImplementedError:
                 # Handler has no events to register (like ProjectEventHandler)
                 self.logger.debug(
-                    f"No events to register for {handler.__class__.__name__}"
+                    f"⏭️  No events to register for {handler.__class__.__name__}"
                 )
             except Exception as e:
                 self.logger.error(
-                    f"Failed to register events for {handler.__class__.__name__}: {e}"
+                    f"❌ Failed to register events for {handler.__class__.__name__}: {e}"
                 )
                 import traceback
 
                 self.logger.error(f"Stack trace: {traceback.format_exc()}")
 
+        # Final verification
+        total_sio_events = len(getattr(self.server.core.sio, 'handlers', {}))
         self.logger.info(
-            f"Successfully registered events from {registered_count} handlers"
+            f"🎉 Event registration complete: {registered_count} handlers processed, "
+            f"{total_sio_events} total Socket.IO events registered"
         )
 
     def add_handler(self, handler_class: Type[BaseEventHandler]):

claude_mpm/services/socketio/server/core.py

@@ -231,15 +231,27 @@ class SocketIOServerCore:
     def _setup_static_files(self):
         """Setup static file serving for the dashboard."""
         try:
+            # Add debug logging for deployment context
+            try:
+                from ....core.unified_paths import PathContext
+                deployment_context = PathContext.detect_deployment_context()
+                self.logger.debug(f"Setting up static files in {deployment_context.value} mode")
+            except Exception as e:
+                self.logger.debug(f"Could not detect deployment context: {e}")
+            
             self.dashboard_path = self._find_static_path()
 
             if self.dashboard_path and self.dashboard_path.exists():
+                self.logger.info(f"✅ Dashboard found at: {self.dashboard_path}")
+                
                 # Serve index.html at root
                 async def index_handler(request):
                     index_file = self.dashboard_path / "index.html"
                     if index_file.exists():
+                        self.logger.debug(f"Serving dashboard index from: {index_file}")
                         return web.FileResponse(index_file)
                     else:
+                        self.logger.warning(f"Dashboard index.html not found at: {index_file}")
                         return web.Response(text="Dashboard not available", status=404)
 
                 self.app.router.add_get("/", index_handler)
@@ -252,10 +264,12 @@ class SocketIOServerCore:
                     self.app.router.add_static(
                         "/static/", dashboard_static_path, name="dashboard_static"
                     )
+                    self.logger.info(f"✅ Static assets available at: {dashboard_static_path}")
                 else:
-                    self.logger.debug(f"Static assets directory not found at: {dashboard_static_path}")
+                    self.logger.warning(f"⚠️  Static assets directory not found at: {dashboard_static_path}")
 
             else:
+                self.logger.warning("⚠️  No dashboard found, serving fallback response")
                 # Fallback handler
                 async def fallback_handler(request):
                     return web.Response(
@@ -266,7 +280,10 @@ class SocketIOServerCore:
                 self.app.router.add_get("/", fallback_handler)
                 
         except Exception as e:
-            self.logger.warning(f"Error setting up static files: {e}")
+            self.logger.error(f"❌ Error setting up static files: {e}")
+            import traceback
+            self.logger.debug(f"Static file setup traceback: {traceback.format_exc()}")
+            
             # Ensure we always have a basic handler
             async def error_handler(request):
                 return web.Response(
@@ -281,40 +298,73 @@ class SocketIOServerCore:
         WHY: The static files location varies depending on how the application
         is installed and run. We try multiple common locations to find them.
         """
+        # Get deployment-context-aware paths
+        try:
+            from ....core.unified_paths import get_path_manager
+            path_manager = get_path_manager()
+            
+            # Use package root for installed packages (including pipx)
+            package_root = path_manager.package_root
+            self.logger.debug(f"Package root: {package_root}")
+            
+            # Use project root for development
+            project_root = get_project_root()
+            self.logger.debug(f"Project root: {project_root}")
+            
+        except Exception as e:
+            self.logger.debug(f"Could not get path manager: {e}")
+            package_root = None
+            project_root = get_project_root()
+
         # Try multiple possible locations for static files and dashboard
         possible_paths = [
-            # Dashboard template directory (primary location)
-            get_project_root() / "src" / "claude_mpm" / "dashboard" / "templates",
-            get_project_root() / "dashboard" / "templates",
-            # Static file directories
-            get_project_root() / "src" / "claude_mpm" / "services" / "static",
-            get_project_root()
-            / "src"
-            / "claude_mpm"
-            / "services"
-            / "socketio"
-            / "static",
-            get_project_root() / "static",
-            get_project_root() / "src" / "static",
-            # Package installation locations
+            # Package-based paths (for pipx and pip installations)
+            package_root / "dashboard" / "templates" if package_root else None,
+            package_root / "services" / "socketio" / "static" if package_root else None,
+            package_root / "static" if package_root else None,
+            
+            # Project-based paths (for development)
+            project_root / "src" / "claude_mpm" / "dashboard" / "templates",
+            project_root / "dashboard" / "templates",
+            project_root / "src" / "claude_mpm" / "services" / "static",
+            project_root / "src" / "claude_mpm" / "services" / "socketio" / "static",
+            project_root / "static",
+            project_root / "src" / "static",
+            
+            # Package installation locations (fallback)
             Path(__file__).parent.parent / "static",
             Path(__file__).parent / "static",
+            
             # Scripts directory (for standalone installations)
             get_scripts_dir() / "static",
             get_scripts_dir() / "socketio" / "static",
+            
             # Current working directory
             Path.cwd() / "static",
             Path.cwd() / "socketio" / "static",
         ]
 
+        # Filter out None values
+        possible_paths = [p for p in possible_paths if p is not None]
+        self.logger.debug(f"Searching {len(possible_paths)} possible static file locations")
+
         for path in possible_paths:
-            if path.exists() and path.is_dir():
-                # Check if it contains expected files
-                if (path / "index.html").exists():
-                    self.logger.debug(f"Found static files at: {path}")
-                    return path
+            self.logger.debug(f"Checking for static files at: {path}")
+            try:
+                if path.exists() and path.is_dir():
+                    # Check if it contains expected files
+                    if (path / "index.html").exists():
+                        self.logger.info(f"✅ Found static files at: {path}")
+                        return path
+                    else:
+                        self.logger.debug(f"Directory exists but no index.html: {path}")
+                else:
+                    self.logger.debug(f"Path does not exist: {path}")
+            except Exception as e:
+                self.logger.debug(f"Error checking path {path}: {e}")
 
-        self.logger.warning("Static files not found - dashboard will not be available")
+        self.logger.warning("⚠️  Static files not found - dashboard will not be available")
+        self.logger.debug(f"Searched paths: {[str(p) for p in possible_paths]}")
         return None
 
     def get_connection_count(self) -> int:

claude_mpm/validation/frontmatter_validator.py

@@ -4,7 +4,7 @@ from pathlib import Path
 Claude Code Frontmatter Validator
 
 Validates agent frontmatter against Claude Code Desktop specification.
-Critical for ensuring agents work correctly with Claude Desktop.
+Critical for ensuring agents work correctly with Claude Code.
 """
 
 import re

{claude_mpm-4.0.28.dist-info → claude_mpm-4.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.28
+Version: 4.0.30
 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
@@ -146,6 +146,9 @@ claude-mpm run --monitor
 # Use MCP Gateway for external tool integration
 claude-mpm mcp
 
+# Run health diagnostics  
+claude-mpm doctor
+
 # Manage memory for large conversation histories
 claude-mpm cleanup-memory
 ```