claude-mpm 4.1.5__py3-none-any.whl → 4.1.7__py3-none-any.whl

claude_mpm/services/event_bus/direct_relay.py

@@ -0,0 +1,230 @@
+"""Direct EventBus to Socket.IO relay that uses server broadcaster.
+
+This module provides a relay that connects EventBus directly to the
+Socket.IO server's broadcaster, avoiding the client loopback issue.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any
+
+from .event_bus import EventBus
+
+logger = logging.getLogger(__name__)
+
+
+class DirectSocketIORelay:
+    """Relay EventBus events directly to Socket.IO broadcaster.
+
+    WHY: The original SocketIORelay creates a client connection back to the server,
+    which causes events to not reach the dashboard properly. This direct relay
+    uses the server's broadcaster directly for proper event emission.
+    """
+
+    def __init__(self, server_instance):
+        """Initialize the direct relay.
+
+        Args:
+            server_instance: The SocketIOServer instance with broadcaster
+        """
+        self.server = server_instance
+        self.event_bus = EventBus.get_instance()
+        self.enabled = True
+        self.connected = False  # Track connection state
+        self.stats = {
+            "events_relayed": 0,
+            "events_failed": 0,
+            "last_relay_time": None,
+        }
+        self.debug = logger.isEnabledFor(logging.DEBUG)
+
+    def start(self) -> None:
+        """Start the relay by subscribing to EventBus events."""
+        if not self.enabled:
+            logger.warning("DirectSocketIORelay is disabled")
+            return
+
+        # Create handler for wildcard events
+        def handle_wildcard_hook_event(event_type: str, data: Any):
+            """Handle wildcard hook events from the event bus.
+
+            Wildcard handlers receive both event_type and data.
+            This is the primary handler that knows the correct event type.
+            """
+            self._handle_hook_event(event_type, data)
+
+        # Subscribe to all hook events via wildcard
+        # This single subscription handles all hook.* events efficiently
+        self.event_bus.on("hook.*", handle_wildcard_hook_event)
+
+        # Add debug logging for verification
+        logger.info("[DirectRelay] Subscribed to hook.* events on EventBus")
+
+        # Check and log broadcaster availability
+        broadcaster_available = (
+            self.server
+            and hasattr(self.server, "broadcaster")
+            and self.server.broadcaster is not None
+        )
+        logger.info(
+            f"[DirectRelay] Server broadcaster available: {broadcaster_available}"
+        )
+        if not broadcaster_available:
+            if not self.server:
+                logger.warning(
+                    "[DirectRelay] No server instance provided - events will not be relayed!"
+                )
+            elif not hasattr(self.server, "broadcaster"):
+                logger.warning(
+                    "[DirectRelay] Server has no broadcaster attribute - events will not be relayed!"
+                )
+            else:
+                logger.warning(
+                    "[DirectRelay] Server broadcaster is None - events will not be relayed!"
+                )
+
+        logger.info(f"[DirectRelay] EventBus instance: {self.event_bus is not None}")
+
+        # Mark as connected after successful subscription
+        self.connected = True
+        logger.info("[DirectRelay] Started and subscribed to hook events")
+
+    def _handle_hook_event(self, event_type: str, data: Any):
+        """Internal method to handle hook events and broadcast them.
+
+        Args:
+            event_type: The event type (e.g., "hook.pre_tool")
+            data: The event data
+        """
+        try:
+            # Enhanced debug logging for troubleshooting
+            if self.debug:
+                logger.debug(f"[DirectRelay] Received event: {event_type}")
+                logger.debug(f"[DirectRelay] Event data type: {type(data).__name__}")
+                logger.debug(
+                    f"[DirectRelay] Event data keys: {list(data.keys()) if isinstance(data, dict) else 'not-dict'}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Relay state - enabled: {self.enabled}, connected: {self.connected}"
+                )
+                logger.debug(
+                    f"[DirectRelay] Server state - has_server: {self.server is not None}, has_broadcaster: {self.server and hasattr(self.server, 'broadcaster') and self.server.broadcaster is not None}"
+                )
+
+            # Always log reception of important events
+            if event_type in [
+                "hook.pre_tool",
+                "hook.post_tool",
+                "hook.user_prompt",
+                "hook.subagent_stop",
+            ]:
+                logger.info(f"[DirectRelay] Processing important event: {event_type}")
+
+            # Only relay hook events
+            if event_type.startswith("hook."):
+                # Extract the event subtype from the event_type (e.g., "hook.pre_tool" -> "pre_tool")
+                event_subtype = (
+                    event_type.split(".", 1)[1] if "." in event_type else event_type
+                )
+
+                # The data passed to us is the raw event data from the publisher
+                # We don't need to extract anything - just use it as is
+                actual_data = data
+
+                # Always log important hook events for debugging
+                if event_subtype in [
+                    "pre_tool",
+                    "post_tool",
+                    "user_prompt",
+                    "subagent_stop",
+                ]:
+                    logger.info(f"[DirectRelay] Processing {event_type} event")
+
+                # Use the server's broadcaster directly
+                if self.server and self.server.broadcaster:
+                    # Log debug info about the broadcaster state
+                    if self.debug:
+                        has_sio = (
+                            hasattr(self.server.broadcaster, "sio")
+                            and self.server.broadcaster.sio is not None
+                        )
+                        has_loop = (
+                            hasattr(self.server.broadcaster, "loop")
+                            and self.server.broadcaster.loop is not None
+                        )
+                        logger.debug(
+                            f"[DirectRelay] Broadcaster state - has_sio: {has_sio}, has_loop: {has_loop}"
+                        )
+                        logger.debug(
+                            f"[DirectRelay] Event subtype: {event_subtype}, data keys: {list(actual_data.keys()) if isinstance(actual_data, dict) else 'not-dict'}"
+                        )
+
+                    # The broadcaster's broadcast_event expects an event_type string and data dict
+                    # The EventNormalizer will map dotted event names like "hook.pre_tool" correctly
+                    # So we pass the full event_type (e.g., "hook.pre_tool") as the event name
+                    # This way the normalizer will correctly extract type="hook" and subtype="pre_tool"
+
+                    # Prepare the broadcast data - just the actual event data
+                    broadcast_data = (
+                        actual_data
+                        if isinstance(actual_data, dict)
+                        else {"data": actual_data}
+                    )
+
+                    # Use the full event_type (e.g., "hook.pre_tool") as the event name
+                    # The normalizer handles dotted names and will extract type and subtype correctly
+                    self.server.broadcaster.broadcast_event(event_type, broadcast_data)
+
+                    self.stats["events_relayed"] += 1
+                    self.stats["last_relay_time"] = datetime.now().isoformat()
+
+                    if self.debug:
+                        logger.debug(
+                            f"[DirectRelay] Broadcasted hook event: {event_type}"
+                        )
+                else:
+                    # Enhanced logging when broadcaster is not available
+                    logger.warning(
+                        f"[DirectRelay] Server broadcaster not available for {event_type}"
+                    )
+                    if self.server:
+                        logger.warning(
+                            f"[DirectRelay] Server exists but broadcaster is None"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server type: {type(self.server).__name__}"
+                        )
+                        logger.warning(
+                            f"[DirectRelay] Server has broadcaster attr: {hasattr(self.server, 'broadcaster')}"
+                        )
+                        if hasattr(self.server, "broadcaster"):
+                            logger.warning(
+                                f"[DirectRelay] Broadcaster value: {self.server.broadcaster}"
+                            )
+                    else:
+                        logger.warning(f"[DirectRelay] Server is None")
+                    self.stats["events_failed"] += 1
+
+        except Exception as e:
+            self.stats["events_failed"] += 1
+            logger.error(f"[DirectRelay] Failed to relay event {event_type}: {e}")
+
+    def stop(self) -> None:
+        """Stop the relay."""
+        self.enabled = False
+        self.connected = False
+        # EventBus doesn't provide an off() method, so listeners remain
+        # but the enabled flag prevents processing
+        logger.info("[DirectRelay] Stopped")
+
+    def get_stats(self) -> dict:
+        """Get relay statistics."""
+        return {
+            "enabled": self.enabled,
+            "connected": self.connected,
+            "events_relayed": self.stats["events_relayed"],
+            "events_failed": self.stats["events_failed"],
+            "last_relay_time": self.stats["last_relay_time"],
+            "has_server": self.server is not None,
+            "has_broadcaster": self.server and self.server.broadcaster is not None,
+        }

claude_mpm/services/socketio/handlers/connection_handler.py

@@ -0,0 +1,330 @@
+"""
+Enhanced Connection Event Handler for Socket.IO.
+
+WHY: This module provides robust connection handling with state tracking,
+event replay on reconnection, and health monitoring integration.
+
+DESIGN DECISION: Centralized connection event handling ensures consistent
+state management and provides resilient event delivery across reconnections.
+"""
+
+from datetime import datetime
+
+from .base import BaseEventHandler
+
+
+class EnhancedConnectionEventHandler(BaseEventHandler):
+    """
+    Handles Socket.IO connection events with enhanced robustness.
+
+    Features:
+    - Persistent client tracking across reconnections
+    - Event replay on reconnection
+    - Connection health monitoring
+    - Acknowledgment system for guaranteed delivery
+    """
+
+    def register_events(self):
+        """Register enhanced connection event handlers."""
+        sio = self.server.core.sio
+
+        @sio.event
+        async def connect(sid, environ, auth):
+            """Handle client connection with enhanced tracking."""
+            try:
+                # Extract client ID from auth or create new
+                client_id = None
+                if auth and isinstance(auth, dict):
+                    client_id = auth.get("client_id")
+
+                # Register connection with manager
+                if self.server.connection_manager:
+                    conn = await self.server.connection_manager.register_connection(
+                        sid, client_id
+                    )
+
+                    # Add to server's connected clients
+                    self.server.connected_clients.add(sid)
+                    self.server.stats["connections_total"] += 1
+
+                    # Store client info
+                    self.server.client_info[sid] = {
+                        "client_id": conn.client_id,
+                        "connected_at": datetime.now().isoformat(),
+                        "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
+                        "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
+                    }
+
+                    # Send client ID back for future reconnections
+                    await sio.emit(
+                        "connection_established",
+                        {
+                            "client_id": conn.client_id,
+                            "sid": sid,
+                            "timestamp": datetime.now().isoformat(),
+                            "server_version": self.get_server_version(),
+                        },
+                        room=sid,
+                    )
+
+                    # Send current server status
+                    await self._send_server_status(sid)
+
+                    # Check for events to replay
+                    last_sequence = 0
+                    if auth and isinstance(auth, dict):
+                        last_sequence = auth.get("last_sequence", 0)
+
+                    if last_sequence > 0:
+                        replay_events = (
+                            await self.server.connection_manager.get_replay_events(
+                                sid, last_sequence
+                            )
+                        )
+
+                        if replay_events:
+                            self.logger.info(
+                                f"Replaying {len(replay_events)} events for client {conn.client_id}"
+                            )
+
+                            # Send replay events in batch
+                            await sio.emit(
+                                "event_replay",
+                                {
+                                    "events": replay_events,
+                                    "count": len(replay_events),
+                                    "from_sequence": last_sequence,
+                                },
+                                room=sid,
+                            )
+
+                    # Send event history for initial population
+                    if (
+                        hasattr(self.server, "event_history")
+                        and self.server.event_history
+                    ):
+                        history_data = list(self.server.event_history)
+                        await sio.emit(
+                            "event_history",
+                            {"events": history_data, "count": len(history_data)},
+                            room=sid,
+                        )
+
+                    self.logger.info(
+                        f"Client connected: {conn.client_id} (sid: {sid}, "
+                        f"reconnect: {conn.metrics.reconnect_count > 0})"
+                    )
+                else:
+                    # Fallback to basic connection tracking
+                    self.server.connected_clients.add(sid)
+                    self.server.stats["connections_total"] += 1
+
+                    self.server.client_info[sid] = {
+                        "connected_at": datetime.now().isoformat(),
+                        "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
+                        "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
+                    }
+
+                    await self._send_server_status(sid)
+
+                    if (
+                        hasattr(self.server, "event_history")
+                        and self.server.event_history
+                    ):
+                        history_data = list(self.server.event_history)
+                        await sio.emit(
+                            "event_history",
+                            {"events": history_data, "count": len(history_data)},
+                            room=sid,
+                        )
+
+                    self.logger.info(f"Client connected: {sid}")
+
+            except Exception as e:
+                self.logger.error(f"Error handling connection for {sid}: {e}")
+
+        @sio.event
+        async def disconnect(sid):
+            """Handle client disconnection with state preservation."""
+            try:
+                # Get disconnection reason if available
+                reason = "client_disconnect"
+
+                # Unregister from connection manager but preserve state
+                if self.server.connection_manager:
+                    await self.server.connection_manager.unregister_connection(
+                        sid, reason
+                    )
+
+                # Remove from connected clients
+                if sid in self.server.connected_clients:
+                    self.server.connected_clients.remove(sid)
+
+                # Remove client info
+                if sid in self.server.client_info:
+                    client_info = self.server.client_info[sid]
+                    del self.server.client_info[sid]
+
+                    client_id = client_info.get("client_id", sid)
+                    self.logger.info(f"Client disconnected: {client_id} (sid: {sid})")
+                else:
+                    self.logger.info(f"Client disconnected: {sid}")
+
+            except Exception as e:
+                self.logger.error(f"Error handling disconnection for {sid}: {e}")
+
+        @sio.event
+        async def ping(sid):
+            """Handle ping from client for health monitoring."""
+            try:
+                # Update activity in connection manager - CRITICAL for preventing stale connections
+                if self.server.connection_manager:
+                    await self.server.connection_manager.update_activity(sid, "ping")
+
+                # Send pong response with timestamp
+                await sio.emit(
+                    "pong",
+                    {
+                        "timestamp": datetime.now().isoformat(),
+                        "server_time": datetime.now().timestamp(),
+                    },
+                    room=sid,
+                )
+
+            except Exception as e:
+                self.logger.error(f"Error handling ping from {sid}: {e}")
+
+        @sio.event
+        async def acknowledge_event(sid, data):
+            """Handle event acknowledgment from client."""
+            try:
+                if not isinstance(data, dict):
+                    return
+
+                sequence = data.get("sequence")
+                if sequence and self.server.connection_manager:
+                    await self.server.connection_manager.acknowledge_event(
+                        sid, sequence
+                    )
+
+                    # Optional: Send confirmation
+                    await sio.emit(
+                        "ack_confirmed",
+                        {"sequence": sequence, "timestamp": datetime.now().isoformat()},
+                        room=sid,
+                    )
+
+            except Exception as e:
+                self.logger.error(f"Error handling acknowledgment from {sid}: {e}")
+
+        @sio.event
+        async def request_replay(sid, data):
+            """Handle replay request from client after reconnection."""
+            try:
+                if not isinstance(data, dict):
+                    return
+
+                last_sequence = data.get("last_sequence", 0)
+
+                if self.server.connection_manager:
+                    replay_events = (
+                        await self.server.connection_manager.get_replay_events(
+                            sid, last_sequence
+                        )
+                    )
+
+                    if replay_events:
+                        await sio.emit(
+                            "event_replay",
+                            {
+                                "events": replay_events,
+                                "count": len(replay_events),
+                                "from_sequence": last_sequence,
+                            },
+                            room=sid,
+                        )
+                    else:
+                        await sio.emit(
+                            "event_replay",
+                            {
+                                "events": [],
+                                "count": 0,
+                                "from_sequence": last_sequence,
+                                "message": "No events to replay",
+                            },
+                            room=sid,
+                        )
+
+            except Exception as e:
+                self.logger.error(f"Error handling replay request from {sid}: {e}")
+
+        @sio.event
+        async def get_connection_stats(sid):
+            """Get connection statistics for debugging."""
+            try:
+                stats = {
+                    "timestamp": datetime.now().isoformat(),
+                    "total_connections": len(self.server.connected_clients),
+                    "server_stats": self.server.stats,
+                }
+
+                if self.server.connection_manager:
+                    conn = self.server.connection_manager.get_connection(sid)
+                    if conn:
+                        stats["connection"] = {
+                            "client_id": conn.client_id,
+                            "state": conn.state.value,
+                            "connected_at": conn.connected_at,
+                            "quality": conn.calculate_quality(),
+                            "metrics": {
+                                "events_sent": conn.metrics.events_sent,
+                                "events_acked": conn.metrics.events_acked,
+                                "events_buffered": conn.metrics.events_buffered,
+                                "reconnect_count": conn.metrics.reconnect_count,
+                            },
+                        }
+
+                    stats["manager_metrics"] = (
+                        self.server.connection_manager.get_metrics()
+                    )
+
+                await sio.emit("connection_stats", stats, room=sid)
+
+            except Exception as e:
+                self.logger.error(f"Error getting connection stats for {sid}: {e}")
+
+        # Heartbeat handler removed - Using Socket.IO's built-in ping/pong instead
+        # This prevents conflicting heartbeat systems that can cause disconnections
+
+        self.logger.info("Enhanced connection event handlers registered")
+
+    async def _send_server_status(self, sid: str):
+        """Send current server status to a client."""
+        try:
+            status_data = {
+                "server_running": self.server.running,
+                "claude_status": self.server.claude_status,
+                "claude_pid": self.server.claude_pid,
+                "session_id": self.server.session_id,
+                "connected_clients": len(self.server.connected_clients),
+                "server_start_time": (
+                    self.server.stats.get("start_time").isoformat()
+                    if self.server.stats.get("start_time")
+                    else None
+                ),
+                "timestamp": datetime.now().isoformat(),
+            }
+
+            await self.server.core.sio.emit("server_status", status_data, room=sid)
+
+        except Exception as e:
+            self.logger.error(f"Error sending server status to {sid}: {e}")
+
+    def get_server_version(self) -> str:
+        """Get server version for client info."""
+        try:
+            from claude_mpm.services.version_service import VersionService
+
+            return VersionService().get_version()
+        except:
+            return "unknown"

claude_mpm/services/socketio/server/broadcaster.py

@@ -153,6 +153,7 @@ class SocketIOEventBroadcaster:
         stats: Dict[str, Any],
         logger,
         server=None,  # Add server reference for event history access
+        connection_manager=None,  # Add connection manager for robust delivery
     ):
         self.sio = sio
         self.connected_clients = connected_clients
@@ -162,6 +163,7 @@ class SocketIOEventBroadcaster:
         self.logger = logger
         self.loop = None  # Will be set by main server
         self.server = server  # Reference to main server for event history
+        self.connection_manager = connection_manager  # For connection tracking
 
         # Initialize retry queue for resilient delivery
         self.retry_queue = RetryQueue(max_size=1000)
@@ -313,7 +315,7 @@ class SocketIOEventBroadcaster:
 
         WHY: Enhanced with retry queue to ensure reliable delivery
         even during transient network issues. Now uses EventNormalizer
-        to ensure consistent event schema.
+        to ensure consistent event schema and ConnectionManager for tracking.
         """
         if not self.sio:
             return
