claude-mpm 3.7.8__py3-none-any.whl → 3.9.0__py3-none-any.whl

claude_mpm/services/socketio/handlers/memory.py

@@ -0,0 +1,27 @@
+"""Memory-related event handlers for Socket.IO.
+
+WHY: This module handles agent memory events. Currently the memory
+events are broadcast methods rather than Socket.IO events, but this
+provides a place for future memory management features.
+"""
+
+from .base import BaseEventHandler
+
+
+class MemoryEventHandler(BaseEventHandler):
+    """Handles memory-related Socket.IO events.
+    
+    WHY: Agent memory management events will be handled here as the system
+    grows. This provides a clean separation for memory-specific functionality.
+    """
+    
+    def register_events(self):
+        """Register memory-related event handlers.
+        
+        Currently memory events are handled through broadcast methods
+        rather than Socket.IO event handlers, but this provides a place
+        for future interactive memory management features.
+        """
+        # Future memory management events will be registered here
+        # For example: query_memory, clear_memory, export_memory, etc.
+        pass

claude_mpm/services/socketio/handlers/project.py

@@ -0,0 +1,25 @@
+"""Project-related event handlers for Socket.IO.
+
+WHY: This module handles project-specific events that don't fit into
+other categories. Currently empty but provides a place for future
+project management features.
+"""
+
+from .base import BaseEventHandler
+
+
+class ProjectEventHandler(BaseEventHandler):
+    """Handles project-related Socket.IO events.
+    
+    WHY: Project management events will be handled here as the system
+    grows. This provides a clean separation for project-specific functionality.
+    """
+    
+    def register_events(self):
+        """Register project-related event handlers.
+        
+        Currently no project-specific events are defined, but this
+        handler is ready for future expansion.
+        """
+        # Future project events will be registered here
+        pass

claude_mpm/services/socketio/handlers/registry.py

@@ -0,0 +1,145 @@
+"""Event handler registry for Socket.IO server.
+
+WHY: This registry manages the registration of all event handlers,
+providing a clean interface for the SocketIOServer to register all
+events without knowing the details of each handler.
+"""
+
+from typing import List, Type, Optional, TYPE_CHECKING
+from logging import Logger
+from ....core.logger import get_logger
+
+from .base import BaseEventHandler
+
+if TYPE_CHECKING:
+    from ..server import SocketIOServer
+from .connection import ConnectionEventHandler
+from .project import ProjectEventHandler
+from .memory import MemoryEventHandler
+from .file import FileEventHandler
+from .git import GitEventHandler
+
+
+class EventHandlerRegistry:
+    """Manages registration of Socket.IO event handlers.
+    
+    WHY: The registry pattern allows us to easily add, remove, or modify
+    event handlers without changing the SocketIOServer implementation.
+    It provides a single point of configuration for all event handlers.
+    """
+    
+    # Default handler classes in registration order
+    DEFAULT_HANDLERS: List[Type[BaseEventHandler]] = [
+        ConnectionEventHandler,  # Connection management first
+        GitEventHandler,         # Git operations
+        FileEventHandler,        # File operations
+        ProjectEventHandler,     # Project management (future)
+        MemoryEventHandler,      # Memory management (future)
+    ]
+    
+    def __init__(self, server: 'SocketIOServer') -> None:
+        """Initialize the registry.
+        
+        Args:
+            server: The SocketIOServer instance
+        """
+        self.server: 'SocketIOServer' = server
+        self.logger: Logger = get_logger("EventHandlerRegistry")
+        self.handlers: List[BaseEventHandler] = []
+        self._initialized: bool = False
+    
+    def initialize(self, handler_classes: Optional[List[Type[BaseEventHandler]]] = None) -> None:
+        """Initialize all event handlers.
+        
+        WHY: This creates instances of all handler classes and prepares
+        them for event registration. Using a list of classes allows
+        customization of which handlers to use.
+        
+        Args:
+            handler_classes: Optional list of handler classes to use.
+                           Defaults to DEFAULT_HANDLERS if not provided.
+        """
+        if self._initialized:
+            self.logger.warning("Registry already initialized, skipping re-initialization")
+            return
+        
+        handler_classes = handler_classes or self.DEFAULT_HANDLERS
+        
+        for handler_class in handler_classes:
+            try:
+                handler = handler_class(self.server)
+                self.handlers.append(handler)
+                self.logger.info(f"Initialized handler: {handler_class.__name__}")
+            except Exception as e:
+                self.logger.error(f"Failed to initialize {handler_class.__name__}: {e}")
+                import traceback
+                self.logger.error(f"Stack trace: {traceback.format_exc()}")
+        
+        self._initialized = True
+        self.logger.info(f"Registry initialized with {len(self.handlers)} handlers")
+    
+    def register_all_events(self) -> None:
+        """Register all events from all handlers.
+        
+        WHY: This is the main method called by SocketIOServer to register
+        all events. It delegates to each handler's register_events method,
+        keeping the server code clean and simple.
+        """
+        if not self._initialized:
+            self.logger.error("Registry not initialized. Call initialize() first.")
+            raise RuntimeError("EventHandlerRegistry not initialized")
+        
+        registered_count = 0
+        for handler in self.handlers:
+            try:
+                handler.register_events()
+                registered_count += 1
+                self.logger.info(f"Registered events for {handler.__class__.__name__}")
+            except NotImplementedError:
+                # Handler has no events to register (like ProjectEventHandler)
+                self.logger.debug(f"No events to register for {handler.__class__.__name__}")
+            except Exception as e:
+                self.logger.error(f"Failed to register events for {handler.__class__.__name__}: {e}")
+                import traceback
+                self.logger.error(f"Stack trace: {traceback.format_exc()}")
+        
+        self.logger.info(f"Successfully registered events from {registered_count} handlers")
+    
+    def add_handler(self, handler_class: Type[BaseEventHandler]):
+        """Add a custom handler to the registry.
+        
+        WHY: Allows dynamic addition of custom handlers for specific
+        deployments or testing without modifying the default handlers.
+        
+        Args:
+            handler_class: The handler class to add
+        """
+        if not self._initialized:
+            self.logger.error("Registry not initialized. Call initialize() first.")
+            raise RuntimeError("EventHandlerRegistry not initialized")
+        
+        try:
+            handler = handler_class(self.server)
+            self.handlers.append(handler)
+            handler.register_events()
+            self.logger.info(f"Added and registered handler: {handler_class.__name__}")
+        except Exception as e:
+            self.logger.error(f"Failed to add handler {handler_class.__name__}: {e}")
+            raise
+    
+    def get_handler(self, handler_class: Type[BaseEventHandler]) -> BaseEventHandler:
+        """Get a specific handler instance by class.
+        
+        WHY: Useful for testing or when specific handler functionality
+        needs to be accessed directly.
+        
+        Args:
+            handler_class: The handler class to find
+            
+        Returns:
+            The handler instance or None if not found
+        """
+        for handler in self.handlers:
+            if isinstance(handler, handler_class):
+                return handler
+        return None

