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

claude_mpm/services/socketio/server/core.py

@@ -10,14 +10,12 @@ to create focused, maintainable modules.
 """
 
 import asyncio
-import logging
-import os
 import threading
 import time
 from collections import deque
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, Set
 
 try:
     import aiohttp
@@ -32,16 +30,15 @@ except ImportError:
     web = None
 
 # Import VersionService for dynamic version retrieval
+import contextlib
+
 from claude_mpm.services.version_service import VersionService
 
 from ....core.constants import (
-    NetworkConfig,
-    PerformanceConfig,
     SystemLimits,
     TimeoutConfig,
 )
-from ....core.interfaces import SocketIOServiceInterface
-from ....core.logging_config import get_logger, log_operation, log_performance_context
+from ....core.logging_config import get_logger
 from ....core.unified_paths import get_project_root, get_scripts_dir
 from ...exceptions import SocketIOServerError as MPMConnectionError
 
@@ -87,7 +84,7 @@ class SocketIOServerCore:
 
         # Static files path
         self.static_path = None
-        
+
         # Heartbeat task
         self.heartbeat_task = None
         self.heartbeat_interval = 60  # seconds
@@ -145,7 +142,7 @@ class SocketIOServerCore:
             # condition window where other threads might try to access it.
             self.loop = asyncio.new_event_loop()
             asyncio.set_event_loop(self.loop)
-            
+
             self.logger.debug("Event loop created and set for background thread")
 
             # Run the server
@@ -167,7 +164,7 @@ class SocketIOServerCore:
                 logger=False,  # Disable Socket.IO's own logging
                 engineio_logger=False,
                 ping_interval=25,  # Send ping every 25 seconds
-                ping_timeout=60,   # Wait 60 seconds for pong response
+                ping_timeout=60,  # Wait 60 seconds for pong response
                 max_http_buffer_size=1e8,  # 100MB max buffer
             )
 
@@ -215,10 +212,8 @@ class SocketIOServerCore:
             # Cancel heartbeat task
             if self.heartbeat_task and not self.heartbeat_task.done():
                 self.heartbeat_task.cancel()
-                try:
+                with contextlib.suppress(asyncio.CancelledError):
                     await self.heartbeat_task
-                except asyncio.CancelledError:
-                    pass
                 self.logger.info("Stopped system heartbeat task")
 
             if self.site:
@@ -240,43 +235,48 @@ class SocketIOServerCore:
             # Add debug logging for deployment context
             try:
                 from ....core.unified_paths import PathContext
+
                 deployment_context = PathContext.detect_deployment_context()
-                self.logger.debug(f"Setting up static files in {deployment_context.value} mode")
+                self.logger.debug(
+                    f"Setting up static files in {deployment_context.value} mode"
+                )
             except Exception as e:
                 self.logger.debug(f"Could not detect deployment context: {e}")
-            
+
             self.dashboard_path = self._find_static_path()
 
             if self.dashboard_path and self.dashboard_path.exists():
                 self.logger.info(f"✅ Dashboard found at: {self.dashboard_path}")
-                
+
                 # Serve index.html at root
                 async def index_handler(request):
                     index_file = self.dashboard_path / "index.html"
                     if index_file.exists():
                         self.logger.debug(f"Serving dashboard index from: {index_file}")
                         return web.FileResponse(index_file)
-                    else:
-                        self.logger.warning(f"Dashboard index.html not found at: {index_file}")
-                        return web.Response(text="Dashboard not available", status=404)
+                    self.logger.warning(
+                        f"Dashboard index.html not found at: {index_file}"
+                    )
+                    return web.Response(text="Dashboard not available", status=404)
 
                 self.app.router.add_get("/", index_handler)
-                
+
                 # Serve version.json from dashboard directory
                 async def version_handler(request):
                     version_file = self.dashboard_path / "version.json"
                     if version_file.exists():
                         self.logger.debug(f"Serving version.json from: {version_file}")
                         return web.FileResponse(version_file)
-                    else:
-                        # Return default version info if file doesn't exist
-                        return web.json_response({
+                    # Return default version info if file doesn't exist
+                    return web.json_response(
+                        {
                             "version": "1.0.0",
                             "build": 1,
                             "formatted_build": "0001",
-                            "full_version": "v1.0.0-0001"
-                        })
-                
+                            "full_version": "v1.0.0-0001",
+                        }
+                    )
+
                 self.app.router.add_get("/version.json", version_handler)
 
                 # Serve static assets (CSS, JS) from the dashboard static directory
@@ -287,12 +287,17 @@ class SocketIOServerCore:
                     self.app.router.add_static(
                         "/static/", dashboard_static_path, name="dashboard_static"
                     )
-                    self.logger.info(f"✅ Static assets available at: {dashboard_static_path}")
+                    self.logger.info(
+                        f"✅ Static assets available at: {dashboard_static_path}"
+                    )
                 else:
-                    self.logger.warning(f"⚠️  Static assets directory not found at: {dashboard_static_path}")
+                    self.logger.warning(
+                        f"⚠️  Static assets directory not found at: {dashboard_static_path}"
+                    )
 
             else:
                 self.logger.warning("⚠️  No dashboard found, serving fallback response")
+
                 # Fallback handler
                 async def fallback_handler(request):
                     return web.Response(
@@ -301,18 +306,20 @@ class SocketIOServerCore:
                     )
 
                 self.app.router.add_get("/", fallback_handler)
-                
+
         except Exception as e:
             self.logger.error(f"❌ Error setting up static files: {e}")
             import traceback
+
             self.logger.debug(f"Static file setup traceback: {traceback.format_exc()}")
-            
+
             # Ensure we always have a basic handler
             async def error_handler(request):
                 return web.Response(
                     text="Socket.IO server running - Static files unavailable",
                     status=200,
                 )
+
             self.app.router.add_get("/", error_handler)
 
     def _find_static_path(self):
@@ -324,16 +331,17 @@ class SocketIOServerCore:
         # Get deployment-context-aware paths
         try:
             from ....core.unified_paths import get_path_manager
+
             path_manager = get_path_manager()
-            
+
             # Use package root for installed packages (including pipx)
             package_root = path_manager.package_root
             self.logger.debug(f"Package root: {package_root}")
-            
+
             # Use project root for development
             project_root = get_project_root()
             self.logger.debug(f"Project root: {project_root}")
-            
+
         except Exception as e:
             self.logger.debug(f"Could not get path manager: {e}")
             package_root = None
@@ -345,7 +353,6 @@ class SocketIOServerCore:
             package_root / "dashboard" / "templates" if package_root else None,
             package_root / "services" / "socketio" / "static" if package_root else None,
             package_root / "static" if package_root else None,
-            
             # Project-based paths (for development)
             project_root / "src" / "claude_mpm" / "dashboard" / "templates",
             project_root / "dashboard" / "templates",
@@ -353,15 +360,12 @@ class SocketIOServerCore:
             project_root / "src" / "claude_mpm" / "services" / "socketio" / "static",
             project_root / "static",
             project_root / "src" / "static",
-            
             # Package installation locations (fallback)
             Path(__file__).parent.parent / "static",
             Path(__file__).parent / "static",
-            
             # Scripts directory (for standalone installations)
             get_scripts_dir() / "static",
             get_scripts_dir() / "socketio" / "static",
-            
             # Current working directory
             Path.cwd() / "static",
             Path.cwd() / "socketio" / "static",
@@ -369,7 +373,9 @@ class SocketIOServerCore:
 
         # Filter out None values
         possible_paths = [p for p in possible_paths if p is not None]
-        self.logger.debug(f"Searching {len(possible_paths)} possible static file locations")
+        self.logger.debug(
+            f"Searching {len(possible_paths)} possible static file locations"
+        )
 
         for path in possible_paths:
             self.logger.debug(f"Checking for static files at: {path}")
@@ -379,14 +385,15 @@ class SocketIOServerCore:
                     if (path / "index.html").exists():
                         self.logger.info(f"✅ Found static files at: {path}")
                         return path
-                    else:
-                        self.logger.debug(f"Directory exists but no index.html: {path}")
+                    self.logger.debug(f"Directory exists but no index.html: {path}")
                 else:
                     self.logger.debug(f"Path does not exist: {path}")
             except Exception as e:
                 self.logger.debug(f"Error checking path {path}: {e}")
 
-        self.logger.warning("⚠️  Static files not found - dashboard will not be available")
+        self.logger.warning(
+            "⚠️  Static files not found - dashboard will not be available"
+        )
         self.logger.debug(f"Searched paths: {[str(p) for p in possible_paths]}")
         return None
 
@@ -409,10 +416,10 @@ class SocketIOServerCore:
             True if server is active
         """
         return self.running
