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

claude_mpm/services/socketio/server/connection_manager.py

@@ -10,6 +10,7 @@ of client states, proper event delivery, and automatic recovery mechanisms.
 """
 
 import asyncio
+import contextlib
 import time
 from collections import deque
 from dataclasses import dataclass, field
@@ -70,11 +71,11 @@ class ClientConnection:
     metrics: ConnectionMetrics = field(default_factory=ConnectionMetrics)
     metadata: Dict[str, Any] = field(default_factory=dict)
 
-    def is_healthy(self, timeout: float = 180.0) -> bool:
+    def is_healthy(self, timeout: float = 90.0) -> bool:
         """Check if connection is healthy based on activity.
-        
+
         Args:
-            timeout: Seconds before considering connection unhealthy (default 180s)
+            timeout: Seconds before considering connection unhealthy (default 90s)
         """
         if self.state != ConnectionState.CONNECTED:
             return False
@@ -91,9 +92,9 @@ class ClientConnection:
             self.connected_at,
         )
 
-        # Add grace period for network hiccups (additional 10% of timeout)
-        grace_period = timeout * 1.1
-        return (now - last_activity) < grace_period
+        # More aggressive timeout for stale detection (no grace period)
+        # This helps identify truly stale connections faster
+        return (now - last_activity) < timeout
 
     def calculate_quality(self) -> float:
         """Calculate connection quality score (0-1)."""
@@ -148,7 +149,7 @@ class ConnectionManager:
     - Automatic event replay on reconnection
     """
 
-    def __init__(self, max_buffer_size: int = None, event_ttl: int = None):
+    def __init__(self, max_buffer_size: Optional[int] = None, event_ttl: Optional[int] = None):
         """
         Initialize connection manager with centralized configuration.
 
@@ -157,17 +158,19 @@ class ConnectionManager:
             event_ttl: Time-to-live for buffered events in seconds (uses config if None)
         """
         from ....config.socketio_config import CONNECTION_CONFIG
-        
+
         self.logger = get_logger(__name__)
         self.connections: Dict[str, ClientConnection] = {}
         self.client_mapping: Dict[str, str] = {}  # client_id -> current sid
-        
+
         # Use centralized configuration with optional overrides
-        self.max_buffer_size = max_buffer_size or CONNECTION_CONFIG['max_events_buffer']
-        self.event_ttl = event_ttl or CONNECTION_CONFIG['event_ttl']
+        self.max_buffer_size = max_buffer_size or CONNECTION_CONFIG["max_events_buffer"]
+        self.event_ttl = event_ttl or CONNECTION_CONFIG["event_ttl"]
         self.global_sequence = 0
-        self.health_check_interval = CONNECTION_CONFIG['health_check_interval']  # 30 seconds
-        self.stale_timeout = CONNECTION_CONFIG['stale_timeout']  # 180 seconds (was 90)
+        self.health_check_interval = CONNECTION_CONFIG[
+            "health_check_interval"
+        ]  # 30 seconds
+        self.stale_timeout = CONNECTION_CONFIG["stale_timeout"]  # 180 seconds (was 90)
         self.health_task = None
         self._lock = asyncio.Lock()
 
@@ -175,7 +178,7 @@ class ConnectionManager:
         self, sid: str, client_id: Optional[str] = None
     ) -> ClientConnection:
         """
-        Register a new connection or reconnection.
+        Register a new connection or reconnection with retry logic.
 
         Args:
             sid: Socket ID
@@ -184,54 +187,84 @@ class ConnectionManager:
         Returns:
             ClientConnection object
         """
-        async with self._lock:
-            now = time.time()
-
-            # Check if this is a reconnection
-            if client_id and client_id in self.client_mapping:
-                old_sid = self.client_mapping[client_id]
-                if old_sid in self.connections:
-                    old_conn = self.connections[old_sid]
+        max_retries = 3
+        retry_delay = 0.1  # Start with 100ms
 