claude_mpm/services/socketio_client_manager.py

@@ -23,6 +23,11 @@ import time
 from datetime import datetime
 from typing import Dict, Any, Optional, List, Tuple
 import importlib.metadata
+from claude_mpm.core.constants import (
+    NetworkConfig,
+    TimeoutConfig,
+    PerformanceConfig
+)
 
 try:
     import requests
@@ -129,7 +134,7 @@ class SocketIOClientManager:
                     try:
                         response = requests.get(
                             f"http://{host}:{port}/version",
-                            timeout=2.0
+                            timeout=TimeoutConfig.QUICK_TIMEOUT
                         )
                         if response.status_code == 200:
                             data = response.json()
@@ -177,9 +182,9 @@ class SocketIOClientManager:
             # Version scoring (basic semantic versioning)
             try:
                 version_parts = server.server_version.split('.')
-                score += int(version_parts[0]) * 1000  # Major version
-                score += int(version_parts[1]) * 100   # Minor version
-                score += int(version_parts[2]) * 10    # Patch version
+                score += int(version_parts[0]) * PerformanceConfig.VERSION_SCORE_MAJOR
+                score += int(version_parts[1]) * PerformanceConfig.VERSION_SCORE_MINOR
+                score += int(version_parts[2]) * PerformanceConfig.VERSION_SCORE_PATCH
             except (ValueError, IndexError):
                 pass
             
@@ -211,7 +216,7 @@ class SocketIOClientManager:
             compat_response = requests.post(
                 f"{server_info.url}/compatibility",
                 json={"client_version": self.client_version},
-                timeout=5.0
+                timeout=TimeoutConfig.FILE_OPERATION_TIMEOUT
             )
             
             if compat_response.status_code == 200:
@@ -224,7 +229,7 @@ class SocketIOClientManager:
             self.client = socketio.AsyncClient(
                 reconnection=True,
                 reconnection_attempts=0,  # Infinite
-                reconnection_delay=1,
+                reconnection_delay=NetworkConfig.RECONNECTION_DELAY,
                 reconnection_delay_max=5,
                 randomization_factor=0.5,
                 logger=False,
@@ -328,7 +333,7 @@ class SocketIOClientManager:
         self.running = False
         
         if self.connection_thread:
-            self.connection_thread.join(timeout=5)
+            self.connection_thread.join(timeout=TimeoutConfig.THREAD_JOIN_TIMEOUT)
         
         if self.client and self.connected:
             try:

claude_mpm/services/socketio_server.py

@@ -31,8 +31,17 @@ except ImportError:
     web = None
     # Don't print warnings at module level
 
-from ..core.logger import get_logger
+from ..core.logging_config import get_logger, log_operation, log_performance_context
 from ..deployment_paths import get_project_root, get_scripts_dir
+from .socketio.handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler
+from ..core.constants import (
+    SystemLimits,
+    NetworkConfig,
+    TimeoutConfig,
+    PerformanceConfig
+)
+from ..core.interfaces import SocketIOServiceInterface
+from ..exceptions import MPMConnectionError
 
 
 class SocketIOClientProxy:
@@ -47,19 +56,19 @@ class SocketIOClientProxy:
     def __init__(self, host: str = "localhost", port: int = 8765):
         self.host = host
         self.port = port
-        self.logger = get_logger("socketio_client_proxy")
+        self.logger = get_logger(__name__ + ".SocketIOClientProxy")
         self.running = True  # Always "running" for compatibility
         self._sio_client = None
         self._client_thread = None
         self._client_loop = None
         
-    def start(self):
+    def start_sync(self):
         """Start the Socket.IO client connection to the persistent server."""
         self.logger.debug(f"SocketIOClientProxy: Connecting to server on {self.host}:{self.port}")
         if SOCKETIO_AVAILABLE:
             self._start_client()
         
-    def stop(self):
+    def stop_sync(self):
         """Stop the Socket.IO client connection."""
         self.logger.debug(f"SocketIOClientProxy: Disconnecting from server")
         if self._sio_client:
@@ -161,7 +170,7 @@ class SocketIOClientProxy:
         self.logger.debug(f"SocketIOClientProxy: Todo updated ({len(todos)} todos)")
 
 
-class SocketIOServer:
+class SocketIOServer(SocketIOServiceInterface):
     """Socket.IO server for broadcasting Claude MPM events.
     
     WHY: Socket.IO provides better connection reliability than raw WebSockets,
@@ -172,9 +181,9 @@ class SocketIOServer:
     def __init__(self, host: str = "localhost", port: int = 8765):
         self.host = host
         self.port = port
-        self.logger = get_logger("socketio_server")
+        self.logger = get_logger(__name__)
         self.clients: Set[str] = set()  # Store session IDs instead of connection objects
-        self.event_history: deque = deque(maxlen=1000)  # Keep last 1000 events
+        self.event_history: deque = deque(maxlen=SystemLimits.MAX_EVENT_HISTORY)
         self.sio = None
         self.app = None
         self.runner = None
@@ -199,8 +208,8 @@ class SocketIOServer:
             except:
                 self.logger.info("Socket.IO server using python-socketio (version unavailable)")
         
-    def start(self):
-        """Start the Socket.IO server in a background thread."""
+    def start_sync(self):
+        """Start the Socket.IO server in a background thread (synchronous version)."""
         if not SOCKETIO_AVAILABLE:
             self.logger.debug("Socket.IO server skipped - required packages not installed")
             return
@@ -223,13 +232,13 @@ class SocketIOServer:
         else:
             self.logger.error(f"❌ Socket.IO server thread failed to start!")
         
-    def stop(self):
-        """Stop the Socket.IO server."""
+    def stop_sync(self):
+        """Stop the Socket.IO server (synchronous version)."""
         self.running = False
         if self.loop:
             asyncio.run_coroutine_threadsafe(self._shutdown(), self.loop)
         if self.thread:
-            self.thread.join(timeout=5)
+            self.thread.join(timeout=TimeoutConfig.THREAD_JOIN_TIMEOUT)
         self.logger.info("Socket.IO server stopped")
         
     def _run_server(self):
@@ -258,8 +267,8 @@ class SocketIOServer:
             # Create Socket.IO server with improved configuration
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
-                ping_timeout=120,
-                ping_interval=30,
+                ping_timeout=NetworkConfig.PING_TIMEOUT,
+                ping_interval=NetworkConfig.PING_INTERVAL,
                 max_http_buffer_size=1000000,
                 allow_upgrades=True,
                 transports=['websocket', 'polling'],
@@ -310,7 +319,16 @@ class SocketIOServer:
             await self.runner.setup()
             
             self.site = web.TCPSite(self.runner, self.host, self.port)
-            await self.site.start()
+            try:
+                await self.site.start()
+            except OSError as e:
+                if "Address already in use" in str(e) or "address already in use" in str(e).lower():
+                    raise MPMConnectionError(
+                        f"Port {self.port} is already in use",
+                        context={"host": self.host, "port": self.port, "error": str(e)}
+                    ) from e
+                else:
+                    raise
             
             self.logger.info(f"🎉 Socket.IO server SUCCESSFULLY listening on http://{self.host}:{self.port}")
             
@@ -319,7 +337,7 @@ class SocketIOServer:
             while self.running:
                 await asyncio.sleep(0.1)
                 loop_count += 1
-                if loop_count % 100 == 0:  # Log every 10 seconds
+                if loop_count % PerformanceConfig.LOG_EVERY_N_ITERATIONS == 0:
                     self.logger.debug(f"🔄 Socket.IO server heartbeat - {len(self.clients)} clients connected")
                 
         except Exception as e:
@@ -463,7 +481,7 @@ class SocketIOServer:
     async def _handle_cors_preflight(self, request):
         """Handle CORS preflight requests."""
         return web.Response(
-            status=200,
+            status=NetworkConfig.HTTP_OK,
             headers={
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
@@ -502,8 +520,12 @@ class SocketIOServer:
             
             self.logger.debug(f"Git diff requested for file: {file_path}, timestamp: {timestamp}")
             
-            # Generate git diff using the _generate_git_diff helper
-            diff_result = await self._generate_git_diff(file_path, timestamp, working_dir)
+            # Generate git diff using the git handler's method
+            if hasattr(self, 'git_handler') and self.git_handler:
+                diff_result = await self.git_handler.generate_git_diff(file_path, timestamp, working_dir)
+            else:
+                # Fallback to old method if handler not available
+                diff_result = await self._generate_git_diff(file_path, timestamp, working_dir)
             
             self.logger.info(f"Git diff result: success={diff_result.get('success', False)}, method={diff_result.get('method', 'unknown')}")
             
@@ -520,7 +542,7 @@ class SocketIOServer:
             return web.json_response({
                 "success": False,
                 "error": f"Failed to generate git diff: {str(e)}"
-            }, status=500, headers={
+            }, status=NetworkConfig.HTTP_INTERNAL_ERROR, headers={
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                 'Access-Control-Allow-Headers': 'Content-Type, Accept'
@@ -538,7 +560,7 @@ class SocketIOServer:
             # Extract query parameters
             file_path = request.query.get('file_path')
             working_dir = request.query.get('working_dir', os.getcwd())
-            max_size = int(request.query.get('max_size', 1024 * 1024))  # 1MB default
+            max_size = int(request.query.get('max_size', SystemLimits.MAX_FILE_SIZE))
             
             self.logger.info(f"File content API request: file_path={file_path}, working_dir={working_dir}")
             
@@ -553,8 +575,12 @@ class SocketIOServer:
                     'Access-Control-Allow-Headers': 'Content-Type, Accept'
                 })
             
-            # Use the same file reading logic as the Socket.IO handler
-            result = await self._read_file_safely(file_path, working_dir, max_size)
+            # Use the file handler's safe reading logic
+            if hasattr(self, 'file_handler') and self.file_handler:
+                result = await self.file_handler._read_file_safely(file_path, working_dir, max_size)
+            else:
+                # Fallback to old method if handler not available
+                result = await self._read_file_safely(file_path, working_dir, max_size)
             
             status_code = 200 if result.get('success') else 400
             return web.json_response(result, status=status_code, headers={
@@ -570,13 +596,13 @@ class SocketIOServer:
             return web.json_response({
                 "success": False,
                 "error": f"Failed to read file: {str(e)}"
-            }, status=500, headers={
+            }, status=NetworkConfig.HTTP_INTERNAL_ERROR, headers={
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
                 'Access-Control-Allow-Headers': 'Content-Type, Accept'
             })
     
-    async def _read_file_safely(self, file_path: str, working_dir: str = None, max_size: int = 1024 * 1024):
+    async def _read_file_safely(self, file_path: str, working_dir: str = None, max_size: int = SystemLimits.MAX_FILE_SIZE):
         """Safely read file content with security checks.
         
         This method contains the core file reading logic that can be used by both
@@ -998,7 +1024,30 @@ class SocketIOServer:
         
             
     def _register_events(self):
-        """Register Socket.IO event handlers."""
+        """Register Socket.IO event handlers.
+        
+        WHY: This method now uses the EventHandlerRegistry to manage all event
+        handlers in a modular way. Each handler focuses on a specific domain,
+        reducing complexity and improving maintainability.
+        """
+        # 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")
+        
+        # Note: The actual event registration is now handled by individual
+        # handler classes in socketio/handlers/. This dramatically reduces
+        # the complexity of this method from 514 lines to under 20 lines.
+        
+        return  # Early return to skip old implementation
         
         @self.sio.event
         async def connect(sid, environ, *args):
@@ -1240,7 +1289,7 @@ class SocketIOServer:
             try:
                 file_path = data.get('file_path')
                 working_dir = data.get('working_dir', os.getcwd())
-                max_size = data.get('max_size', 1024 * 1024)  # 1MB default limit
+                max_size = data.get('max_size', SystemLimits.MAX_FILE_SIZE)
                 
                 if not file_path:
                     await self.sio.emit('file_content_response', {
@@ -1626,7 +1675,7 @@ class SocketIOServer:
                 )
                 # Wait for completion with timeout to detect issues
                 try:
-                    future.result(timeout=2.0)  # 2 second timeout
+                    future.result(timeout=TimeoutConfig.QUICK_TIMEOUT)
                     self.logger.debug(f"📨 Successfully broadcasted {event_type} to {len(self.clients)} clients")
                 except asyncio.TimeoutError:
                     self.logger.warning(f"⏰ Broadcast timeout for event {event_type} - continuing anyway")
@@ -1758,6 +1807,83 @@ class SocketIOServer:
             "context_size": context_size,
             "timestamp": datetime.utcnow().isoformat() + "Z"
         })
