claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -0,0 +1,439 @@
+"""
+Unified Dashboard Manager Service
+=================================
+
+WHY: This service provides a centralized way to manage dashboard functionality using
+the UnifiedMonitorDaemon. It replaces the old DashboardLauncher and SocketIOManager
+services with a cleaner implementation that uses the unified daemon architecture.
+
+DESIGN DECISIONS:
+- Uses UnifiedMonitorDaemon for all server functionality
+- Provides the same interface as the old services for compatibility
+- Handles browser opening, process management, and status checking
+- Integrates with PortManager for port allocation
+- Thread-safe daemon management
+"""
+
+import threading
+import time
+import webbrowser
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import requests
+
+from ...core.logging_config import get_logger
+from ...services.monitor.daemon import UnifiedMonitorDaemon
+from ...services.monitor.daemon_manager import DaemonManager
+from ...services.port_manager import PortManager
+
+
+@dataclass
+class DashboardInfo:
+    """Information about a running dashboard."""
+
+    url: str
+    port: int
+    pid: Optional[int] = None
+    status: str = "running"
+
+
+class IUnifiedDashboardManager(ABC):
+    """Interface for unified dashboard management."""
+
+    @abstractmethod
+    def start_dashboard(
+        self, port: int = 8765, background: bool = False, open_browser: bool = True
+    ) -> Tuple[bool, bool]:
+        """Start the dashboard using unified daemon."""
+
+    @abstractmethod
+    def stop_dashboard(self, port: int = 8765) -> bool:
+        """Stop the dashboard."""
+
+    @abstractmethod
+    def is_dashboard_running(self, port: int = 8765) -> bool:
+        """Check if dashboard is running."""
+
+    @abstractmethod
+    def get_dashboard_url(self, port: int = 8765) -> str:
+        """Get dashboard URL."""
+
+    @abstractmethod
+    def open_browser(self, url: str) -> bool:
+        """Open URL in browser."""
+
+
+class UnifiedDashboardManager(IUnifiedDashboardManager):
+    """Unified dashboard manager using UnifiedMonitorDaemon."""
+
+    def __init__(self, logger=None):
+        """Initialize the unified dashboard manager."""
+        self.logger = logger or get_logger("UnifiedDashboardManager")
+        self.port_manager = PortManager()
+        self._background_daemons = {}  # port -> daemon instance
+        self._lock = threading.Lock()
+
+    def start_dashboard(
+        self,
+        port: int = 8765,
+        background: bool = False,
+        open_browser: bool = True,
+        force_restart: bool = False,
+    ) -> Tuple[bool, bool]:
+        """
+        Start the dashboard using unified daemon.
+
+        Args:
+            port: Port to run dashboard on
+            background: Whether to run in background mode
+            open_browser: Whether to open browser automatically
+            force_restart: If True, restart existing service if it's ours
+
+        Returns:
+            Tuple of (success, browser_opened)
+        """
+        try:
+            # Create daemon instance to check service status
+            daemon = UnifiedMonitorDaemon(
+                host="localhost", port=port, daemon_mode=background
+            )
+
+            # Use daemon manager to check service ownership
+            daemon_mgr = DaemonManager(port=port, host="localhost")
+            is_ours, pid = daemon_mgr.is_our_service()
+
+            if is_ours and not force_restart:
+                # Our service is already running, just open browser if needed
+                self.logger.info(
+                    f"Our dashboard already running on port {port} (PID: {pid})"
+                )
+                browser_opened = False
+                if open_browser:
+                    browser_opened = self.open_browser(self.get_dashboard_url(port))
+                return True, browser_opened
+            if is_ours and force_restart:
+                self.logger.info(
+                    f"Force restarting our dashboard on port {port} (PID: {pid})"
+                )
+                # Don't cleanup here - let daemon.start(force_restart=True) handle it
+                # This prevents race conditions where we kill the service we're trying to start
+            elif self.is_dashboard_running(port) and not force_restart:
+                # Different service is using the port - don't clean it up without force_restart
+                self.logger.warning(
+                    f"Port {port} is in use by a different service. Use force_restart to override."
+                )
+                return False, False
+
+            self.logger.info(
+                f"Starting unified dashboard on port {port} (background: {background}, force_restart: {force_restart})"
+            )
+
+            if background:
+                # The daemon.start() method will handle cleanup when force_restart=True
+                # We don't need pre-emptive cleanup here as it causes race conditions
+
+                # Try to start daemon with retry on port conflicts
+                max_retries = 3
+                retry_count = 0
+                success = False
+
+                while retry_count < max_retries and not success:
+                    if retry_count > 0:
+                        # Only cleanup on retries, not on first attempt
+                        self.logger.info(
+                            f"Retry {retry_count}/{max_retries}: Cleaning up port {port}"
+                        )
+                        daemon_mgr = DaemonManager(port=port, host="localhost")
+                        if not daemon_mgr.cleanup_port_conflicts():
+                            self.logger.error(f"Cleanup failed on retry {retry_count}")
+                            break
+                        time.sleep(3)  # Longer wait for cleanup to complete
+
+                    # Start daemon in background mode with force restart
+                    # The daemon.start() method handles its own cleanup when force_restart=True
+                    success = daemon.start(force_restart=force_restart)
+
+                    if not success and retry_count < max_retries - 1:
+                        # Check if it's a port conflict
+                        if not self.port_manager.is_port_available(port):
+                            self.logger.warning(
+                                f"Port {port} still in use, will retry cleanup"
+                            )
+                            retry_count += 1
+                        else:
+                            # Different kind of failure, don't retry
+                            self.logger.error(
+                                "Daemon start failed for reason other than port conflict"
+                            )
+                            break
+                    else:
+                        break
+
+                if success:
+                    with self._lock:
+                        self._background_daemons[port] = daemon
+
+                    # Wait for daemon to be ready
+                    if self._wait_for_dashboard(port, timeout=10):
+                        browser_opened = False
+                        if open_browser:
+                            browser_opened = self.open_browser(
+                                self.get_dashboard_url(port)
+                            )
+                        return True, browser_opened
+                    self.logger.error("Dashboard daemon started but not responding")
+                    return False, False
+                self.logger.error("Failed to start dashboard daemon")
+                return False, False
+            # For foreground mode, the caller should handle the daemon directly
+            # This is used by the CLI command that runs in foreground
+            self.logger.info("Foreground mode should be handled by caller")
+            return True, False
+
+        except Exception as e:
+            self.logger.error(f"Error starting dashboard: {e}")
+            return False, False
+
+    def stop_dashboard(self, port: int = 8765) -> bool:
+        """
+        Stop the dashboard.
+
+        Args:
+            port: Port of dashboard to stop
+
+        Returns:
+            True if successfully stopped
+        """
+        try:
+            # Check if we have a background daemon for this port
+            with self._lock:
+                daemon = self._background_daemons.get(port)
+                if daemon:
+                    daemon.stop()
+                    del self._background_daemons[port]
+                    self.logger.info(f"Stopped background daemon on port {port}")
+                    return True
+
+            # Try to stop via process management
+            # Check if port is in use (is_port_available returns False if in use)
+            if not self.port_manager.is_port_available(port):
+                # Use port manager to find and stop the process
+                active_instances = self.port_manager.list_active_instances()
+                for instance in active_instances:
+                    if instance.get("port") == port:
+                        pid = instance.get("pid")
+                        if pid:
+                            try:
+                                import psutil
+
+                                process = psutil.Process(pid)
+                                process.terminate()
+                                process.wait(timeout=5)
+                                self.logger.info(
+                                    f"Terminated dashboard process {pid} on port {port}"
+                                )
+                                return True
+                            except Exception as e:
+                                self.logger.warning(
+                                    f"Failed to terminate process {pid}: {e}"
+                                )
+
+            self.logger.warning(f"No dashboard found running on port {port}")
+            return False
+
+        except Exception as e:
+            self.logger.error(f"Error stopping dashboard: {e}")
+            return False
+
+    def is_dashboard_running(self, port: int = 8765) -> bool:
+        """
+        Check if dashboard is running.
+
+        Args:
+            port: Port to check
+
+        Returns:
+            True if dashboard is running
+        """
+        try:
+            response = requests.get(f"http://localhost:{port}/health", timeout=2)
+            return response.status_code == 200
+        except requests.exceptions.RequestException:
+            return False
+
+    def get_dashboard_url(self, port: int = 8765) -> str:
+        """
+        Get dashboard URL.
+
+        Args:
+            port: Port number
+
+        Returns:
+            Dashboard URL
+        """
+        return f"http://localhost:{port}"
+
+    def open_browser(self, url: str) -> bool:
+        """
+        Open URL in browser.
+
+        Args:
+            url: URL to open
+
+        Returns:
+            True if browser was opened successfully
+        """
+        try:
+            self.logger.info(f"Opening browser to {url}")
+            webbrowser.open(url)
+            return True
+        except Exception as e:
+            self.logger.warning(f"Failed to open browser: {e}")
+            return False
+
+    def _wait_for_dashboard(self, port: int, timeout: int = 30) -> bool:
+        """
+        Wait for dashboard to be ready.
+
+        Args:
+            port: Port to check
+            timeout: Maximum time to wait
+
+        Returns:
+            True if dashboard became ready
+        """
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_dashboard_running(port):
+                return True
+            time.sleep(0.5)
+        return False
+
+    def get_dashboard_info(self, port: int = 8765) -> Optional[DashboardInfo]:
+        """
+        Get information about running dashboard.
+
+        Args:
+            port: Port to check
+
+        Returns:
+            DashboardInfo if running, None otherwise
+        """
+        if self.is_dashboard_running(port):
+            return DashboardInfo(
+                url=self.get_dashboard_url(port), port=port, status="running"
+            )
+        return None
+
+    def ensure_dependencies(self) -> Tuple[bool, Optional[str]]:
+        """
+        Ensure required dependencies are available.
+
+        Returns:
+            Tuple of (dependencies_ok, error_message)
+        """
+        import importlib.util
+
+        missing = []
+        if importlib.util.find_spec("aiohttp") is None:
+            missing.append("aiohttp")
+        if importlib.util.find_spec("socketio") is None:
+            missing.append("socketio")
+
+        if missing:
+            error_msg = f"Required dependencies missing: {', '.join(missing)}"
+            return False, error_msg
+        return True, None
+
+    def find_available_port(self, preferred_port: int = 8765) -> int:
+        """
+        Find an available port starting from the preferred port.
+
+        Args:
+            preferred_port: Preferred port to start checking from
+
+        Returns:
+            Available port number
+        """
+        return self.port_manager.find_available_port(preferred_port)
+
+    def _cleanup_port_conflicts(self, port: int) -> bool:
+        """
+        Try to clean up any processes using our port.
+
+        Delegates to the consolidated DaemonManager for consistent behavior.
+
+        Args:
+            port: Port to clean up
+
+        Returns:
+            True if cleanup was successful or not needed
+        """
+        daemon_mgr = DaemonManager(port=port, host="localhost")
+        return daemon_mgr.cleanup_port_conflicts()
+
+    def start_server(
+        self, port: Optional[int] = None, timeout: int = 30, force_restart: bool = True
+    ) -> Tuple[bool, DashboardInfo]:
+        """
+        Start the server (compatibility method for SocketIOManager interface).
+
+        Args:
+            port: Port to use (finds available if None)
+            timeout: Timeout for startup
+            force_restart: If True, restart existing service if it's ours
+
+        Returns:
+            Tuple of (success, DashboardInfo)
+        """
+        if port is None:
+            port = self.find_available_port()
+
+        # Use force_restart to ensure we're using the latest code
+        success, _browser_opened = self.start_dashboard(
+            port=port, background=True, open_browser=False, force_restart=force_restart
+        )
+
+        if success:
+            dashboard_info = DashboardInfo(
+                url=self.get_dashboard_url(port), port=port, status="running"
+            )
+            return True, dashboard_info
+        return False, DashboardInfo(url="", port=port, status="failed")
+
+    def is_server_running(self, port: int) -> bool:
+        """
+        Check if server is running (compatibility method for SocketIOManager interface).
+
+        Args:
+            port: Port to check
+
+        Returns:
+            True if server is running
+        """
+        return self.is_dashboard_running(port)
+
+    def stop_server(self, port: Optional[int] = None, timeout: int = 10) -> bool:
+        """
+        Stop the server (compatibility method for SocketIOManager interface).
+
+        Args:
+            port: Port to stop (stops all if None)
+            timeout: Timeout for shutdown
+
+        Returns:
+            True if stopped successfully
+        """
+        if port is None:
+            # Stop all background daemons
+            with self._lock:
+                ports_to_stop = list(self._background_daemons.keys())
+
+            success = True
+            for p in ports_to_stop:
+                if not self.stop_dashboard(p):
+                    success = False
+            return success
+        return self.stop_dashboard(port)