-                    # Create new connection with history
-                    conn = ClientConnection(
-                        sid=sid,
-                        client_id=client_id,
-                        state=ConnectionState.CONNECTED,
-                        connected_at=now,
-                        event_buffer=old_conn.event_buffer,
-                        event_sequence=old_conn.event_sequence,
-                        last_acked_sequence=old_conn.last_acked_sequence,
-                        metrics=old_conn.metrics,
-                    )
+        for attempt in range(max_retries):
+            try:
+                async with self._lock:
+                    now = time.time()
+
+                    # Check if this is a reconnection
+                    if client_id and client_id in self.client_mapping:
+                        old_sid = self.client_mapping[client_id]
+                        if old_sid in self.connections:
+                            old_conn = self.connections[old_sid]
+
+                            # Create new connection with history
+                            conn = ClientConnection(
+                                sid=sid,
+                                client_id=client_id,
+                                state=ConnectionState.CONNECTED,
+                                connected_at=now,
+                                event_buffer=old_conn.event_buffer,
+                                event_sequence=old_conn.event_sequence,
+                                last_acked_sequence=old_conn.last_acked_sequence,
+                                metrics=old_conn.metrics,
+                            )
 
-                    # Update metrics
-                    conn.metrics.reconnect_count += 1
-                    conn.metrics.connect_count += 1
-                    if old_conn.disconnected_at:
-                        conn.metrics.total_downtime += now - old_conn.disconnected_at
+                            # Update metrics
+                            conn.metrics.reconnect_count += 1
+                            conn.metrics.connect_count += 1
+                            if old_conn.disconnected_at:
+                                conn.metrics.total_downtime += (
+                                    now - old_conn.disconnected_at
+                                )
 
-                    # Clean up old connection
-                    del self.connections[old_sid]
+                            # Clean up old connection
+                            del self.connections[old_sid]
 
-                    self.logger.info(
-                        f"Client {client_id} reconnected (new sid: {sid}, "
-                        f"buffered events: {len(conn.event_buffer)})"
-                    )
-                else:
-                    # No old connection found, create new
-                    client_id = client_id or str(uuid4())
-                    conn = self._create_new_connection(sid, client_id, now)
-            else:
-                # New client
-                client_id = client_id or str(uuid4())
-                conn = self._create_new_connection(sid, client_id, now)
+                            self.logger.info(
+                                f"Client {client_id} reconnected (new sid: {sid}, "
+                                f"buffered events: {len(conn.event_buffer)})"
+                            )
+                        else:
+                            # No old connection found, create new
+                            client_id = client_id or str(uuid4())
+                            conn = self._create_new_connection(sid, client_id, now)
+                    else:
+                        # New client
+                        client_id = client_id or str(uuid4())
+                        conn = self._create_new_connection(sid, client_id, now)
 
-            # Register connection
-            self.connections[sid] = conn
-            self.client_mapping[client_id] = sid
+                    # Register connection with validation
+                    if conn and conn.state == ConnectionState.CONNECTED:
+                        self.connections[sid] = conn
+                        self.client_mapping[client_id] = sid
+                        return conn
+                    raise ValueError(f"Invalid connection state for {sid}")
 
-            return conn
+            except Exception as e:
+                self.logger.warning(
+                    f"Failed to register connection {sid} (attempt {attempt + 1}/{max_retries}): {e}"
+                )
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 2  # Exponential backoff
+                else:
+                    # Final attempt failed, create minimal connection
+                    self.logger.error(
+                        f"All attempts failed for {sid}, creating minimal connection"
+                    )
+                    conn = ClientConnection(
+                        sid=sid,
+                        client_id=client_id or str(uuid4()),
+                        state=ConnectionState.CONNECTED,
+                        connected_at=time.time(),
+                    )
+                    self.connections[sid] = conn
+                    return conn
+        return None
 
     def _create_new_connection(
         self, sid: str, client_id: str, now: float
@@ -403,10 +436,8 @@ class ConnectionManager:
         """Stop the health monitoring task."""
         if self.health_task:
             self.health_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self.health_task
-            except asyncio.CancelledError:
-                pass
             self.health_task = None
             self.logger.info("Stopped connection health monitoring")
 
@@ -460,7 +491,7 @@ class ConnectionManager:
                             conn.connected_at,
                         )
                         time_since_activity = now - last_activity