-    
+
     async def _heartbeat_loop(self):
         """Send periodic heartbeat events to connected clients.
-        
+
         WHY: This provides a way to verify the event flow is working and
         track server health and active sessions without relying on hook events.
         """
@@ -420,23 +427,27 @@ class SocketIOServerCore:
             try:
                 # Wait for the interval
                 await asyncio.sleep(self.heartbeat_interval)
-                
+
                 if not self.sio:
                     continue
-                    
+
                 # Calculate uptime
                 uptime_seconds = 0
                 if self.stats.get("start_time"):
-                    uptime_seconds = int((datetime.now() - self.stats["start_time"]).total_seconds())
-                
+                    uptime_seconds = int(
+                        (datetime.now() - self.stats["start_time"]).total_seconds()
+                    )
+
                 # Get active sessions from main server if available
                 active_sessions = []
-                if self.main_server and hasattr(self.main_server, 'get_active_sessions'):
+                if self.main_server and hasattr(
+                    self.main_server, "get_active_sessions"
+                ):
                     try:
                         active_sessions = self.main_server.get_active_sessions()
                     except Exception as e:
                         self.logger.debug(f"Could not get active sessions: {e}")
-                
+
                 # Prepare heartbeat data (using new schema)
                 heartbeat_data = {
                     "type": "system",
@@ -454,20 +465,20 @@ class SocketIOServerCore:
                         },
                     },
                 }