claude_mpm/services/command_deployment_service.py

@@ -84,13 +84,15 @@ class CommandDeploymentService(BaseService):
 
                 try:
                     # Check if file exists and if we should overwrite
-                    if target_file.exists() and not force:
-                        # Check if source is newer
-                        if source_file.stat().st_mtime <= target_file.stat().st_mtime:
-                            self.logger.debug(
-                                f"Skipping {source_file.name} - target is up to date"
-                            )
-                            continue
+                    if (
+                        target_file.exists()
+                        and not force
+                        and source_file.stat().st_mtime <= target_file.stat().st_mtime
+                    ):
+                        self.logger.debug(
+                            f"Skipping {source_file.name} - target is up to date"
+                        )
+                        continue
 
                     # Copy the file
                     shutil.copy2(source_file, target_file)

claude_mpm/services/command_handler_service.py

@@ -12,6 +12,7 @@ Extracted from ClaudeRunner to follow Single Responsibility Principle.
 from typing import Any, Dict, List
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.services.core.interfaces import CommandHandlerInterface
 
 
@@ -169,7 +170,7 @@ class CommandHandlerService(BaseService, CommandHandlerInterface):
             if command == "test":
                 success = self._handle_test_command(args)
                 return {
-                    "success": success,
+                    OperationResult.SUCCESS.value: success,
                     "command": command,
                     "args": args,
                     "message": (
@@ -179,7 +180,7 @@ class CommandHandlerService(BaseService, CommandHandlerInterface):
             if command == "agents":
                 success = self._handle_agents_command(args)
                 return {
-                    "success": success,
+                    OperationResult.SUCCESS.value: success,
                     "command": command,
                     "args": args,
                     "message": (
@@ -189,14 +190,19 @@ class CommandHandlerService(BaseService, CommandHandlerInterface):
                     ),
                 }
             return {
-                "success": False,
+                OperationResult.SUCCESS.value: False,
                 "command": command,
                 "args": args,
-                "error": f"Unknown command: {command}",
+                OperationResult.ERROR.value: f"Unknown command: {command}",
                 "available_commands": self.get_available_commands(),
             }
         except Exception as e:
-            return {"success": False, "command": command, "args": args, "error": str(e)}
+            return {
+                OperationResult.SUCCESS.value: False,
+                "command": command,
+                "args": args,
+                OperationResult.ERROR.value: str(e),
+            }
 
     def get_command_help(self, command: str) -> str:
         """Get help text for a specific command.

claude_mpm/services/core/__init__.py

@@ -16,7 +16,9 @@ from .interfaces import (  # Core dependency injection; Configuration management
     CacheEntry,
     HealthStatus,
     HookServiceInterface,
+    IAgentRecommender,
     IAgentRegistry,
+    IAutoConfigManager,
     ICacheService,
     IConfigurationManager,
     IConfigurationService,
@@ -31,6 +33,7 @@ from .interfaces import (  # Core dependency injection; Configuration management
     IServiceLifecycle,
     IStructuredLogger,
     ITemplateManager,
+    IToolchainAnalyzer,
     MemoryServiceInterface,
     ProjectAnalyzerInterface,
     ServiceType,
@@ -38,8 +41,21 @@ from .interfaces import (  # Core dependency injection; Configuration management
     TemplateRenderContext,
     TicketManagerInterface,
 )
+from .models import (  # Data models for services
+    AgentCapabilities,
+    AgentRecommendation,
+    ConfidenceLevel,
+    ConfigurationPreview,
+    ConfigurationResult,
+    DeploymentTarget,
+    Framework,
+    LanguageDetection,
+    ToolchainAnalysis,
+    ToolchainComponent,
+    ValidationResult,
+)
 
-__all__ = [
+__all__ = [  # noqa: RUF022 - Grouped by category with comments for clarity
     # Service interfaces
     "AgentDeploymentInterface",
     "AgentMetadata",
@@ -48,7 +64,9 @@ __all__ = [
     "CacheEntry",
     "HealthStatus",
     "HookServiceInterface",
+    "IAgentRecommender",
     "IAgentRegistry",
+    "IAutoConfigManager",
     "ICacheService",
     "IConfigurationManager",
     "IConfigurationService",
@@ -63,6 +81,7 @@ __all__ = [
     "IServiceLifecycle",
     "IStructuredLogger",
     "ITemplateManager",
+    "IToolchainAnalyzer",
     # Registry
     "InterfaceRegistry",
     "MemoryServiceInterface",
@@ -73,4 +92,17 @@ __all__ = [
     "SyncBaseService",
     "TemplateRenderContext",
     "TicketManagerInterface",
+    # Data models - Toolchain
+    "ConfidenceLevel",
+    "ToolchainComponent",
+    "LanguageDetection",
+    "Framework",
+    "DeploymentTarget",
+    "ToolchainAnalysis",
+    # Data models - Agent Configuration
+    "AgentCapabilities",
+    "AgentRecommendation",
+    "ConfigurationResult",
+    "ValidationResult",
+    "ConfigurationPreview",
 ]

claude_mpm/services/core/base.py

@@ -9,6 +9,7 @@ and lifecycle management.
 Part of TSK-0046: Service Layer Architecture Reorganization
 """
 
+import threading
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 
@@ -221,29 +222,43 @@ class SingletonService(SyncBaseService):
     """
     Base class for singleton services.
 
-    Ensures only one instance of the service exists.
+    Ensures only one instance of the service exists with thread-safe initialization.
+    Uses double-checked locking pattern to prevent race conditions.
     """
 
     _instances: Dict[type, "SingletonService"] = {}
+    _lock = threading.Lock()
 
     def __new__(cls, *args, **kwargs):
-        """Ensure only one instance exists."""
+        """Ensure only one instance exists with thread-safe initialization."""
+        # Fast path - check without lock
         if cls not in cls._instances:
-            cls._instances[cls] = super().__new__(cls)
+            # Slow path - acquire lock and double-check
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = super().__new__(cls)
         return cls._instances[cls]
 
     @classmethod
     def get_instance(cls) -> "SingletonService":
-        """Get the singleton instance."""
+        """Get the singleton instance with thread-safe initialization."""
+        # Fast path - check without lock
         if cls not in cls._instances:
-            cls._instances[cls] = cls()
+            # Slow path - acquire lock and double-check
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = cls()
         return cls._instances[cls]
 
     @classmethod
     def clear_instance(cls) -> None:
-        """Clear the singleton instance (useful for testing)."""
-        if cls in cls._instances:
-            instance = cls._instances[cls]
-            if hasattr(instance, "shutdown") and not instance.is_shutdown:
-                instance.shutdown()
-            del cls._instances[cls]
+        """Clear the singleton instance (useful for testing).
+
+        Thread-safe implementation ensures proper cleanup.
+        """
+        with cls._lock:
+            if cls in cls._instances:
+                instance = cls._instances[cls]
+                if hasattr(instance, "shutdown") and not instance.is_shutdown:
+                    instance.shutdown()
+                del cls._instances[cls]