claude-mpm 4.1.8__py3-none-any.whl → 4.1.11__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
@@ -148,7 +149,9 @@ 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.
 
@@ -263,6 +266,7 @@ class ConnectionManager:
                     )
                     self.connections[sid] = conn
                     return conn
+        return None
 
     def _create_new_connection(
         self, sid: str, client_id: str, now: float
@@ -434,10 +438,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")
 

claude_mpm/services/socketio/server/core.py

@@ -273,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

@@ -265,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()

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",
+]