claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/scripts/socketio_server_manager.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+Socket.IO Server Manager wrapper for claude-mpm.
+
+WHY: This module provides a wrapper around the ServerManager class from
+tools/admin/socketio_server_manager.py to make it accessible from the
+scripts directory as expected by the CLI monitor command.
+
+DESIGN DECISION: Rather than duplicating code, we import and re-export
+the ServerManager class from its actual location in tools/admin. This
+ensures consistency and maintainability.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the tools/admin directory to Python path to import ServerManager
+script_dir = Path(__file__).parent
+project_root = script_dir.parent.parent.parent  # Up to project root
+tools_admin_dir = project_root / "tools" / "admin"
+
+if tools_admin_dir.exists() and str(tools_admin_dir) not in sys.path:
+    sys.path.insert(0, str(tools_admin_dir))
+
+try:
+    # Import ServerManager from the actual implementation
+    from socketio_server_manager import ServerManager as BaseServerManager
+    import subprocess
+    
+    # Patch the ServerManager to use project-local PID file and daemon
+    class ServerManager(BaseServerManager):
+        """Patched ServerManager that uses project-local PID file and daemon.
+        
+        WHY: The daemon stores its PID file in the project's .claude-mpm
+        directory, not in the home directory. This patch ensures the
+        ServerManager looks in the correct location and uses the daemon
+        for starting servers when the standalone module is not available.
+        """
+        
+        def __init__(self):
+            super().__init__()
+            # Override the daemon PID file path to use project root
+            from claude_mpm.core.unified_paths import get_project_root
+            self.daemon_pidfile_path = get_project_root() / ".claude-mpm" / "socketio-server.pid"
+            self.daemon_script = script_dir / "socketio_daemon.py"
+        
+        def start_server(self, port: int = None, host: str = "localhost", 
+                        server_id: str = None) -> bool:
+            """Start Socket.IO server, preferring daemon over standalone.
+            
+            WHY: When the standalone_socketio_server module is not available,
+            we fallback to using the daemon script which is always present.
+            """
+            # First check if the daemon is already running
+            if self.daemon_pidfile_path.exists():
+                try:
+                    with open(self.daemon_pidfile_path) as f:
+                        pid = int(f.read().strip())
+                    # Check if process is running
+                    import psutil
+                    process = psutil.Process(pid)
+                    if process.is_running():
+                        print(f"Socket.IO daemon server is already running (PID: {pid})")
+                        return True
+                except:
+                    pass
+            
+            # Try to use the daemon script for starting
+            if self.daemon_script.exists():
+                print(f"Starting server on {host}:{port or self.base_port} using daemon...")
+                try:
+                    result = subprocess.run(
+                        [sys.executable, str(self.daemon_script), "start"],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    if result.returncode == 0:
+                        # Check if output contains success message
+                        if "started successfully" in result.stdout.lower():
+                            print(result.stdout)
+                            return True
+                        # Even if no explicit success message, check if process is running
+                        elif self.daemon_pidfile_path.exists():
+                            print("Socket.IO daemon server started")
+                            return True
+                    else:
+                        # If daemon fails, try parent's start_server method
+                        if result.stderr:
+                            print(f"Daemon error: {result.stderr}")
+                        print("Trying standalone method...")
+                except Exception as e:
+                    print(f"Error running daemon: {e}")
+                    pass
+            
+            # Fall back to parent implementation
+            return super().start_server(port=port, host=host, server_id=server_id)
+        
+        def stop_server(self, port: int = None) -> bool:
+            """Stop Socket.IO server, handling daemon-style servers.
+            
+            WHY: The daemon server needs special handling for stopping.
+            """
+            # Check if daemon is running
+            if self.daemon_pidfile_path.exists():
+                print(f"🔄 Stopping daemon server", end="")
+                try:
+                    with open(self.daemon_pidfile_path) as f:
+                        pid = int(f.read().strip())
+                    print(f" (PID: {pid})...")
+                    
+                    result = subprocess.run(
+                        [sys.executable, str(self.daemon_script), "stop"],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    if result.returncode == 0:
+                        print("✅ Daemon server stopped successfully")
+                        return True
+                    else:
+                        print(f"❌ Failed to stop daemon: {result.stderr}")
+                except Exception as e:
+                    print(f"❌ Error stopping daemon: {e}")
+            
+            # Fall back to parent implementation for non-daemon servers
+            return super().stop_server(port=port)
+        
+        def restart_server(self, port: int = None) -> bool:
+            """Restart Socket.IO server, handling daemon-style servers.
+            
+            WHY: The daemon server needs special handling for restarting.
+            """
+            # Check if daemon is running
+            if self.daemon_pidfile_path.exists():
+                try:
+                    with open(self.daemon_pidfile_path) as f:
+                        pid = int(f.read().strip())
+                    
+                    print(f"🔄 Stopping daemon server (PID: {pid})...")
+                    
+                    # Stop the daemon
+                    result = subprocess.run(
+                        [sys.executable, str(self.daemon_script), "stop"],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    if result.returncode == 0:
+                        print("✅ Daemon server stopped successfully")
+                        # Wait a moment for clean shutdown
+                        import time
+                        time.sleep(1)
+                        
+                        # Start it again
+                        return self.start_server(port=port)
+                    else:
+                        print(f"❌ Failed to stop daemon: {result.stderr}")
+                        return False
+                        
+                except Exception as e:
+                    print(f"❌ Error restarting daemon: {e}")
+                    return False
+            else:
+                print("❌ No daemon server found (no PID file at {})".format(self.daemon_pidfile_path))
+                
+            # Fall back to parent implementation for non-daemon servers
+            return super().restart_server(port=port)
+    
+    # Re-export for use by CLI
+    __all__ = ["ServerManager"]
+    
+except ImportError as e:
+    # Fallback: If tools/admin version not available, provide basic implementation
+    # that delegates to socketio_daemon.py
+    
+    import subprocess
+    import json
+    import time
+    from typing import Dict, List, Optional, Any
+    
+    class ServerManager:
+        """Fallback ServerManager that uses socketio_daemon.py.
+        
+        WHY: This fallback ensures the monitor CLI command works even if
+        the full ServerManager from tools/admin is not available. It provides
+        basic functionality by delegating to the socketio_daemon.py script.
+        """
+        
+        def __init__(self):
+            self.daemon_script = script_dir / "socketio_daemon.py"
+            self.base_port = 8765
+            
+        def start_server(self, port: int = None, host: str = "localhost", 
+                        server_id: str = None) -> bool:
+            """Start the Socket.IO server using daemon script.
+            
+            WHY: The daemon script handles port selection and process management,
+            so we delegate to it for starting servers.
+            """
+            if port and port != self.base_port:
+                print(f"Note: Daemon only supports default port {self.base_port}")
+                print(f"Starting on port {self.base_port} instead...")
+            
+            try:
+                result = subprocess.run(
+                    [sys.executable, str(self.daemon_script), "start"],
+                    capture_output=True,
+                    text=True
+                )
+                
+                if result.returncode == 0:
+                    print("Socket.IO server started successfully")
+                    return True
+                else:
+                    print(f"Failed to start server: {result.stderr}")
+                    return False
+                    
+            except Exception as e:
+                print(f"Error starting server: {e}")
+                return False
+        
+        def stop_server(self, port: int = None) -> bool:
+            """Stop the Socket.IO server using daemon script."""
+            if port and port != self.base_port:
+                print(f"Note: Daemon only supports default port {self.base_port}")
+            
+            try:
+                result = subprocess.run(
+                    [sys.executable, str(self.daemon_script), "stop"],
+                    capture_output=True,
+                    text=True
+                )
+                
+                if result.returncode == 0:
+                    print("Socket.IO server stopped successfully")
+                    return True
+                else:
+                    print(f"Failed to stop server: {result.stderr}")
+                    return False
+                    
+            except Exception as e:
+                print(f"Error stopping server: {e}")
+                return False
+        
+        def restart_server(self, port: int = None) -> bool:
+            """Restart the Socket.IO server using daemon script."""
+            if port and port != self.base_port:
+                print(f"Note: Daemon only supports default port {self.base_port}")
+            
+            try:
+                result = subprocess.run(
+                    [sys.executable, str(self.daemon_script), "restart"],
+                    capture_output=True,
+                    text=True
+                )
+                
+                if result.returncode == 0:
+                    print("Socket.IO server restarted successfully")
+                    return True
+                else:
+                    print(f"Failed to restart server: {result.stderr}")
+                    return False
+                    
+            except Exception as e:
+                print(f"Error restarting server: {e}")
+                return False
+        
+        def list_running_servers(self) -> List[Dict[str, Any]]:
+            """List running servers using daemon script status."""
+            try:
+                result = subprocess.run(
+                    [sys.executable, str(self.daemon_script), "status"],
+                    capture_output=True,
+                    text=True
+                )
+                
+                # Parse status output to determine if server is running
+                if "is running" in result.stdout:
+                    # Extract port from output if possible
+                    port = self.base_port
+                    for line in result.stdout.split('\n'):
+                        if "port" in line.lower():
+                            try:
+                                # Try to extract port number
+                                import re
+                                match = re.search(r'port\s+(\d+)', line.lower())
+                                if match:
+                                    port = int(match.group(1))
+                            except:
+                                pass
+                    
+                    return [{
+                        "port": port,
+                        "server_id": "daemon-socketio",
+                        "status": "running"
+                    }]
+                else:
+                    return []
+                    
+            except Exception as e:
+                print(f"Error checking server status: {e}")
+                return []
+        
+        def get_server_info(self, port: int) -> Optional[Dict[str, Any]]:
+            """Get information about a server on a specific port."""
+            servers = self.list_running_servers()
+            for server in servers:
+                if server.get("port") == port:
+                    return server
+            return None
+
+
+# If running as a script, delegate to the actual socketio_server_manager.py
+if __name__ == "__main__":
+    try:
+        # Try to run the actual script from tools/admin
+        import subprocess
+        tools_script = tools_admin_dir / "socketio_server_manager.py"
+        if tools_script.exists():
+            subprocess.run([sys.executable, str(tools_script)] + sys.argv[1:])
+        else:
+            print("Socket.IO server manager not found in tools/admin")
+            print("Please ensure claude-mpm is properly installed")
+            sys.exit(1)
+    except Exception as e:
+        print(f"Error running server manager: {e}")
+        sys.exit(1)

claude_mpm/scripts/start_activity_logging.py

@@ -6,18 +6,18 @@ This script starts the event aggregator that captures all agent activity
 from the Socket.IO dashboard and saves it to .claude-mpm/activity/
 """
 
+import signal
 import sys
 import time
-import signal
-from pathlib import Path
 
 # Since we're now inside the claude_mpm package, use relative imports
 from ..core.config import Config
-from ..services.event_aggregator import EventAggregator
 from ..core.logger import get_logger
+from ..services.event_aggregator import EventAggregator
 
 logger = get_logger("activity_logging")
 
+
 def signal_handler(signum, frame):
     """Handle shutdown signals gracefully."""
     logger.info("Shutting down activity logging...")
@@ -25,55 +25,58 @@ def signal_handler(signum, frame):
         aggregator.stop()
     sys.exit(0)
 
+
 if __name__ == "__main__":
     # Load configuration
     config = Config()
-    
+
     # Check if event aggregator is enabled
-    if not config.get('event_aggregator.enabled', True):
+    if not config.get("event_aggregator.enabled", True):
         logger.warning("Event aggregator is disabled in configuration")
         logger.warning("Enable it by setting event_aggregator.enabled: true")
         sys.exit(1)
-    
+
     # Get configuration values
-    activity_dir = config.get('event_aggregator.activity_directory', '.claude-mpm/activity')
-    dashboard_port = config.get('event_aggregator.dashboard_port', 8765)
-    
+    activity_dir = config.get(
+        "event_aggregator.activity_directory", ".claude-mpm/activity"
+    )
+    dashboard_port = config.get("event_aggregator.dashboard_port", 8765)
+
     logger.info("=" * 60)
     logger.info("Starting Activity Logging Service")
     logger.info("=" * 60)
     logger.info(f"Activity Directory: {activity_dir}")
     logger.info(f"Dashboard Port: {dashboard_port}")
     logger.info("Connecting to Socket.IO dashboard...")
-    
+
     # Initialize aggregator
     aggregator = EventAggregator(
-        host="localhost",
-        port=dashboard_port,
-        save_dir=None  # Will use config value
+        host="localhost", port=dashboard_port, save_dir=None  # Will use config value
     )
-    
+
     # Set up signal handlers
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-    
+
     # Start the aggregator
     try:
         aggregator.start()
         logger.info("✅ Activity logging started successfully!")
         logger.info(f"📁 Saving activity to: {aggregator.save_dir}")
         logger.info("Press Ctrl+C to stop")
-        
+
         # Keep running and show periodic status
         while aggregator.running:
             time.sleep(30)
-            
+
             # Show status every 30 seconds
             status = aggregator.get_status()
-            if status['active_sessions'] > 0:
-                logger.info(f"📊 Status: {status['active_sessions']} active sessions, "
-                          f"{status['total_events']} events captured")
-            
+            if status["active_sessions"] > 0:
+                logger.info(
+                    f"📊 Status: {status['active_sessions']} active sessions, "
+                    f"{status['total_events']} events captured"
+                )
+
     except KeyboardInterrupt:
         logger.info("Received shutdown signal")
     except Exception as e:
@@ -83,4 +86,4 @@ if __name__ == "__main__":
             aggregator.stop()
             # Save any remaining sessions
             aggregator._save_all_sessions()
-            logger.info("Activity logging stopped")
+            logger.info("Activity logging stopped")

claude_mpm/services/__init__.py

@@ -11,156 +11,181 @@ New structure:
 - infrastructure/: Logging and monitoring services
 """
 
+
 # Use lazy imports to prevent circular dependency issues
 def __getattr__(name):
     """Lazy import to prevent circular dependencies."""
     if name == "TicketManager":
         from .ticket_manager import TicketManager
+
         return TicketManager
     elif name == "AgentDeploymentService":
-        # Try new location first, fall back to old
-        try:
-            from .agent.deployment import AgentDeploymentService
-            return AgentDeploymentService
-        except ImportError:
-            from .agents.deployment import AgentDeploymentService
-            return AgentDeploymentService
+        # Use correct path
+        from .agents.deployment import AgentDeploymentService
+
+        return AgentDeploymentService
     elif name == "AgentMemoryManager":
         from .agents.memory import AgentMemoryManager
+
         return AgentMemoryManager
     elif name == "get_memory_manager":
         from .agents.memory import get_memory_manager
+
         return get_memory_manager
     # Add backward compatibility for other agent services
     elif name == "AgentRegistry":
-        # Try new location first, fall back to old
-        try:
-            from .agent.registry import AgentRegistry
-            return AgentRegistry
-        except ImportError:
-            from .agents.registry import AgentRegistry
-            return AgentRegistry
+        # Use correct path
+        from .agents.registry import AgentRegistry
+
+        return AgentRegistry
     elif name == "AgentLifecycleManager":
         from .agents.deployment import AgentLifecycleManager
+
         return AgentLifecycleManager
     elif name == "AgentManager":
         from .agents.management import AgentManager
+
         return AgentManager
     elif name == "AgentCapabilitiesGenerator":
         from .agents.management import AgentCapabilitiesGenerator
+
         return AgentCapabilitiesGenerator
     elif name == "AgentModificationTracker":
         from .agents.registry import AgentModificationTracker
+
         return AgentModificationTracker
     elif name == "AgentPersistenceService":
         from .agents.memory import AgentPersistenceService
+
         return AgentPersistenceService
     elif name == "AgentProfileLoader":
         from .agents.loading import AgentProfileLoader
+
         return AgentProfileLoader
     elif name == "AgentVersionManager":
         from .agents.deployment import AgentVersionManager
+
         return AgentVersionManager
     elif name == "BaseAgentManager":
         from .agents.loading import BaseAgentManager
+
         return BaseAgentManager
     elif name == "DeployedAgentDiscovery":
         from .agents.registry import DeployedAgentDiscovery
+
         return DeployedAgentDiscovery
     elif name == "FrameworkAgentLoader":
         from .agents.loading import FrameworkAgentLoader
+
         return FrameworkAgentLoader
     elif name == "HookService":
         from .hook_service import HookService
+
         return HookService
     elif name == "ProjectAnalyzer":
-        # Try new location first, fall back to old
-        try:
-            from .project.analyzer import ProjectAnalyzer
-            return ProjectAnalyzer
-        except ImportError:
-            from .project_analyzer import ProjectAnalyzer
-            return ProjectAnalyzer
-    elif name == "AdvancedHealthMonitor" or name == "HealthMonitor":
-        try:
-            from .infrastructure.monitoring import HealthMonitor
-            return HealthMonitor
-        except ImportError:
-            try:
-                from .health_monitor import AdvancedHealthMonitor
-                return AdvancedHealthMonitor
-            except ImportError:
-                raise AttributeError(f"Health monitoring not available: {name}")
+        from .project.analyzer import ProjectAnalyzer
+
+        return ProjectAnalyzer
+    elif name == "AdvancedHealthMonitor":
+        from .infrastructure.monitoring import AdvancedHealthMonitor
+
+        return AdvancedHealthMonitor
+    elif name == "HealthMonitor":
+        # For backward compatibility, return AdvancedHealthMonitor
+        # Note: There's also a different HealthMonitor in infrastructure.health_monitor
+        from .infrastructure.monitoring import AdvancedHealthMonitor
+
+        return AdvancedHealthMonitor
     elif name == "RecoveryManager":
         try:
             from .recovery_manager import RecoveryManager
+
             return RecoveryManager
         except ImportError:
             raise AttributeError(f"Recovery management not available: {name}")
     elif name == "StandaloneSocketIOServer" or name == "SocketIOServer":
-        try:
-            from .communication.socketio import SocketIOServer
-            return SocketIOServer
-        except ImportError:
-            from .standalone_socketio_server import StandaloneSocketIOServer
-            return StandaloneSocketIOServer
+        from .socketio_server import SocketIOServer
+
+        return SocketIOServer
     # Backward compatibility for memory services
     elif name == "MemoryBuilder":
         from .memory.builder import MemoryBuilder
+
         return MemoryBuilder
     elif name == "MemoryRouter":
         from .memory.router import MemoryRouter
+
         return MemoryRouter
     elif name == "MemoryOptimizer":
         from .memory.optimizer import MemoryOptimizer
+
         return MemoryOptimizer
     elif name == "SimpleCacheService":
         from .memory.cache.simple_cache import SimpleCacheService
+
         return SimpleCacheService
     elif name == "SharedPromptCache":
         from .memory.cache.shared_prompt_cache import SharedPromptCache
+
         return SharedPromptCache
     # New service organization imports
     elif name == "AgentManagementService":
-        from .agent.management import AgentManagementService
-        return AgentManagementService
+        from .agents.management import AgentManager
+
+        return AgentManager
     elif name == "ProjectRegistry":
         from .project.registry import ProjectRegistry
+
         return ProjectRegistry
     elif name == "LoggingService":
         from .infrastructure.logging import LoggingService
+
         return LoggingService
     elif name == "SocketIOClientManager":
-        from .communication.websocket import SocketIOClientManager
+        from .socketio_client_manager import SocketIOClientManager
+
         return SocketIOClientManager
     # MCP Gateway services
     elif name == "MCPConfiguration":
         from .mcp_gateway.config.configuration import MCPConfiguration
+
         return MCPConfiguration
     elif name == "MCPConfigLoader":
         from .mcp_gateway.config.config_loader import MCPConfigLoader
+
         return MCPConfigLoader
     elif name == "MCPServer":
         from .mcp_gateway.server.mcp_server import MCPServer
+
         return MCPServer
     elif name == "MCPToolRegistry":
         from .mcp_gateway.tools.tool_registry import MCPToolRegistry
+
         return MCPToolRegistry
     elif name == "BaseMCPService":
         from .mcp_gateway.core.base import BaseMCPService
+
         return BaseMCPService
     elif name.startswith("IMCP"):
         from .mcp_gateway.core import interfaces
+
         return getattr(interfaces, name)
     elif name.startswith("MCP") and "Error" in name:
         from .mcp_gateway.core import exceptions
+
         return getattr(exceptions, name)
     # Core interfaces and base classes
-    elif name.startswith('I') or name in ['BaseService', 'SyncBaseService', 'SingletonService']:
+    elif name.startswith("I") or name in [
+        "BaseService",
+        "SyncBaseService",
+        "SingletonService",
+    ]:
         from . import core
+
         return getattr(core, name)
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
+
 __all__ = [
     "TicketManager",
     "AgentDeploymentService",
@@ -170,7 +195,7 @@ __all__ = [
     "ProjectAnalyzer",
     "AdvancedHealthMonitor",
     "HealthMonitor",  # New alias
-    "RecoveryManager", 
+    "RecoveryManager",
     "StandaloneSocketIOServer",
     "SocketIOServer",  # New alias
     # Additional agent services for backward compatibility
@@ -208,4 +233,4 @@ __all__ = [
     "BaseService",
     "SyncBaseService",
     "SingletonService",
-]
+]