claude-mpm 4.1.0__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/socketio/handlers/__init__.py

@@ -17,9 +17,9 @@ from .registry import EventHandlerRegistry
 __all__ = [
     "BaseEventHandler",
     "ConnectionEventHandler",
-    "ProjectEventHandler",
-    "MemoryEventHandler",
+    "EventHandlerRegistry",
     "FileEventHandler",
     "GitEventHandler",
-    "EventHandlerRegistry",
+    "MemoryEventHandler",
+    "ProjectEventHandler",
 ]

claude_mpm/services/socketio/handlers/base.py

@@ -5,15 +5,15 @@ logging, error handling, and access to the server instance. All handler
 classes inherit from this to ensure consistent behavior.
 """
 
-import logging
 from datetime import datetime
-from logging import Logger
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from ....core.logger import get_logger
 from ....core.typing_utils import EventData, EventName, SocketId
 
 if TYPE_CHECKING:
+    from logging import Logger
+
     import socketio
 
     from ..server import SocketIOServer
@@ -33,8 +33,8 @@ class BaseEventHandler:
         Args:
             server: The SocketIOServer instance that owns this handler
         """
-        self.server: "SocketIOServer" = server
-        self.sio: "socketio.AsyncServer" = server.sio
+        self.server: SocketIOServer = server
+        self.sio: socketio.AsyncServer = server.sio
         self.logger: Logger = get_logger(self.__class__.__name__)
         self.clients: Dict[SocketId, Dict[str, Any]] = server.clients
         self.event_history: List[Dict[str, Any]] = server.event_history
@@ -92,6 +92,7 @@ class BaseEventHandler:
         except Exception as e:
             self.logger.error(f"Failed to broadcast {event}: {e}")
             import traceback
+
             self.logger.error(f"Stack trace: {traceback.format_exc()}")
 
     def add_to_history(self, event_type: str, data: EventData) -> None:

claude_mpm/services/socketio/handlers/connection.py

@@ -9,74 +9,83 @@ import asyncio
 import functools
 import time
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Any, Callable, Dict, List, Optional
 
-from ....core.typing_utils import ClaudeStatus, EventData, SocketId
 from .base import BaseEventHandler
 
 
 def timeout_handler(timeout_seconds: float = 5.0):
     """Decorator to add timeout protection to async handlers.
-    
+
     WHY: Network operations can hang indefinitely, causing resource leaks
     and poor user experience. This decorator ensures handlers complete
     within a reasonable time or fail gracefully.
-    
+
     Args:
         timeout_seconds: Maximum time allowed for handler execution (default: 5s)
     """
+
     def decorator(func: Callable) -> Callable:
         @functools.wraps(func)
         async def wrapper(*args, **kwargs):
             handler_name = func.__name__
             start_time = time.time()
-            
+
             try:
                 # Create a task with timeout
                 result = await asyncio.wait_for(
-                    func(*args, **kwargs),
-                    timeout=timeout_seconds
+                    func(*args, **kwargs), timeout=timeout_seconds
                 )
-                
+
                 elapsed = time.time() - start_time
                 if elapsed > timeout_seconds * 0.8:  # Warn if close to timeout
                     # Try to get logger from closure scope or fallback to print
                     try:
                         import logging
+
                         logger = logging.getLogger(__name__)
                         logger.warning(
                             f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
                             f"(close to {timeout_seconds}s timeout)"
                         )
                     except:
-                        print(f"⚠️ Handler {handler_name} took {elapsed:.2f}s (close to {timeout_seconds}s timeout)")
-                    
+                        print(
+                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s (close to {timeout_seconds}s timeout)"
+                        )
+
                 return result
-                
+
             except asyncio.TimeoutError:
                 elapsed = time.time() - start_time
                 # Try to get logger from closure scope or fallback to print
                 try:
                     import logging
+
                     logger = logging.getLogger(__name__)
-                    logger.error(f"❌ Handler {handler_name} timed out after {elapsed:.2f}s")
+                    logger.error(
+                        f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
+                    )
                 except:
                     print(f"❌ Handler {handler_name} timed out after {elapsed:.2f}s")
-                        
+
                 return None
-                
+
             except Exception as e:
                 elapsed = time.time() - start_time
                 # Try to get logger from closure scope or fallback to print
                 try:
                     import logging
+
                     logger = logging.getLogger(__name__)