-                
+
                 # Add to event history if main server is available
-                if self.main_server and hasattr(self.main_server, 'event_history'):
+                if self.main_server and hasattr(self.main_server, "event_history"):
                     self.main_server.event_history.append(heartbeat_data)
-                
+
                 # Emit heartbeat to all connected clients (already using new schema)
                 await self.sio.emit("system_event", heartbeat_data)
-                
+
                 self.logger.info(
                     f"System heartbeat sent - clients: {len(self.connected_clients)}, "
                     f"uptime: {uptime_seconds}s, events: {self.stats.get('events_sent', 0)}, "
                     f"sessions: {len(active_sessions)}"
                 )
-                
+
             except asyncio.CancelledError:
                 # Task was cancelled, exit gracefully
                 break

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -7,7 +7,6 @@ WHY this integration module:
 - Provides clean separation of concerns
 """
 
-import asyncio
 import logging
 from typing import Optional
 
@@ -19,17 +18,17 @@ logger = logging.getLogger(__name__)
 
 class EventBusIntegration:
     """Integrates EventBus relay with Socket.IO server.
-    
+
     WHY integration class:
     - Encapsulates EventBus setup and teardown
     - Provides lifecycle management for relay
     - Handles configuration and error cases
     - Can be easily added to existing server
     """
-    
+
     def __init__(self, server_instance=None):
         """Initialize EventBus integration.
-        
+
         Args:
             server_instance: Optional Socket.IO server instance
         """
@@ -38,43 +37,78 @@ class EventBusIntegration:
         self.event_bus: Optional[EventBus] = None
         self.config = get_config()
         self.enabled = self.config.enabled and self.config.relay_enabled
-        
+
     def setup(self, port: Optional[int] = None) -> bool:
         """Set up EventBus and relay.
-        
+
         Args:
             port: Optional Socket.IO server port
-            
+
         Returns:
             bool: True if setup successful
         """
+        from datetime import datetime
+
+        print(
+            f"[{datetime.now().isoformat()}] EventBusIntegration.setup() called",
+            flush=True,
+        )
+
         if not self.enabled:
             logger.info("EventBus integration disabled by configuration")
+            print(
+                f"[{datetime.now().isoformat()}] EventBus integration disabled by configuration",
+                flush=True,
+            )
             return False
-        
+
         try:
             # Get EventBus instance
+            print(
+                f"[{datetime.now().isoformat()}] Getting EventBus instance...",
+                flush=True,
+            )
             self.event_bus = EventBus.get_instance()
-            
+            print(
+                f"[{datetime.now().isoformat()}] EventBus instance obtained", flush=True
+            )
+
             # Apply configuration
             self.config.apply_to_eventbus(self.event_bus)
-            
+
             # Create and configure relay
             relay_port = port or self.config.relay_port
+            print(
+                f"[{datetime.now().isoformat()}] Creating SocketIORelay on port {relay_port}...",
+                flush=True,
+            )
             self.relay = SocketIORelay(relay_port)
             self.config.apply_to_relay(self.relay)
-            
+
             # Start the relay
+            print(f"[{datetime.now().isoformat()}] Starting relay...", flush=True)
             self.relay.start()
-            
+            print(f"[{datetime.now().isoformat()}] Relay started", flush=True)
+
             logger.info(f"EventBus integration setup complete (port: {relay_port})")
+            print(
+                f"[{datetime.now().isoformat()}] EventBus integration setup complete",
+                flush=True,
+            )
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to setup EventBus integration: {e}")
+            print(
+                f"[{datetime.now().isoformat()}] Failed to setup EventBus integration: {e}",
+                flush=True,
+            )
+            import traceback
+
+            traceback.print_exc()
             self.enabled = False
             return False
-    
+
     def teardown(self) -> None:
         """Tear down EventBus integration."""
         if self.relay:
@@ -85,105 +119,110 @@ class EventBusIntegration:
                 logger.error(f"Error stopping relay: {e}")
             finally:
                 self.relay = None
-    
+
     def is_active(self) -> bool:
         """Check if integration is active.