-                        
+
                         # Only mark as stale if significantly over timeout (2x)
                         if time_since_activity > (self.stale_timeout * 2):
                             conn.state = ConnectionState.STALE
@@ -476,15 +507,14 @@ class ConnectionManager:
                                 f"Connection {conn.client_id} borderline "
                                 f"(last activity: {time_since_activity:.1f}s ago)"
                             )
-                            
+
                 elif conn.state == ConnectionState.DISCONNECTED:
                     report["disconnected"] += 1
 
                     # Clean up old disconnected connections (be conservative)
-                    if (
-                        conn.disconnected_at
-                        and (now - conn.disconnected_at) > (self.event_ttl * 2)  # Double the TTL
-                    ):
+                    if conn.disconnected_at and (now - conn.disconnected_at) > (
+                        self.event_ttl * 2
+                    ):  # Double the TTL
                         to_clean.append(sid)
 
             # Clean up old connections

claude_mpm/services/socketio/server/core.py

@@ -160,22 +160,38 @@ class SocketIOServerCore:
         try:
             # Import centralized configuration for consistency
             from ....config.socketio_config import CONNECTION_CONFIG
-            
+
             # Create Socket.IO server with centralized configuration
             # CRITICAL: These values MUST match client settings to prevent disconnections
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
                 logger=False,  # Disable Socket.IO's own logging
                 engineio_logger=False,
-                ping_interval=CONNECTION_CONFIG['ping_interval'],  # 45 seconds from config
-                ping_timeout=CONNECTION_CONFIG['ping_timeout'],    # 20 seconds from config
-                max_http_buffer_size=CONNECTION_CONFIG['max_http_buffer_size'],  # 100MB from config
+                ping_interval=CONNECTION_CONFIG[
+                    "ping_interval"
+                ],  # 45 seconds from config
+                ping_timeout=CONNECTION_CONFIG[
+                    "ping_timeout"
+                ],  # 20 seconds from config
+                max_http_buffer_size=CONNECTION_CONFIG[
+                    "max_http_buffer_size"
+                ],  # 100MB from config
             )
 
             # Create aiohttp application
             self.app = web.Application()
             self.sio.attach(self.app)
 
+            # CRITICAL: Register event handlers BEFORE starting the server
+            # This ensures handlers are ready when clients connect
+            if self.main_server and hasattr(self.main_server, "_register_events_async"):
+                self.logger.info(
+                    "Registering Socket.IO event handlers before server start"
+                )
+                await self.main_server._register_events_async()
+            else:
+                self.logger.warning("Main server not available for event registration")
+
             # Setup HTTP API endpoints for receiving events from hook handlers
             self._setup_http_api()
 
@@ -202,11 +218,14 @@ class SocketIOServerCore:
 
             # Conditionally start heartbeat task based on configuration
             from ....config.socketio_config import CONNECTION_CONFIG
-            if CONNECTION_CONFIG.get('enable_extra_heartbeat', False):
+
+            if CONNECTION_CONFIG.get("enable_extra_heartbeat", False):
                 self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
                 self.logger.info("Started system heartbeat task")
             else:
-                self.logger.info("System heartbeat disabled (using Socket.IO ping/pong instead)")
+                self.logger.info(
+                    "System heartbeat disabled (using Socket.IO ping/pong instead)"
+                )
 
             # Keep the server running
             while self.running:
@@ -254,24 +273,113 @@ class SocketIOServerCore:
                 # Parse JSON payload
                 event_data = await request.json()
 