-                    logger.error(f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}")
+                    logger.error(
+                        f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
+                    )
                 except:
                     print(f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}")
                 raise
-                
+
         return wrapper
+
     return decorator
 
 
@@ -87,34 +96,34 @@ class ConnectionEventHandler(BaseEventHandler):
     that deserves its own focused handler. This includes client connections,
     disconnections, status updates, and event history management.
     """
-    
+
     def __init__(self, server):
         """Initialize connection handler with health monitoring.
-        
+
         WHY: We need to track connection health metrics and implement
         ping/pong mechanism for detecting stale connections.
         """
         super().__init__(server)
-        
+
         # Connection health tracking
         self.connection_metrics = {}
         self.last_ping_times = {}
         self.ping_interval = 45  # seconds - avoid conflict with Engine.IO pings
         self.ping_timeout = 20  # seconds - more lenient timeout
         self.stale_check_interval = 90  # seconds - less frequent checks
-        
+
         # Health monitoring tasks (will be started after event registration)
         self.ping_task = None
         self.stale_check_task = None
 
     def _start_health_monitoring(self):
         """Start background tasks for connection health monitoring.
-        
+
         WHY: We need to actively monitor connection health to detect
         and clean up stale connections, ensuring reliable event delivery.
         """
         # Only start if we have a valid event loop and tasks aren't already running
-        if hasattr(self.server, 'core') and hasattr(self.server.core, 'loop'):
+        if hasattr(self.server, "core") and hasattr(self.server.core, "loop"):
             loop = self.server.core.loop
             if loop and not loop.is_closed():
                 if not self.ping_task or self.ping_task.done():
@@ -122,154 +131,160 @@ class ConnectionEventHandler(BaseEventHandler):
                         self._periodic_ping(), loop
                     )
                     self.logger.info("🏓 Started connection ping monitoring")
-                
+
                 if not self.stale_check_task or self.stale_check_task.done():
                     self.stale_check_task = asyncio.run_coroutine_threadsafe(
                         self._check_stale_connections(), loop
                     )
                     self.logger.info("🧹 Started stale connection checker")
-    
+
     def stop_health_monitoring(self):
         """Stop health monitoring tasks.
-        
+
         WHY: Clean shutdown requires stopping background tasks to
         prevent errors and resource leaks.
         """
         if self.ping_task and not self.ping_task.done():
             self.ping_task.cancel()
             self.logger.info("🚫 Stopped connection ping monitoring")
-        
+
         if self.stale_check_task and not self.stale_check_task.done():
             self.stale_check_task.cancel()
             self.logger.info("🚫 Stopped stale connection checker")
-    
+
     async def _periodic_ping(self):
         """Send periodic pings to all connected clients.
-        
+
         WHY: WebSocket connections can silently fail. Regular pings
         help detect dead connections and maintain connection state.
         """
         while True:
             try:
                 await asyncio.sleep(self.ping_interval)
-                
+
                 if not self.clients:
                     continue
-                    
+
                 current_time = time.time()
                 disconnected = []
-                
+
                 for sid in list(self.clients):
                     try:
                         # Send ping and record time (using new schema)
-                        await self.sio.emit('ping', {
-                            'type': 'system',
-                            'subtype': 'ping',
-                            'timestamp': current_time,
-                            'source': 'server'
-                        }, room=sid)
+                        await self.sio.emit(
+                            "ping",
+                            {
+                                "type": "system",
+                                "subtype": "ping",
+                                "timestamp": current_time,
+                                "source": "server",
+                            },
+                            room=sid,
+                        )
                         self.last_ping_times[sid] = current_time
-                        
+
                         # Update connection metrics
                         if sid not in self.connection_metrics:
                             self.connection_metrics[sid] = {
-                                'connected_at': current_time,
-                                'reconnects': 0,
-                                'failures': 0,
-                                'last_activity': current_time
+                                "connected_at": current_time,
+                                "reconnects": 0,
+                                "failures": 0,
+                                "last_activity": current_time,
                             }
-                        self.connection_metrics[sid]['last_activity'] = current_time
-                        
+                        self.connection_metrics[sid]["last_activity"] = current_time
+
                     except Exception as e:
                         self.logger.warning(f"Failed to ping client {sid}: {e}")
                         disconnected.append(sid)
-                
+
                 # Clean up failed connections
                 for sid in disconnected:
                     await self._cleanup_stale_connection(sid)
-                    
+
                 if self.clients:
                     self.logger.debug(
                         f"🏓 Sent pings to {len(self.clients)} clients, "
                         f"{len(disconnected)} failed"
                     )
-                    
+
             except Exception as e:
                 self.logger.error(f"Error in periodic ping: {e}")
-    
+
     async def _check_stale_connections(self):
         """Check for and clean up stale connections.