+    
+    # ================================================================================
+    # Interface Adapter Methods
+    # ================================================================================
+    # These methods adapt the existing implementation to comply with SocketIOServiceInterface
+    
+    async def start(self, host: str = "localhost", port: int = 8765) -> None:
+        """Start the WebSocket server (async adapter).
+        
+        WHY: The interface expects async methods, but our implementation uses
+        synchronous start with background threads. This adapter provides compatibility.
+        
+        Args:
+            host: Host to bind to
+            port: Port to listen on
+        """
+        self.host = host
+        self.port = port
+        # Call the synchronous start method
+        self.start_sync()
+    
+    async def stop(self) -> None:
+        """Stop the WebSocket server (async adapter).
+        
+        WHY: The interface expects async methods. This adapter wraps the
+        synchronous stop method for interface compliance.
+        """
+        # Call the synchronous stop method
+        self.stop_sync()
+    
+    async def emit(self, event: str, data: Any, room: Optional[str] = None) -> None:
+        """Emit an event to connected clients.
+        
+        WHY: Provides interface compliance by wrapping broadcast_event with
+        async signature and room support.
+        
+        Args:
+            event: Event name
+            data: Event data
+            room: Optional room to target (not supported in current implementation)
+        """
+        if room:
+            self.logger.warning(f"Room-based emit not supported, broadcasting to all: {event}")
+        
+        # Use existing broadcast_event method
+        self.broadcast_event(event, data)
+    
+    async def broadcast(self, event: str, data: Any) -> None:
+        """Broadcast event to all connected clients.
+        
+        WHY: Provides interface compliance with async signature.
+        
+        Args:
+            event: Event name
+            data: Event data
+        """
+        self.broadcast_event(event, data)
+    
+    def get_connection_count(self) -> int:
+        """Get number of connected clients.
+        
+        WHY: Provides interface compliance for monitoring connections.
+        
+        Returns:
+            Number of active connections
+        """
+        return len(self.clients)
+    
+    def is_running(self) -> bool:
+        """Check if server is running.
+        
+        WHY: Provides interface compliance for status checking.
+        
+        Returns:
+            True if server is active
+        """
+        return self.running
 
 
 # Global instance for easy access
@@ -1795,7 +1921,7 @@ def get_socketio_server() -> SocketIOServer:
 def start_socketio_server():
     """Start the global Socket.IO server."""
     server = get_socketio_server()
-    server.start()
+    server.start_sync()
     return server
 
 
@@ -1803,5 +1929,5 @@ def stop_socketio_server():
     """Stop the global Socket.IO server."""
     global _socketio_server
     if _socketio_server:
-        _socketio_server.stop()
+        _socketio_server.stop_sync()
         _socketio_server = None