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

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

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -507,6 +507,7 @@ class MultiSourceAgentDeploymentService:
             "needs_update": [],
             "up_to_date": [],
             "new_agents": [],
+            "orphaned_agents": [],  # Agents without templates
             "version_upgrades": [],
             "version_downgrades": [],
             "source_changes": []
@@ -527,9 +528,11 @@ class MultiSourceAgentDeploymentService:
             # Read template version
             try:
                 template_data = json.loads(template_path.read_text())
+                metadata = template_data.get("metadata", {})
                 template_version = self.version_manager.parse_version(
                     template_data.get("agent_version") or 
-                    template_data.get("version", "0.0.0")
+                    template_data.get("version") or
+                    metadata.get("version", "0.0.0")
                 )
             except Exception as e:
                 self.logger.warning(f"Error reading template for '{agent_name}': {e}")
@@ -597,13 +600,20 @@ class MultiSourceAgentDeploymentService:
                     "source": agent_sources[agent_name]
                 })
         
+        # Check for orphaned agents (deployed but no template)
+        orphaned = self._detect_orphaned_agents_simple(deployed_agents_dir, agents_to_deploy)
+        comparison_results["orphaned_agents"] = orphaned
+        
         # Log summary
-        self.logger.info(
-            f"Version comparison complete: "
-            f"{len(comparison_results['needs_update'])} need updates, "
-            f"{len(comparison_results['up_to_date'])} up to date, "
+        summary_parts = [
+            f"{len(comparison_results['needs_update'])} need updates",
+            f"{len(comparison_results['up_to_date'])} up to date",
             f"{len(comparison_results['new_agents'])} new agents"
-        )
+        ]
+        if comparison_results["orphaned_agents"]:
+            summary_parts.append(f"{len(comparison_results['orphaned_agents'])} orphaned")
+        
+        self.logger.info(f"Version comparison complete: {', '.join(summary_parts)}")
         
         if comparison_results["version_upgrades"]:
             for upgrade in comparison_results["version_upgrades"]:
@@ -622,10 +632,24 @@ class MultiSourceAgentDeploymentService:
         
         if comparison_results["version_downgrades"]:
             for downgrade in comparison_results["version_downgrades"]:
-                self.logger.warning(
-                    f"  Warning: {downgrade['name']} deployed version "
+                # Changed from warning to debug - deployed versions higher than templates
+                # are not errors, just informational
+                self.logger.debug(
+                    f"  Note: {downgrade['name']} deployed version "
                     f"{downgrade['deployed_version']} is higher than template "
-                    f"{downgrade['template_version']}"
+                    f"{downgrade['template_version']} (keeping deployed version)"
+                )
+        
+        # Log orphaned agents if found
+        if comparison_results["orphaned_agents"]:
+            self.logger.info(
+                f"Found {len(comparison_results['orphaned_agents'])} orphaned agent(s) "
+                f"(deployed without templates):"
+            )
+            for orphan in comparison_results["orphaned_agents"]:
+                self.logger.info(
+                    f"  - {orphan['name']} v{orphan['version']} "
+                    f"(consider removing or creating a template)"
                 )
         
         return comparison_results
@@ -692,4 +716,177 @@ class MultiSourceAgentDeploymentService:
             return "system"
         
         # Complex names are more likely to be user/project agents
-        return "user"
+        return "user"
+    
+    def detect_orphaned_agents(
+        self, 
+        deployed_agents_dir: Path,
+        available_agents: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Detect deployed agents that don't have corresponding templates.
+        
+        WHY: Orphaned agents can cause confusion with version warnings.
+        This method identifies them so they can be handled appropriately.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            available_agents: Dictionary of available agents from all sources
+            
+        Returns:
+            List of orphaned agent information
+        """
+        orphaned = []
+        
+        if not deployed_agents_dir.exists():
+            return orphaned
+        
+        # Build a mapping of file stems to agent names for comparison
+        # Since available_agents uses display names like "Code Analysis Agent"
+        # but deployed files use stems like "code_analyzer"
+        available_stems = set()
+        stem_to_name = {}
+        
+        for agent_name, agent_sources in available_agents.items():
+            # Get the file path from the first source to extract the stem
+            if agent_sources and isinstance(agent_sources, list) and len(agent_sources) > 0:
+                first_source = agent_sources[0]
+                if 'file_path' in first_source:
+                    file_path = Path(first_source['file_path'])
+                    stem = file_path.stem
+                    available_stems.add(stem)
+                    stem_to_name[stem] = agent_name
+        
+        for deployed_file in deployed_agents_dir.glob("*.md"):
+            agent_stem = deployed_file.stem
+            
+            # Skip if this agent has a template (check by stem, not display name)
+            if agent_stem in available_stems:
+                continue
+            
+            # This is an orphaned agent
+            try:
+                deployed_content = deployed_file.read_text()
+                deployed_version, _, _ = self.version_manager.extract_version_from_frontmatter(
+                    deployed_content
+                )
+                version_str = self.version_manager.format_version_display(deployed_version)
+            except Exception:
+                version_str = "unknown"
+            
+            orphaned.append({
+                "name": agent_stem,
+                "file": str(deployed_file),
+                "version": version_str
+            })
+        
+        return orphaned
+    
+    def _detect_orphaned_agents_simple(
+        self, 
+        deployed_agents_dir: Path,
+        agents_to_deploy: Dict[str, Path]
+    ) -> List[Dict[str, Any]]:
+        """Simple orphan detection that works with agents_to_deploy structure.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            agents_to_deploy: Dictionary mapping file stems to template paths
+            
+        Returns:
+            List of orphaned agent information
+        """
+        orphaned = []
+        
+        if not deployed_agents_dir.exists():
+            return orphaned
+        
+        # agents_to_deploy already contains file stems as keys
+        available_stems = set(agents_to_deploy.keys())
+        
+        for deployed_file in deployed_agents_dir.glob("*.md"):
+            agent_stem = deployed_file.stem
+            
+            # Skip if this agent has a template (check by stem)
+            if agent_stem in available_stems:
+                continue
+            
+            # This is an orphaned agent
+            try:
+                deployed_content = deployed_file.read_text()
+                deployed_version, _, _ = self.version_manager.extract_version_from_frontmatter(
+                    deployed_content
+                )
+                version_str = self.version_manager.format_version_display(deployed_version)
+            except Exception:
+                version_str = "unknown"
+            
+            orphaned.append({
+                "name": agent_stem,
+                "file": str(deployed_file),
+                "version": version_str
+            })
+        
+        return orphaned
+    
+    def cleanup_orphaned_agents(
+        self,
+        deployed_agents_dir: Path,
+        dry_run: bool = True
+    ) -> Dict[str, Any]:
+        """Clean up orphaned agents that don't have templates.
+        
+        WHY: Orphaned agents can accumulate over time and cause confusion.
+        This method provides a way to clean them up systematically.
+        
+        Args:
+            deployed_agents_dir: Directory containing deployed agents
+            dry_run: If True, only report what would be removed
+            
+        Returns:
+            Dictionary with cleanup results
+        """
+        results = {
+            "orphaned": [],
+            "removed": [],
+            "errors": []
+        }
+        
+        # First, discover all available agents from all sources
+        all_agents = self.discover_agents_from_all_sources()
+        available_names = set(all_agents.keys())
+        
+        # Detect orphaned agents
+        orphaned = self.detect_orphaned_agents(deployed_agents_dir, all_agents)
+        results["orphaned"] = orphaned
+        
+        if not orphaned:
+            self.logger.info("No orphaned agents found")
+            return results
+        
+        self.logger.info(f"Found {len(orphaned)} orphaned agent(s)")
+        
+        for orphan in orphaned:
+            agent_file = Path(orphan["file"])
+            
+            if dry_run:
+                self.logger.info(
+                    f"  Would remove: {orphan['name']} v{orphan['version']}"
+                )
+            else:
+                try:
+                    agent_file.unlink()
+                    results["removed"].append(orphan["name"])
+                    self.logger.info(
+                        f"  Removed: {orphan['name']} v{orphan['version']}"
+                    )
+                except Exception as e:
+                    error_msg = f"Failed to remove {orphan['name']}: {e}"
+                    results["errors"].append(error_msg)
+                    self.logger.error(f"  {error_msg}")
+        
+        if dry_run and orphaned:
+            self.logger.info(
+                "Run with dry_run=False to actually remove orphaned agents"
+            )
+        
+        return results