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

claude_mpm/scripts/socketio_server_manager.py

@@ -24,30 +24,35 @@ if tools_admin_dir.exists() and str(tools_admin_dir) not in sys.path:
 
 try:
     # Import ServerManager from the actual implementation
-    from socketio_server_manager import ServerManager as BaseServerManager
     import subprocess
-    
+
+    from socketio_server_manager import ServerManager as BaseServerManager
+
     # 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_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:
+
+        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.
             """
@@ -58,30 +63,36 @@ try:
                         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})")
+                        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...")
+                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
+                        text=True,
+                        check=False,
                     )
-                    
+
                     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():
+                        if self.daemon_pidfile_path.exists():
                             print("Socket.IO daemon server started")
                             return True
                     else:
@@ -91,44 +102,43 @@ try:
                         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="")
+                print("🔄 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
+                        text=True,
+                        check=False,
                     )
-                    
+
                     if result.returncode == 0:
                         print("✅ Daemon server stopped successfully")
                         return True
-                    else:
-                        print(f"❌ Failed to stop daemon: {result.stderr}")
+                    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
@@ -136,172 +146,180 @@ try:
                 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
+                        text=True,
+                        check=False,
                     )
-                    
+
                     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
-                        
+                    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))
-                
+                print(
+                    f"❌ No daemon server found (no PID file at {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:
+
+except ImportError:
     # 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
-    
+    from typing import Any, Dict, List, Optional
+
     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:
+
+        def start_server(
+            self,
+            port: Optional[int] = None,
+            host: str = "localhost",
+            server_id: Optional[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
+                    text=True,
+                    check=False,
                 )
-                
+
                 if result.returncode == 0:
                     print("Socket.IO server started successfully")
                     return True
-                else:
-                    print(f"Failed to start server: {result.stderr}")
-                    return False
-                    
+                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:
+
+        def stop_server(self, port: Optional[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
+                    text=True,
+                    check=False,
                 )
-                
+
                 if result.returncode == 0:
                     print("Socket.IO server stopped successfully")
                     return True
-                else:
-                    print(f"Failed to stop server: {result.stderr}")
-                    return False
-                    
+                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:
+
+        def restart_server(self, port: Optional[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
+                    text=True,
+                    check=False,
                 )
-                
+
                 if result.returncode == 0:
                     print("Socket.IO server restarted successfully")
                     return True
-                else:
-                    print(f"Failed to restart server: {result.stderr}")
-                    return False
-                    
+                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
+                    text=True,
+                    check=False,
                 )
-                
+
                 # 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'):
+                    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())
+
+                                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 []
-                    
+
+                    return [
+                        {
+                            "port": port,
+                            "server_id": "daemon-socketio",
+                            "status": "running",
+                        }
+                    ]
+                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()
@@ -316,13 +334,16 @@ 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:])
+            subprocess.run(
+                [sys.executable, str(tools_script)] + sys.argv[1:], check=False
+            )
         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)
+        sys.exit(1)

claude_mpm/services/__init__.py

@@ -19,91 +19,91 @@ def __getattr__(name):
         from .ticket_manager import TicketManager
 
         return TicketManager
-    elif name == "AgentDeploymentService":
+    if name == "AgentDeploymentService":
         # Use correct path
         from .agents.deployment import AgentDeploymentService
 
         return AgentDeploymentService
-    elif name == "AgentMemoryManager":
+    if name == "AgentMemoryManager":
         from .agents.memory import AgentMemoryManager
 
         return AgentMemoryManager
-    elif name == "get_memory_manager":
+    if 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":
+    if name == "AgentRegistry":
         # Use correct path
         from .agents.registry import AgentRegistry
 
         return AgentRegistry
-    elif name == "AgentLifecycleManager":
+    if name == "AgentLifecycleManager":
         from .agents.deployment import AgentLifecycleManager
 
         return AgentLifecycleManager
-    elif name == "AgentManager":
+    if name == "AgentManager":
         from .agents.management import AgentManager
 
         return AgentManager
-    elif name == "AgentCapabilitiesGenerator":
+    if name == "AgentCapabilitiesGenerator":
         from .agents.management import AgentCapabilitiesGenerator
 
         return AgentCapabilitiesGenerator
-    elif name == "AgentModificationTracker":
+    if name == "AgentModificationTracker":
         from .agents.registry import AgentModificationTracker
 
         return AgentModificationTracker
-    elif name == "AgentPersistenceService":
+    if name == "AgentPersistenceService":
         from .agents.memory import AgentPersistenceService
 
         return AgentPersistenceService
-    elif name == "AgentProfileLoader":
+    if name == "AgentProfileLoader":
         from .agents.loading import AgentProfileLoader
 
         return AgentProfileLoader
-    elif name == "AgentVersionManager":
+    if name == "AgentVersionManager":
         from .agents.deployment import AgentVersionManager
 
         return AgentVersionManager
-    elif name == "BaseAgentManager":
+    if name == "BaseAgentManager":
         from .agents.loading import BaseAgentManager
 
         return BaseAgentManager
-    elif name == "DeployedAgentDiscovery":
+    if name == "DeployedAgentDiscovery":
         from .agents.registry import DeployedAgentDiscovery
 
         return DeployedAgentDiscovery
-    elif name == "FrameworkAgentLoader":
+    if name == "FrameworkAgentLoader":
         from .agents.loading import FrameworkAgentLoader
 
         return FrameworkAgentLoader
-    elif name == "HookService":
+    if name == "HookService":
         from .hook_service import HookService
 
         return HookService
-    elif name == "ProjectAnalyzer":
+    if name == "ProjectAnalyzer":
         from .project.analyzer import ProjectAnalyzer
 
         return ProjectAnalyzer
-    elif name == "AdvancedHealthMonitor":
+    if name == "AdvancedHealthMonitor":
         from .infrastructure.monitoring import AdvancedHealthMonitor
 
         return AdvancedHealthMonitor
-    elif name == "HealthMonitor":
+    if 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":
+    if 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":
+    elif name in {"StandaloneSocketIOServer", "SocketIOServer"}:
         from .socketio_server import SocketIOServer
 
         return SocketIOServer
@@ -187,50 +187,50 @@ def __getattr__(name):
 
 
 __all__ = [
-    "TicketManager",
-    "AgentDeploymentService",
-    "AgentMemoryManager",
-    "get_memory_manager",
-    "HookService",
-    "ProjectAnalyzer",
     "AdvancedHealthMonitor",
-    "HealthMonitor",  # New alias
-    "RecoveryManager",
-    "StandaloneSocketIOServer",
-    "SocketIOServer",  # New alias
-    # Additional agent services for backward compatibility
-    "AgentRegistry",
+    "AgentCapabilitiesGenerator",
+    "AgentDeploymentService",
     "AgentLifecycleManager",
-    "AgentManager",
     "AgentManagementService",  # New service
-    "AgentCapabilitiesGenerator",
+    "AgentManager",
+    "AgentMemoryManager",
     "AgentModificationTracker",
     "AgentPersistenceService",
     "AgentProfileLoader",
+    # Additional agent services for backward compatibility
+    "AgentRegistry",
     "AgentVersionManager",
     "BaseAgentManager",
+    "BaseMCPService",
+    # Core exports
+    "BaseService",
     "DeployedAgentDiscovery",
     "FrameworkAgentLoader",
-    # Project services
-    "ProjectRegistry",  # New service
+    "HealthMonitor",  # New alias
+    "HookService",
     # Infrastructure services
     "LoggingService",  # New service
-    # Communication services
-    "SocketIOClientManager",  # New service
-    # Memory services (backward compatibility)
-    "MemoryBuilder",
-    "MemoryRouter",
-    "MemoryOptimizer",
-    "SimpleCacheService",
-    "SharedPromptCache",
+    "MCPConfigLoader",
     # MCP Gateway services
     "MCPConfiguration",
-    "MCPConfigLoader",
     "MCPServer",
     "MCPToolRegistry",
-    "BaseMCPService",
-    # Core exports
-    "BaseService",
-    "SyncBaseService",
+    # Memory services (backward compatibility)
+    "MemoryBuilder",
+    "MemoryOptimizer",
+    "MemoryRouter",
+    "ProjectAnalyzer",
+    # Project services
+    "ProjectRegistry",  # New service
+    "RecoveryManager",
+    "SharedPromptCache",
+    "SimpleCacheService",
     "SingletonService",
+    # Communication services
+    "SocketIOClientManager",  # New service
+    "SocketIOServer",  # New alias
+    "StandaloneSocketIOServer",
+    "SyncBaseService",
+    "TicketManager",
+    "get_memory_manager",
 ]