-        
+
         Returns:
             bool: True if relay is active and connected
         """
-        return (
-            self.enabled and 
-            self.relay is not None and 
-            self.relay.enabled
-        )
-    
+        return self.enabled and self.relay is not None and self.relay.enabled
+
     def get_stats(self) -> dict:
         """Get integration statistics.
-        
+
         Returns:
             dict: Combined stats from EventBus and relay
         """
-        stats = {
-            "enabled": self.enabled,
-            "active": self.is_active()
-        }
-        
+        stats = {"enabled": self.enabled, "active": self.is_active()}
+
         if self.event_bus:
             stats["eventbus"] = self.event_bus.get_stats()
-        
+
         if self.relay:
             stats["relay"] = self.relay.get_stats()
-        
+
         return stats
 
 
-def integrate_with_server(server_instance, port: Optional[int] = None) -> EventBusIntegration:
+def integrate_with_server(
+    server_instance, port: Optional[int] = None
+) -> EventBusIntegration:
     """Helper function to integrate EventBus with a Socket.IO server.
-    
+
     Args:
         server_instance: Socket.IO server instance
         port: Optional server port
-        
+
     Returns:
         EventBusIntegration: The integration instance
     """
     integration = EventBusIntegration(server_instance)
-    integration.setup(port or getattr(server_instance, 'port', 8765))
+    integration.setup(port or getattr(server_instance, "port", 8765))
     return integration
 
 
 # Monkey-patch helper for existing server
 def patch_socketio_server(server_class):
     """Monkey-patch an existing Socket.IO server class to add EventBus.
-    
+
     WHY monkey-patching:
     - Allows integration without modifying existing code
     - Can be applied selectively based on configuration
     - Easy to remove or disable
-    
+
     Args:
         server_class: The server class to patch
     """
     original_init = server_class.__init__
-    original_start = getattr(server_class, 'start_sync', None) or getattr(server_class, 'start', None)
-    original_stop = getattr(server_class, 'stop_sync', None) or getattr(server_class, 'stop', None)
-    
+    original_start = getattr(server_class, "start_sync", None) or getattr(
+        server_class, "start", None
+    )
+    original_stop = getattr(server_class, "stop_sync", None) or getattr(
+        server_class, "stop", None
+    )
+
     def patched_init(self, *args, **kwargs):
         """Patched __init__ that adds EventBus integration."""
         original_init(self, *args, **kwargs)
         self._eventbus_integration = EventBusIntegration(self)
-    
+
     def patched_start(self, *args, **kwargs):
         """Patched start method that sets up EventBus."""
         # Call original start
-        if original_start:
-            result = original_start(self, *args, **kwargs)
-        else:
-            result = None
-        
+        result = original_start(self, *args, **kwargs) if original_start else None
+
         # Setup EventBus integration
-        if hasattr(self, '_eventbus_integration'):
-            port = getattr(self, 'port', 8765)
+        if hasattr(self, "_eventbus_integration"):
+            port = getattr(self, "port", 8765)
             self._eventbus_integration.setup(port)
-        
+
         return result
-    
+
     def patched_stop(self, *args, **kwargs):
         """Patched stop method that tears down EventBus."""
         # Teardown EventBus first
-        if hasattr(self, '_eventbus_integration'):
+        if hasattr(self, "_eventbus_integration"):
             self._eventbus_integration.teardown()
-        
+
         # Call original stop
         if original_stop:
             return original_stop(self, *args, **kwargs)
-    
+        return None
+
     # Apply patches
     server_class.__init__ = patched_init
     if original_start:
-        setattr(server_class, 'start_sync' if hasattr(server_class, 'start_sync') else 'start', patched_start)
+        setattr(
+            server_class,
+            "start_sync" if hasattr(server_class, "start_sync") else "start",
+            patched_start,
+        )
     if original_stop:
-        setattr(server_class, 'stop_sync' if hasattr(server_class, 'stop_sync') else 'stop', patched_stop)
-    
-    logger.info(f"Patched {server_class.__name__} with EventBus integration")
+        setattr(
+            server_class,
+            "stop_sync" if hasattr(server_class, "stop_sync") else "stop",
+            patched_stop,
+        )
+
+    logger.info(f"Patched {server_class.__name__} with EventBus integration")