claude-mpm 4.0.3__py3-none-any.whl → 4.0.8__py3-none-any.whl

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

@@ -464,8 +464,14 @@ class SocketClient {
                 transformedEvent.subtype = 'user_prompt';
             } else {
                 // Generic fallback for unknown event names
-                transformedEvent.type = 'system';
+                // Use 'unknown' for type and the actual eventName for subtype
+                transformedEvent.type = 'unknown';
                 transformedEvent.subtype = eventName.toLowerCase();
+                
+                // Prevent duplicate type/subtype values
+                if (transformedEvent.type === transformedEvent.subtype) {
+                    transformedEvent.subtype = 'event';
+                }
             }
             
             // Remove the 'event' field to avoid confusion
@@ -494,14 +500,28 @@ class SocketClient {
             transformedEvent.subtype = '';
         }
 
+        // Store original event name for display purposes (before any transformation)
+        if (!eventData.type && eventData.event) {
+            transformedEvent.originalEventName = eventData.event;
+        } else if (eventData.type) {
+            transformedEvent.originalEventName = eventData.type;
+        }
+
         // Extract and flatten data fields to top level for dashboard compatibility
         // The dashboard expects fields like tool_name, agent_type, etc. at the top level
         if (eventData.data && typeof eventData.data === 'object') {
-            // Copy all data fields to the top level
+            // Protected fields that should never be overwritten by data fields
+            const protectedFields = ['type', 'subtype', 'timestamp', 'id', 'event', 'event_type', 'originalEventName'];
+            
+            // Copy all data fields to the top level, except protected ones
             Object.keys(eventData.data).forEach(key => {
-                // Always copy data fields to ensure dashboard gets them
-                // This overwrites any existing values to ensure data fields take precedence
-                transformedEvent[key] = eventData.data[key];
+                // Only copy if not a protected field
+                if (!protectedFields.includes(key)) {
+                    transformedEvent[key] = eventData.data[key];
+                } else {
+                    // Log warning if data field would overwrite a protected field
+                    console.warn(`Protected field '${key}' in data object was not copied to top level to preserve event structure`);
+                }
             });
             
             // Keep the original data object for backward compatibility

claude_mpm/hooks/claude_hooks/connection_pool.py

@@ -70,30 +70,78 @@ class SocketIOConnectionPool:
         return None
 
     def _create_connection(self, port: int) -> Optional[Any]:
-        """Create a new Socket.IO connection."""
+        """Create a new Socket.IO connection with persistent keep-alive.
+        
+        WHY persistent connections:
+        - Maintains connection throughout handler lifecycle
+        - Automatic reconnection on disconnect
+        - Reduced connection overhead for multiple events
+        - Better reliability for event delivery
+        """
         if not SOCKETIO_AVAILABLE:
             return None
         try:
             client = socketio.Client(
-                reconnection=False,
+                reconnection=True,  # Enable automatic reconnection
+                reconnection_attempts=5,  # Try to reconnect up to 5 times
+                reconnection_delay=0.5,  # Wait 0.5s between reconnection attempts
+                reconnection_delay_max=2.0,  # Max delay between attempts
                 logger=False,
-                engineio_logger=False,  # Disable auto-reconnect
+                engineio_logger=False,
             )
+            
+            # Set up event handlers for connection lifecycle
+            @client.on('connect')
+            def on_connect():
+                pass  # Connection established
+            
+            @client.on('disconnect')
+            def on_disconnect():
+                pass  # Will automatically try to reconnect
+            
             client.connect(
                 f"http://localhost:{port}",
-                wait=True,
+                wait=True,  # Wait for connection to establish
                 wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT,
+                transports=['websocket', 'polling'],  # Try WebSocket first, fall back to polling
             )
+            
             if client.connected:
+                # Send a keep-alive ping to establish the connection
+                try:
+                    client.emit('ping', {'timestamp': time.time()})
+                except:
+                    pass  # Ignore ping errors
                 return client
         except Exception:
             pass
         return None
 
     def _is_connection_alive(self, client: Any) -> bool:
-        """Check if a connection is still alive."""
+        """Check if a connection is still alive.
+        
+        WHY enhanced check:
+        - Verifies actual connection state
+        - Attempts to ping server for liveness check
+        - More reliable than just checking connected flag
+        """
         try:
-            return client and client.connected
+            if not client:
+                return False
+            
+            # Check basic connection state
+            if not client.connected:
+                return False
+            
+            # Try a quick ping to verify connection is truly alive
+            # This helps detect zombie connections
+            try:
+                # Just emit a ping, don't wait for response (faster)
+                client.emit('ping', {'timestamp': time.time()})
+                return True
+            except:
+                # If ping fails, connection might be dead
+                return client.connected  # Fall back to basic check
         except:
             return False
 
@@ -106,12 +154,27 @@ class SocketIOConnectionPool:
             pass
 
     def _cleanup_dead_connections(self) -> None:
-        """Remove dead connections from the pool."""
-        self.connections = [
-            conn
-            for conn in self.connections
-            if self._is_connection_alive(conn.get("client"))
-        ]
+        """Remove dead connections from the pool and attempt reconnection.
+        
+        WHY proactive reconnection:
+        - Maintains pool health
+        - Ensures connections are ready when needed
+        - Reduces latency for event emission
+        """
+        alive_connections = []
+        for conn in self.connections:
+            client = conn.get("client")
+            if self._is_connection_alive(client):
+                alive_connections.append(conn)
+            else:
+                # Try to reconnect dead connections
+                self._close_connection(client)
+                new_client = self._create_connection(conn.get("port", 8765))
+                if new_client:
+                    conn["client"] = new_client
+                    conn["created"] = time.time()
+                    alive_connections.append(conn)
+        self.connections = alive_connections
 
     def close_all(self) -> None:
         """Close all connections in the pool."""

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -17,6 +17,7 @@ import json
 import os
 import select
 import signal
+import subprocess
 import sys
 import threading
 import time
@@ -434,12 +435,13 @@ class ClaudeHookHandler:
             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 logging.
+        """Emit Socket.IO event with improved reliability and persistent connections.
 
         WHY improved approach:
-        - Better error handling and recovery
-        - Comprehensive event logging for debugging
-        - Automatic reconnection on failure
+        - Maintains persistent connections throughout handler lifecycle
+        - Better error handling and automatic recovery
+        - Connection health monitoring before emission
+        - Automatic reconnection for critical events
         - Validates data before emission
         """
         # Always try to emit Socket.IO events if available
@@ -448,15 +450,56 @@ class ClaudeHookHandler:
         # Get Socket.IO client with dynamic port discovery
         port = self._discover_socketio_port()
         client = self.connection_pool.get_connection(port)
+        
+        # If no client available, try to create one
         if not client:
             if DEBUG:
                 print(
-                    f"Hook handler: No Socket.IO client available for event: hook.{event}",
+                    f"Hook handler: No Socket.IO client available, attempting to create connection for event: hook.{event}",
                     file=sys.stderr,
                 )
-            return
+            # 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()}
+                )
+            else:
+                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:
+                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
+            
             # Format event for Socket.IO server
             claude_event_data = {
                 "type": f"hook.{event}",  # Dashboard expects 'hook.' prefix
@@ -480,19 +523,23 @@ class ClaudeHookHandler:
                         file=sys.stderr,
                     )
 
-            # Emit synchronously with verification
+            # 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}",
+                        f"✅ Successfully emitted Socket.IO event: hook.{event} (connection still active)",
                         file=sys.stderr,
                     )
                 else:
                     print(
-                        f"⚠️ Event emitted but connection status uncertain: hook.{event}",
+                        f"⚠️ Event emitted but connection closed after: hook.{event}",
                         file=sys.stderr,
                     )
 
@@ -507,12 +554,16 @@ class ClaudeHookHandler:
                         f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}",
                         file=sys.stderr,
                     )
-                # Try to get a new client and emit again
-                retry_port = int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
-                retry_client = self.connection_pool.get_connection(retry_port)
+                # 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}",