-                # Log receipt if debugging
-                event_type = event_data.get("subtype", "unknown")
-                self.logger.debug(f"Received HTTP event: {event_type}")
+                # Log receipt with more detail
+                event_type = (
+                    event_data.get("subtype")
+                    or event_data.get("hook_event_name")
+                    or "unknown"
+                )
+                self.logger.info(f"📨 Received HTTP event: {event_type}")
+                self.logger.debug(f"Event data keys: {list(event_data.keys())}")
+                self.logger.debug(f"Connected clients: {len(self.connected_clients)}")
+
+                # Transform hook event format to claude_event format if needed
+                if "hook_event_name" in event_data and "event" not in event_data:
+                    # This is a raw hook event, transform it
+                    from claude_mpm.services.socketio.event_normalizer import (
+                        EventNormalizer,
+                    )
+
+                    normalizer = EventNormalizer()
+
+                    # Create the format expected by normalizer
+                    raw_event = {
+                        "type": "hook",
+                        "subtype": event_data.get("hook_event_name", "unknown")
+                        .lower()
+                        .replace("submit", "")
+                        .replace("use", "_use"),
+                        "timestamp": event_data.get("timestamp"),
+                        "data": event_data.get("hook_input_data", {}),
+                        "source": "claude_hooks",
+                        "session_id": event_data.get("session_id"),
+                    }
+
+                    # Map hook event names to dashboard subtypes
+                    subtype_map = {
+                        "UserPromptSubmit": "user_prompt",
+                        "PreToolUse": "pre_tool",
+                        "PostToolUse": "post_tool",
+                        "Stop": "stop",
+                        "SubagentStop": "subagent_stop",
+                        "AssistantResponse": "assistant_response",
+                    }
+                    raw_event["subtype"] = subtype_map.get(
+                        event_data.get("hook_event_name"), "unknown"
+                    )
+
+                    normalized = normalizer.normalize(raw_event, source="hook")
+                    event_data = normalized.to_dict()
+                    self.logger.debug(
+                        f"Normalized event: type={event_data.get('type')}, subtype={event_data.get('subtype')}"
+                    )
 
                 # Broadcast to all connected dashboard clients via SocketIO
                 if self.sio:
-                    # The event is already in claude_event format from the hook handler
-                    await self.sio.emit("claude_event", event_data)
+                    # CRITICAL: Use the main server's broadcaster for proper event handling
+                    # The broadcaster handles retries, connection management, and buffering
+                    if (
+                        self.main_server
+                        and hasattr(self.main_server, "broadcaster")
+                        and self.main_server.broadcaster
+                    ):
+                        # The broadcaster expects raw event data and will normalize it
+                        # Since we already normalized it, we need to pass it in a way that won't double-normalize
+                        # We'll emit directly through the broadcaster's sio with proper handling
+
+                        # Add to event buffer and history
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
+
+                        # Add to main server's event history
+                        if hasattr(self.main_server, "event_history"):
+                            self.main_server.event_history.append(event_data)
+
+                        # Use the broadcaster's sio to emit (it's the same as self.sio)
+                        # This ensures the event goes through the proper channels
+                        await self.sio.emit("claude_event", event_data)
+
+                        # Update broadcaster stats
+                        if hasattr(self.main_server.broadcaster, "stats"):
+                            self.main_server.broadcaster.stats["events_sent"] = (
+                                self.main_server.broadcaster.stats.get("events_sent", 0)
+                                + 1
+                            )
+
+                        self.logger.info(
+                            f"✅ Event broadcasted: {event_data.get('subtype', 'unknown')} to {len(self.connected_clients)} clients"
+                        )
+                        self.logger.debug(
+                            f"Connected client IDs: {list(self.connected_clients) if self.connected_clients else 'None'}"
+                        )
+                    else:
+                        # Fallback: Direct emit if broadcaster not available (shouldn't happen)
+                        self.logger.warning(
+                            "Broadcaster not available, using direct emit"
+                        )
+                        await self.sio.emit("claude_event", event_data)
 
-                    # Update stats
-                    self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
+                        # Update stats manually if using fallback
+                        self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
 
-                    # Add to event buffer for late-joining clients
-                    with self.buffer_lock:
-                        self.event_buffer.append(event_data)
-                        self.stats["events_buffered"] = len(self.event_buffer)
+                        # Add to event buffer for late-joining clients
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
 
                 # Return 204 No Content for success