-        
+
         WHY: Some clients may not properly disconnect, leaving zombie
         connections that consume resources and prevent proper cleanup.
         """
         while True:
             try:
                 await asyncio.sleep(self.stale_check_interval)
-                
+
                 current_time = time.time()
-                stale_threshold = current_time - (self.ping_timeout + self.ping_interval)
+                stale_threshold = current_time - (
+                    self.ping_timeout + self.ping_interval
+                )
                 stale_sids = []
-                
+
                 for sid in list(self.clients):
                     last_ping = self.last_ping_times.get(sid, 0)
-                    
+
                     if last_ping < stale_threshold:
                         stale_sids.append(sid)
                         self.logger.warning(
                             f"🧟 Detected stale connection {sid} "
                             f"(last ping: {current_time - last_ping:.1f}s ago)"
                         )
-                
+
                 # Clean up stale connections
                 for sid in stale_sids:
                     await self._cleanup_stale_connection(sid)
-                    
+
                 if stale_sids:
                     self.logger.info(
                         f"🧹 Cleaned up {len(stale_sids)} stale connections"
                     )
-                    
+
             except Exception as e:
                 self.logger.error(f"Error checking stale connections: {e}")
-    
+
     async def _cleanup_stale_connection(self, sid: str):
         """Clean up a stale or dead connection.
-        
+
         WHY: Proper cleanup prevents memory leaks and ensures
         accurate connection tracking.
         """
         try:
             if sid in self.clients:
                 self.clients.remove(sid)
-                
+
             if sid in self.last_ping_times:
                 del self.last_ping_times[sid]
-                
+
             if sid in self.connection_metrics:
                 metrics = self.connection_metrics[sid]
-                uptime = time.time() - metrics.get('connected_at', 0)
+                uptime = time.time() - metrics.get("connected_at", 0)
                 self.logger.info(
                     f"📊 Connection {sid} stats - uptime: {uptime:.1f}s, "
                     f"reconnects: {metrics.get('reconnects', 0)}, "
                     f"failures: {metrics.get('failures', 0)}"
                 )
                 del self.connection_metrics[sid]
-                
+
             # Force disconnect if still connected
             try:
                 await self.sio.disconnect(sid)
             except:
                 pass  # Already disconnected
-                
+
             self.logger.info(f"🔌 Cleaned up stale connection: {sid}")
-            
+
         except Exception as e:
             self.logger.error(f"Error cleaning up connection {sid}: {e}")
-    
+
     def register_events(self) -> None:
         """Register connection-related event handlers."""
-        
+
         # Start health monitoring now that we're registering events
         self._start_health_monitoring()
 
@@ -293,13 +308,18 @@ class ConnectionEventHandler(BaseEventHandler):
             monitor_build_info = {}
             try:
                 from ....services.monitor_build_service import get_monitor_build_service
+
                 monitor_service = get_monitor_build_service()
                 monitor_build_info = monitor_service.get_build_info_sync()
             except Exception as e:
                 self.logger.debug(f"Could not get monitor build info: {e}")
                 monitor_build_info = {
-                    "monitor": {"version": "1.0.0", "build": 1, "formatted_build": "0001"},
-                    "mpm": {"version": "unknown", "build": "unknown"}
+                    "monitor": {
+                        "version": "1.0.0",
+                        "build": 1,
+                        "formatted_build": "0001",
+                    },
+                    "mpm": {"version": "unknown", "build": "unknown"},
                 }
 
             # Send initial status immediately with enhanced data (using new schema)
@@ -317,7 +337,7 @@ class ConnectionEventHandler(BaseEventHandler):
                     "server_version": "2.0.0",
                     "client_id": sid,
                     "build_info": monitor_build_info,
-                }
+                },
             }
 
             try:
@@ -336,7 +356,7 @@ class ConnectionEventHandler(BaseEventHandler):
                             "client_id": sid,
                             "server_time": datetime.utcnow().isoformat() + "Z",
                             "build_info": monitor_build_info,
-                        }
+                        },
                     },
                 )
 
@@ -362,10 +382,8 @@ class ConnectionEventHandler(BaseEventHandler):
                 self.logger.info(f"🔌 CLIENT DISCONNECTED: {sid}")
                 self.logger.info(f"📉 Total clients now: {len(self.clients)}")
             else:
-                self.logger.warning(
-                    f"⚠️  Attempted to disconnect unknown client: {sid}"
-                )
-            
+                self.logger.warning(f"⚠️  Attempted to disconnect unknown client: {sid}")
+
             # Clean up health tracking
             if sid in self.last_ping_times:
                 del self.last_ping_times[sid]
@@ -391,7 +409,7 @@ class ConnectionEventHandler(BaseEventHandler):
                     "clients_connected": len(self.clients),
                     "claude_status": self.server.claude_status,
                     "claude_pid": self.server.claude_pid,
-                }
+                },
             }
             await self.emit_to_client(sid, "status", status_data)
 
@@ -432,13 +450,17 @@ class ConnectionEventHandler(BaseEventHandler):
             for filtered event streaming.
             """
             channels = data.get("channels", ["*"]) if data else ["*"]