@@ -342,6 +344,18 @@ class SocketIOEventBroadcaster:
                     f"Added {event['type']}/{event['subtype']} to history (total: {len(self.server.event_history)})"
                 )
 
+        # If we have a connection manager, buffer event for all connected clients
+        if self.connection_manager and self.loop:
+            # Buffer for each connected client asynchronously
+            async def buffer_for_clients():
+                for sid in list(self.connected_clients):
+                    await self.connection_manager.buffer_event(sid, event)
+
+            try:
+                asyncio.run_coroutine_threadsafe(buffer_for_clients(), self.loop)
+            except Exception as e:
+                self.logger.warning(f"Failed to buffer event for clients: {e}")
+
         # Broadcast to all connected clients
         broadcast_success = False
         try:
@@ -360,6 +374,23 @@ class SocketIOEventBroadcaster:
                     future.result(timeout=0.5)  # 500ms timeout
                     broadcast_success = True
                     self.stats["events_sent"] += 1
+
+                    # Update activity for all connected clients
+                    if self.connection_manager:
+
+                        async def update_activities():
+                            for sid in list(self.connected_clients):
+                                await self.connection_manager.update_activity(
+                                    sid, "event"
+                                )
+
+                        try:
+                            asyncio.run_coroutine_threadsafe(
+                                update_activities(), self.loop
+                            )
+                        except:
+                            pass  # Non-critical
+
                     self.logger.debug(f"Broadcasted event: {event_type}")
                 except:
                     # Will be added to retry queue below