claude-mpm 4.0.34__py3-none-any.whl → 4.1.0__py3-none-any.whl

claude_mpm/cli/parsers/base_parser.py

@@ -338,6 +338,12 @@ def create_parser(
         from ..commands.cleanup import add_cleanup_parser
 
         add_cleanup_parser(subparsers)
+
+        # MCP pipx configuration command
+        if hasattr(CLICommands, "MCP_PIPX_CONFIG") or True:  # Always add for now
+            from ..commands.mcp_pipx_config import add_parser as add_mcp_pipx_parser
+            
+            add_mcp_pipx_parser(subparsers)
         
         from ..commands.doctor import add_doctor_parser
         

claude_mpm/cli/startup_logging.py

@@ -66,8 +66,10 @@ class StartupStatusLogger:
                     self.logger.info(f"MCP Server: {config_status['servers_count']} server(s) configured")
                 else:
                     self.logger.info("MCP Server: No servers configured")
+                    self._log_mcp_setup_hint()
             else:
                 self.logger.info("MCP Server: No configuration found in ~/.claude.json")
+                self._log_mcp_setup_hint()
             
             # Check for claude-mpm MCP gateway status
             gateway_status = self._check_mcp_gateway_status()
@@ -75,6 +77,9 @@ class StartupStatusLogger:
                 self.logger.info("MCP Gateway: Claude MPM gateway configured")
             else:
                 self.logger.info("MCP Gateway: Claude MPM gateway not configured")
+                # Check if this is a pipx installation that could benefit from auto-config
+                if self._is_pipx_installation() and not self._has_auto_config_preference():
+                    self.logger.info("MCP Gateway: Auto-configuration available for pipx users")
                 
         except Exception as e:
             self.logger.warning(f"MCP Server: Status check failed - {e}")
@@ -293,6 +298,76 @@ class StartupStatusLogger:
             result["error"] = str(e)
         
         return result
+    
+    def _is_pipx_installation(self) -> bool:
+        """Check if this is a pipx installation."""
+        try:
+            # Check if running from pipx
+            if "pipx" in sys.executable.lower():
+                return True
+            
+            # Check module path
+            import claude_mpm
+            module_path = Path(claude_mpm.__file__).parent
+            if "pipx" in str(module_path):
+                return True
+        except Exception:
+            pass
+        
+        return False
+    
+    def _has_auto_config_preference(self) -> bool:
+        """Check if user has already been asked about auto-configuration."""
+        try:
+            from ..config.paths import paths
+            preference_file = paths.claude_mpm_dir_hidden / "mcp_auto_config_preference.json"
+            return preference_file.exists()
+        except Exception:
+            return False
+    
+    def _log_mcp_setup_hint(self) -> None:
+        """Log helpful hints for MCP setup."""
+        # Check if installed via pipx
+        is_pipx = self._check_pipx_installation()
+        
+        if is_pipx:
+            self.logger.info("💡 TIP: It looks like you installed claude-mpm via pipx")
+            self.logger.info("   To configure MCP for Claude Code with pipx:")
+            self.logger.info("   1. Run: python3 scripts/configure_mcp_pipx.py")
+            self.logger.info("   2. Or see: docs/MCP_PIPX_SETUP.md for manual setup")
+            self.logger.info("   3. Restart Claude Code after configuration")
+        else:
+            self.logger.info("💡 TIP: To enable MCP integration with Claude Code:")
+            self.logger.info("   1. See docs/MCP_SETUP.md for setup instructions")
+            self.logger.info("   2. Run: claude-mpm doctor --check mcp to verify")
+            self.logger.info("   3. Restart Claude Code after configuration")
+    
+    def _check_pipx_installation(self) -> bool:
+        """Check if claude-mpm was installed via pipx."""
+        try:
+            # Check if running from a pipx venv
+            if "pipx" in sys.executable.lower():
+                return True
+            
+            # Check if claude-mpm-mcp command exists and is from pipx
+            mcp_cmd = shutil.which("claude-mpm-mcp")
+            if mcp_cmd and "pipx" in mcp_cmd.lower():
+                return True
+            
+            # Try to check pipx list
+            result = subprocess.run(
+                ["pipx", "list"],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            if result.returncode == 0 and "claude-mpm" in result.stdout:
+                return True
+                
+        except Exception:
+            pass
+        
+        return False
 
 
 def setup_startup_logging(project_root: Optional[Path] = None) -> Path:

claude_mpm/dashboard/static/js/components/build-tracker.js

@@ -35,12 +35,46 @@ export class BuildTracker {
     /**
      * Initialize the build tracker component
      */
-    init() {
+    async init() {
         console.log('Initializing BuildTracker component');
+        
+        // Try to load version.json for dashboard version
+        await this.loadDashboardVersion();
+        
         this.createElements();
         this.setupEventListeners();
     }
     
+    /**
+     * Load dashboard version from version.json if available
+     * 
+     * WHY: Attempts to load the actual dashboard version from the 
+     * version.json file created by the version management script.
+     * Falls back to defaults if file is not available.
+     */
+    async loadDashboardVersion() {
+        try {
+            // Try to fetch version.json from the dashboard root
+            const response = await fetch('/version.json');
+            if (response.ok) {
+                const versionData = await response.json();
+                
+                // Update monitor build info with loaded data
+                this.buildInfo.monitor = {
+                    version: versionData.version || "1.0.0",
+                    build: versionData.build || 1,
+                    formatted_build: versionData.formatted_build || "0001",
+                    full_version: versionData.full_version || "v1.0.0-0001"
+                };
+                
+                console.log('Loaded dashboard version:', this.buildInfo.monitor);
+            }
+        } catch (error) {
+            // Silently fall back to defaults if version.json not available
+            console.debug('Dashboard version.json not available, using defaults');
+        }
+    }
+    
     /**
      * Create the DOM elements for version display
      * 

claude_mpm/dashboard/static/js/socket-client.js

@@ -47,7 +47,7 @@ class SocketClient {
         // Health monitoring
         this.lastPingTime = null;
         this.lastPongTime = null;
-        this.pingTimeout = 40000; // 40 seconds (server sends every 30s)
+        this.pingTimeout = 90000; // 90 seconds for health check (more lenient than Socket.IO timeout)
         this.healthCheckInterval = null;
         
         // Start periodic status check as fallback mechanism
@@ -97,11 +97,13 @@ class SocketClient {
             autoConnect: true,
             reconnection: true,
             reconnectionDelay: 1000,
-            reconnectionDelayMax: 10000,
-            maxReconnectionAttempts: 10,
-            timeout: 10000,
+            reconnectionDelayMax: 5000,
+            reconnectionAttempts: Infinity,  // Keep trying indefinitely
+            timeout: 20000,  // Increase connection timeout
             forceNew: true,
-            transports: ['websocket', 'polling']
+            transports: ['websocket', 'polling'],
+            pingInterval: 25000,  // Match server setting
+            pingTimeout: 60000    // Match server setting
         });
 
         this.setupSocketHandlers();

claude_mpm/hooks/claude_hooks/connection_pool.py

@@ -1,7 +1,18 @@
 #!/usr/bin/env python3
-"""Socket.IO connection pool for Claude Code hook handler.
+"""[DEPRECATED] Socket.IO connection pool for Claude Code hook handler.
 
-This module provides connection pooling for Socket.IO clients to reduce
+DEPRECATION NOTICE: As of v4.0.35, this module is deprecated.
+All event emission now goes through the EventBus, which handles
+Socket.IO connections via its relay component. This provides:
+- Single event path (no duplicates)
+- Better separation of concerns
+- Centralized connection management
+- More resilient architecture
+
+This module is kept for backward compatibility but will be removed in v5.0.0.
+Please use EventBus.publish() instead of direct Socket.IO emission.
+
+Original purpose: Provided connection pooling for Socket.IO clients to reduce
 connection overhead and implement circuit breaker patterns.
 """
 

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -60,6 +60,14 @@ except ImportError:
                 }
             })
 
+# Import EventBus for decoupled event distribution
+try:
+    from claude_mpm.services.event_bus import EventBus
+    EVENTBUS_AVAILABLE = True
+except ImportError:
+    EVENTBUS_AVAILABLE = False
+    EventBus = None
+
 # Import constants for configuration
 try:
     from claude_mpm.core.constants import NetworkConfig, RetryConfig, TimeoutConfig
@@ -111,13 +119,23 @@ class ClaudeHookHandler:
     """
 
     def __init__(self):
-        # Socket.IO client (persistent if possible)
-        self.connection_pool = SocketIOConnectionPool(max_connections=3)
         # Track events for periodic cleanup
         self.events_processed = 0
         self.last_cleanup = time.time()
         # Event normalizer for consistent event schema
         self.event_normalizer = EventNormalizer()
+        
+        # Initialize EventBus for decoupled event distribution
+        self.event_bus = None
+        if EVENTBUS_AVAILABLE:
+            try:
+                self.event_bus = EventBus.get_instance()
+                if DEBUG:
+                    print("✅ EventBus initialized for hook handler", file=sys.stderr)
+            except Exception as e:
+                if DEBUG:
+                    print(f"⚠️ Failed to initialize EventBus: {e}", file=sys.stderr)
+                self.event_bus = None
 
         # Maximum sizes for tracking
         self.MAX_DELEGATION_TRACKING = 200
@@ -511,176 +529,61 @@ class ClaudeHookHandler:
         """
         print(json.dumps({"action": "continue"}))
 
-    def _discover_socketio_port(self) -> int:
-        """Discover the port of the running SocketIO server."""
-        try:
-            # Try to import port manager
-            from claude_mpm.services.port_manager import PortManager
-
-            port_manager = PortManager()
-            instances = port_manager.list_active_instances()
-
-            if instances:
-                # Prefer port 8765 if available
-                for instance in instances:
-                    if instance.get("port") == 8765:
-                        return 8765
-                # Otherwise use the first active instance
-                return instances[0].get("port", 8765)
-            else:
-                # No active instances, use default
-                return 8765
-        except Exception:
-            # Fallback to environment variable or default
-            return int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
 
     def _emit_socketio_event(self, namespace: str, event: str, data: dict):
-        """Emit Socket.IO event with improved reliability and event normalization.
-
-        WHY improved approach:
-        - Uses EventNormalizer for consistent event schema
-        - Maintains persistent connections throughout handler lifecycle
-        - Better error handling and automatic recovery
-        - Connection health monitoring before emission
-        - Automatic reconnection for critical events
-        - All events normalized to standard schema before emission
+        """Emit event through EventBus for Socket.IO relay.
+
+        WHY EventBus-only approach:
+        - Single event path prevents duplicates
+        - EventBus relay handles Socket.IO connection management
+        - Better separation of concerns
+        - More resilient with centralized failure handling
+        - Cleaner architecture and easier testing
         """
-        # Always try to emit Socket.IO events if available
-        # The daemon should be running when manager is active
-
-        # Get Socket.IO client with dynamic port discovery
-        port = self._discover_socketio_port()
-        client = self.connection_pool.get_connection(port)
+        # Create event data for normalization
+        raw_event = {
+            "type": "hook",
+            "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop"
+            "timestamp": datetime.now().isoformat(),
+            "data": data,
+            "source": "claude_hooks",  # Identify the source
+            "session_id": data.get("sessionId"),  # Include session if available
+        }
         
-        # If no client available, try to create one
-        if not client:
-            if DEBUG:
+        # Normalize the event using EventNormalizer for consistent schema
+        normalized_event = self.event_normalizer.normalize(raw_event, source="hook")
+        claude_event_data = normalized_event.to_dict()
+
+        # Log important events for debugging
+        if DEBUG and event in ["subagent_stop", "pre_tool"]:
+            if event == "subagent_stop":
+                agent_type = data.get("agent_type", "unknown")
                 print(
-                    f"Hook handler: No Socket.IO client available, attempting to create connection for event: hook.{event}",
+                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
                     file=sys.stderr,
                 )
-            # Force creation of a new connection
-            client = self.connection_pool._create_connection(port)
-            if client:
-                # Add to pool for future use
-                self.connection_pool.connections.append(
-                    {"port": port, "client": client, "created": time.time()}
+            elif event == "pre_tool" and data.get("tool_name") == "Task":
+                delegation = data.get("delegation_details", {})
+                agent_type = delegation.get("agent_type", "unknown")
+                print(
+                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
+                    file=sys.stderr,
                 )
-            else:
+        
+        # Publish to EventBus for distribution through relay
+        if self.event_bus and EVENTBUS_AVAILABLE:
+            try:
+                # Publish to EventBus with topic format: hook.{event}
+                topic = f"hook.{event}"
+                self.event_bus.publish(topic, claude_event_data)
                 if DEBUG:
-                    print(
-                        f"Hook handler: Failed to create Socket.IO connection for event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                return
-
-        try:
-            # Verify connection is alive before emitting
-            if not client.connected:
+                    print(f"✅ Published to EventBus: {topic}", file=sys.stderr)
+            except Exception as e:
                 if DEBUG:
-                    print(
-                        f"Hook handler: Client not connected, attempting reconnection for event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                # Try to reconnect
-                try:
-                    client.connect(
-                        f"http://localhost:{port}",
-                        wait=True,
-                        wait_timeout=1.0,
-                        transports=['websocket', 'polling'],
-                    )
-                except:
-                    # If reconnection fails, get a fresh client
-                    client = self.connection_pool._create_connection(port)
-                    if not client:
-                        if DEBUG:
-                            print(
-                                f"Hook handler: Reconnection failed for event: hook.{event}",
-                                file=sys.stderr,
-                            )
-                        return
-            
-            # Create event data for normalization
-            raw_event = {
-                "type": "hook",
-                "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop"
-                "timestamp": datetime.now().isoformat(),
-                "data": data,
-                "source": "claude_hooks",  # Identify the source
-                "session_id": data.get("sessionId"),  # Include session if available
-            }
-            
-            # Normalize the event using EventNormalizer for consistent schema
-            # Pass source explicitly to ensure it's set correctly
-            normalized_event = self.event_normalizer.normalize(raw_event, source="hook")
-            claude_event_data = normalized_event.to_dict()
-
-            # Log important events for debugging
-            if DEBUG and event in ["subagent_stop", "pre_tool"]:
-                if event == "subagent_stop":
-                    agent_type = data.get("agent_type", "unknown")
-                    print(
-                        f"Hook handler: Emitting SubagentStop for agent '{agent_type}'",
-                        file=sys.stderr,
-                    )
-                elif event == "pre_tool" and data.get("tool_name") == "Task":
-                    delegation = data.get("delegation_details", {})
-                    agent_type = delegation.get("agent_type", "unknown")
-                    print(
-                        f"Hook handler: Emitting Task delegation to agent '{agent_type}'",
-                        file=sys.stderr,
-                    )
-
-            # Emit synchronously
-            client.emit("claude_event", claude_event_data)
-            
-            # For critical events, wait a moment to ensure delivery
-            if event in ["subagent_stop", "pre_tool"]:
-                time.sleep(0.01)  # Small delay to ensure event is sent
-
-            # Verify emission for critical events
-            if event in ["subagent_stop", "pre_tool"] and DEBUG:
-                if client.connected:
-                    print(
-                        f"✅ Successfully emitted Socket.IO event: hook.{event} (connection still active)",
-                        file=sys.stderr,
-                    )
-                else:
-                    print(
-                        f"⚠️ Event emitted but connection closed after: hook.{event}",
-                        file=sys.stderr,
-                    )
-
-        except Exception as e:
+                    print(f"⚠️ Failed to publish to EventBus: {e}", file=sys.stderr)
+        else:
             if DEBUG:
-                print(f"❌ Socket.IO emit failed for hook.{event}: {e}", file=sys.stderr)
-
-            # Try to reconnect immediately for critical events
-            if event in ["subagent_stop", "pre_tool"]:
-                if DEBUG:
-                    print(
-                        f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                # Force get a new client and emit again
-                self.connection_pool._cleanup_dead_connections()
-                retry_client = self.connection_pool._create_connection(port)
-                if retry_client:
-                    try:
-                        retry_client.emit("claude_event", claude_event_data)
-                        # Add to pool for future use
-                        self.connection_pool.connections.append(
-                            {"port": port, "client": retry_client, "created": time.time()}
-                        )
-                        if DEBUG:
-                            print(
-                                f"✅ Successfully re-emitted event after reconnection: hook.{event}",
-                                file=sys.stderr,
-                            )
-                    except Exception as retry_e:
-                        if DEBUG:
-                            print(f"❌ Re-emission failed: {retry_e}", file=sys.stderr)
+                print(f"⚠️ EventBus not available for event: hook.{event}", file=sys.stderr)
 
     def handle_subagent_stop(self, event: dict):
         """Handle subagent stop events with improved agent type detection.
@@ -1012,12 +915,9 @@ class ClaudeHookHandler:
         self._emit_socketio_event("/hook", "subagent_stop", subagent_stop_data)
 
     def __del__(self):
-        """Cleanup Socket.IO connections on handler destruction."""
-        if hasattr(self, "connection_pool") and self.connection_pool:
-            try:
-                self.connection_pool.close_all()
-            except:
-                pass
+        """Cleanup on handler destruction."""
+        # Connection pool no longer used - EventBus handles cleanup
+        pass
 
 
 def main():

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -198,7 +198,10 @@ class AgentDiscoveryService:
                 "name": metadata.get("name", template_file.stem),
                 "description": metadata.get("description", "No description available"),
                 "version": template_data.get(
-                    "agent_version", template_data.get("version", "1.0.0")
+                    "agent_version", 
+                    template_data.get("version", 
+                        metadata.get("version", "1.0.0")
+                    )
                 ),
                 "tools": capabilities.get("tools", []),
                 "specializations": metadata.get(

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -136,7 +136,8 @@ class AgentTemplateBuilder:
         )
 
         # Extract custom metadata fields
-        agent_version = template_data.get("agent_version", "1.0.0")
+        metadata = template_data.get("metadata", {})
+        agent_version = template_data.get("agent_version") or template_data.get("version") or metadata.get("version", "1.0.0")
         agent_type = template_data.get("agent_type", "general")
         # Use the capabilities_model we already extracted earlier
         model_type = capabilities_model or "sonnet"

claude_mpm/services/agents/deployment/agent_version_manager.py

@@ -254,8 +254,11 @@ class AgentVersionManager:
             template_data = json.loads(template_file.read_text())
 
             # Extract agent version from template
+            metadata = template_data.get("metadata", {})
             current_agent_version = self.parse_version(
-                template_data.get("agent_version") or template_data.get("version", 0)
+                template_data.get("agent_version") or 
+                template_data.get("version") or
+                metadata.get("version", 0)
             )
 
             # If old format detected, always trigger update for migration