-            await self.emit_to_client(sid, "subscribed", {
-                "type": "connection",
-                "subtype": "subscribed",
-                "timestamp": datetime.utcnow().isoformat() + "Z",
-                "source": "server",
-                "data": {"channels": channels}
-            })
+            await self.emit_to_client(
+                sid,
+                "subscribed",
+                {
+                    "type": "connection",
+                    "subtype": "subscribed",
+                    "timestamp": datetime.utcnow().isoformat() + "Z",
+                    "source": "server",
+                    "data": {"channels": channels},
+                },
+            )
 
         @self.sio.event
         @timeout_handler(timeout_seconds=5.0)
@@ -450,55 +472,58 @@ class ConnectionEventHandler(BaseEventHandler):
             """
             # Add debug logging
             self.logger.info(f"🔵 Received claude_event from {sid}: {data}")
-            
+
             # Check if this is a hook event and route to HookEventHandler
             # Hook events can have either:
             # 1. Normalized format: type="hook", subtype="pre_tool"
             # 2. Legacy format: type="hook.pre_tool"
             if isinstance(data, dict):
                 event_type = data.get("type", "")
-                event_subtype = data.get("subtype", "")
-                
+                data.get("subtype", "")
+
                 # Check for both normalized and legacy formats
                 is_hook_event = False
                 if isinstance(event_type, str):
                     # Legacy format: type="hook.something"
-                    if event_type.startswith("hook."):
-                        is_hook_event = True
-                    # Normalized format: type="hook" with any subtype
-                    elif event_type == "hook":
+                    if event_type.startswith("hook.") or event_type == "hook":
                         is_hook_event = True
-                
+
                 if is_hook_event:
                     # Get the hook handler if available
                     hook_handler = None
                     # Check if event_registry exists and has handlers
-                    if hasattr(self.server, 'event_registry') and self.server.event_registry:
-                        if hasattr(self.server.event_registry, 'handlers'):
-                            for handler in self.server.event_registry.handlers:
-                                if handler.__class__.__name__ == "HookEventHandler":
-                                    hook_handler = handler
-                                    break
-                    
+                    if (
+                        hasattr(self.server, "event_registry")
+                        and self.server.event_registry
+                    ) and hasattr(self.server.event_registry, "handlers"):
+                        for handler in self.server.event_registry.handlers:
+                            if handler.__class__.__name__ == "HookEventHandler":
+                                hook_handler = handler
+                                break
+
                     if hook_handler and hasattr(hook_handler, "process_hook_event"):
                         # Let the hook handler process this event
                         await hook_handler.process_hook_event(data)
                         # Don't double-store or double-broadcast, return early
                         return
-            
+
             # Normalize event format before storing in history
             normalized_event = self._normalize_event(data)
-            
+
             # Store in history - flatten if it's a nested structure
             # If the normalized event has data.event, promote it to top level
-            if isinstance(normalized_event, dict) and 'data' in normalized_event:
-                if isinstance(normalized_event['data'], dict) and 'event' in normalized_event['data']:
+            if isinstance(normalized_event, dict) and "data" in normalized_event:
+                if (
+                    isinstance(normalized_event["data"], dict)
+                    and "event" in normalized_event["data"]
+                ):
                     # This is a nested event, flatten it
                     flattened = {
-                        'type': normalized_event.get('type', 'unknown'),
-                        'event': normalized_event['data'].get('event'),
-                        'timestamp': normalized_event.get('timestamp') or normalized_event['data'].get('timestamp'),
-                        'data': normalized_event['data'].get('data', {})
+                        "type": normalized_event.get("type", "unknown"),
+                        "event": normalized_event["data"].get("event"),
+                        "timestamp": normalized_event.get("timestamp")
+                        or normalized_event["data"].get("timestamp"),
+                        "data": normalized_event["data"].get("data", {}),
                     }
                     self.event_history.append(flattened)
                 else:
@@ -510,32 +535,34 @@ class ConnectionEventHandler(BaseEventHandler):
             )
 
             # Re-broadcast to all other clients
-            self.logger.info(f"📡 Broadcasting claude_event to all clients except {sid}")
+            self.logger.info(
+                f"📡 Broadcasting claude_event to all clients except {sid}"
+            )
             await self.broadcast_event("claude_event", data, skip_sid=sid)
-            self.logger.info(f"✅ Broadcast complete")
-        
+            self.logger.info("✅ Broadcast complete")
+
         @self.sio.event
         async def pong(sid, data=None):
             """Handle pong response from client.