+                self.logger.debug(f"✅ HTTP event processed successfully: {event_type}")
                 return web.Response(status=204)
 
             except Exception as e:

claude_mpm/services/socketio/server/main.py

@@ -111,7 +111,8 @@ class SocketIOServer(SocketIOServiceInterface):
             flush=True,
         )
 
-        # Start the core server
+        # CRITICAL: Start the core server first to create sio instance
+        # Event handlers will be registered inside _start_server before accepting connections
         self.core.start_sync()
 
         # Initialize connection manager for robust connection tracking
@@ -163,8 +164,9 @@ class SocketIOServer(SocketIOServiceInterface):
                     self.connection_manager.start_health_monitoring(), self.core.loop
                 )
 
-        # Register events
-        self._register_events()
+        # Register events if not already done in async context
+        if self.core.sio and not self.event_registry:
+            self._register_events()
 
         # Setup EventBus integration
         # WHY: This connects the EventBus to the Socket.IO server, allowing
@@ -263,10 +265,16 @@ class SocketIOServer(SocketIOServiceInterface):
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
 
-        # Stop health monitoring in connection handler
+        # Stop code analysis handler
         if self.event_registry:
-            from ..handlers import ConnectionEventHandler
+            from ..handlers import CodeAnalysisEventHandler, ConnectionEventHandler
 
+            # Stop analysis runner
+            analysis_handler = self.event_registry.get_handler(CodeAnalysisEventHandler)
+            if analysis_handler and hasattr(analysis_handler, "cleanup"):
+                analysis_handler.cleanup()
+
+            # Stop health monitoring in connection handler
             conn_handler = self.event_registry.get_handler(ConnectionEventHandler)
             if conn_handler and hasattr(conn_handler, "stop_health_monitoring"):
                 conn_handler.stop_health_monitoring()
@@ -281,6 +289,12 @@ class SocketIOServer(SocketIOServiceInterface):
         handlers in a modular way. Each handler focuses on a specific domain,
         reducing complexity and improving maintainability.
         """
+        if not self.core.sio:
+            self.logger.error(
+                "Cannot register events - Socket.IO server not initialized"
+            )
+            return
+
         # Initialize the event handler registry
         self.event_registry = EventHandlerRegistry(self)
         self.event_registry.initialize()
@@ -294,6 +308,31 @@ class SocketIOServer(SocketIOServiceInterface):
 
         self.logger.info("All Socket.IO events registered via handler system")
 
+    async def _register_events_async(self):
+        """Async version of event registration for calling from async context.
+
+        WHY: This allows us to register events from within the async _start_server
+        method before the server starts accepting connections.
+        """
+        if not self.core.sio:
+            self.logger.error(
+                "Cannot register events - Socket.IO server not initialized"
+            )
+            return
+
+        # Initialize the event handler registry
+        self.event_registry = EventHandlerRegistry(self)
+        self.event_registry.initialize()
+
+        # Register all events from all handlers
+        self.event_registry.register_all_events()
+
+        # Keep handler instances for HTTP endpoint compatibility
+        self.file_handler = self.event_registry.get_handler(FileEventHandler)
+        self.git_handler = self.event_registry.get_handler(GitEventHandler)
+
+        self.logger.info("All Socket.IO events registered via handler system (async)")
+
     # Delegate broadcasting methods to the broadcaster
     def broadcast_event(self, event_type: str, data: Dict[str, Any]):
         """Broadcast an event to all connected clients."""

claude_mpm/services/visualization/__init__.py

@@ -0,0 +1,19 @@
+"""
+Visualization Services for Claude MPM
+=====================================
+
+This module provides visualization services for code analysis,
+including Mermaid diagram generation for various code structures.
+"""
+
+from .mermaid_generator import (
+    DiagramConfig,
+    DiagramType,
+    MermaidGeneratorService,
+)
+
+__all__ = [
+    "DiagramConfig",
+    "DiagramType",
+    "MermaidGeneratorService",
+]