-            
+
             WHY: Clients respond to our pings with pongs, confirming
             they're still alive and the connection is healthy.
             """
             current_time = time.time()
-            
+
             # Update last activity time
             if sid in self.connection_metrics:
-                self.connection_metrics[sid]['last_activity'] = current_time
-                
+                self.connection_metrics[sid]["last_activity"] = current_time
+
             # Calculate round-trip time if timestamp provided
-            if data and 'timestamp' in data:
-                rtt = current_time - data['timestamp']
+            if data and "timestamp" in data:
+                rtt = current_time - data["timestamp"]
                 if rtt < 10:  # Reasonable RTT
                     self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt*1000:.1f}ms")
 
     def _normalize_event(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
         """Normalize event format to ensure consistency.
-        
+
         WHY: Different clients may send events in different formats.
         This ensures all events have a consistent 'type' field for
         proper display in the dashboard, while preserving the original
@@ -543,37 +570,37 @@ class ConnectionEventHandler(BaseEventHandler):
         """
         if not isinstance(event_data, dict):
             return event_data
-            
+
         # Make a copy to avoid modifying the original
         normalized = dict(event_data)
-        
+
         # If event has no 'type' but has 'event' field (legacy format)
-        if 'type' not in normalized and 'event' in normalized:
-            event_name = normalized['event']
-            
+        if "type" not in normalized and "event" in normalized:
+            event_name = normalized["event"]
+
             # Map common event names to proper type
-            if event_name in ['TestStart', 'TestEnd']:
-                normalized['type'] = 'test'
-            elif event_name in ['SubagentStart', 'SubagentStop']:
-                normalized['type'] = 'subagent'
-            elif event_name == 'ToolCall':
-                normalized['type'] = 'tool'
-            elif event_name == 'UserPrompt':
-                normalized['type'] = 'hook'
-                normalized['subtype'] = 'user_prompt'
+            if event_name in ["TestStart", "TestEnd"]:
+                normalized["type"] = "test"
+            elif event_name in ["SubagentStart", "SubagentStop"]:
+                normalized["type"] = "subagent"
+            elif event_name == "ToolCall":
+                normalized["type"] = "tool"
+            elif event_name == "UserPrompt":
+                normalized["type"] = "hook"
+                normalized["subtype"] = "user_prompt"
             else:
                 # Default to system type for unknown events
-                normalized['type'] = 'system'
-            
+                normalized["type"] = "system"
+
             # Note: We keep the 'event' field for backward compatibility
             # Dashboard may use it for display purposes
-        
+
         # Ensure there's always a type field
-        if 'type' not in normalized:
-            normalized['type'] = 'unknown'
-            
+        if "type" not in normalized:
+            normalized["type"] = "unknown"
+
         return normalized
-    
+
     async def _send_event_history(
         self, sid: str, event_types: Optional[List[str]] = None, limit: int = 50
     ):