claude-mpm 4.2.7__py3-none-any.whl → 4.2.11__py3-none-any.whl

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -0,0 +1,354 @@
+"""
+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.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
+    ) -> 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
+
+        Returns:
+            Tuple of (success, browser_opened)
+        """
+        try:
+            # Check if already running
+            if self.is_dashboard_running(port):
+                self.logger.info(f"Dashboard already running on port {port}")
+                browser_opened = False
+                if open_browser:
+                    browser_opened = self.open_browser(self.get_dashboard_url(port))
+                return True, browser_opened
+
+            self.logger.info(
+                f"Starting unified dashboard on port {port} (background: {background})"
+            )
+
+            if background:
+                # Start daemon in background mode
+                daemon = UnifiedMonitorDaemon(
+                    host="localhost", port=port, daemon_mode=True
+                )
+
+                success = daemon.start()
+                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
+            if self.port_manager.is_port_in_use(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)
+        """
+        try:
+            import aiohttp
+            import socketio
+
+            return True, None
+        except ImportError as e:
+            error_msg = f"Required dependencies missing: {e}"
+            return False, error_msg
+
+    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 start_server(
+        self, port: Optional[int] = None, timeout: int = 30
+    ) -> Tuple[bool, DashboardInfo]:
+        """
+        Start the server (compatibility method for SocketIOManager interface).
+
+        Args:
+            port: Port to use (finds available if None)
+            timeout: Timeout for startup
+
+        Returns:
+            Tuple of (success, DashboardInfo)
+        """
+        if port is None:
+            port = self.find_available_port()
+
+        success, browser_opened = self.start_dashboard(
+            port=port, background=True, open_browser=False
+        )
+
+        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/monitor/__init__.py

@@ -0,0 +1,20 @@
+"""
+Unified Monitor Service for Claude MPM
+=====================================
+
+WHY: This module provides a single, stable daemon process that combines all
+monitoring functionality into one cohesive service. It replaces the multiple
+competing server implementations with a unified solution.
+
+DESIGN DECISIONS:
+- Single process handles HTTP dashboard, Socket.IO events, and real AST analysis
+- Uses proven aiohttp + socketio foundation
+- Integrates real CodeTreeAnalyzer instead of mock data
+- Built for daemon operation with proper lifecycle management
+- Single port (8765) for all functionality
+"""
+
+from .daemon import UnifiedMonitorDaemon
+from .server import UnifiedMonitorServer
+
+__all__ = ["UnifiedMonitorDaemon", "UnifiedMonitorServer"]

claude_mpm/services/monitor/daemon.py

@@ -0,0 +1,256 @@
+"""
+Unified Monitor Daemon for Claude MPM
+=====================================
+
+WHY: This is the main daemon process that provides a single, stable way to
+launch all monitoring functionality. It combines HTTP dashboard serving,
+Socket.IO event handling, real AST analysis, and Claude Code hook ingestion.
+
+DESIGN DECISIONS:
+- Single process replaces multiple competing server implementations
+- Daemon-ready with proper lifecycle management
+- Real AST analysis using CodeTreeAnalyzer
+- Single port (8765) for all functionality
+- Built on proven aiohttp + socketio foundation
+"""
+
+import os
+import signal
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Optional
+
+from ...core.logging_config import get_logger
+from .management.health import HealthMonitor
+from .management.lifecycle import DaemonLifecycle
+from .server import UnifiedMonitorServer
+
+
+class UnifiedMonitorDaemon:
+    """Unified daemon process for all Claude MPM monitoring functionality.
+
+    WHY: Provides a single, stable entry point for launching monitoring services.
+    Replaces the multiple competing server implementations with one cohesive daemon.
+    """
+
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 8765,
+        daemon_mode: bool = False,
+        pid_file: Optional[str] = None,
+        log_file: Optional[str] = None,
+    ):
+        """Initialize the unified monitor daemon.
+
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+            daemon_mode: Whether to run as background daemon
+            pid_file: Path to PID file for daemon mode
+            log_file: Path to log file for daemon mode
+        """
+        self.host = host
+        self.port = port
+        self.daemon_mode = daemon_mode
+        self.logger = get_logger(__name__)
+
+        # Daemon management
+        self.lifecycle = DaemonLifecycle(
+            pid_file=pid_file or self._get_default_pid_file(), log_file=log_file
+        )
+
+        # Core server
+        self.server = UnifiedMonitorServer(host=host, port=port)
+
+        # Health monitoring
+        self.health_monitor = HealthMonitor(port=port)
+
+        # State
+        self.running = False
+        self.shutdown_event = threading.Event()
+
+    def _get_default_pid_file(self) -> str:
+        """Get default PID file path."""
+        project_root = Path.cwd()
+        claude_mpm_dir = project_root / ".claude-mpm"
+        claude_mpm_dir.mkdir(exist_ok=True)
+        return str(claude_mpm_dir / "monitor-daemon.pid")
+
+    def start(self) -> bool:
+        """Start the unified monitor daemon.
+
+        Returns:
+            True if started successfully, False otherwise
+        """
+        try:
+            if self.daemon_mode:
+                return self._start_daemon()
+            return self._start_foreground()
+        except Exception as e:
+            self.logger.error(f"Failed to start unified monitor daemon: {e}")
+            return False
+
+    def _start_daemon(self) -> bool:
+        """Start as background daemon process."""
+        self.logger.info("Starting unified monitor daemon in background mode")
+
+        # Check if already running
+        if self.lifecycle.is_running():
+            existing_pid = self.lifecycle.get_pid()
+            self.logger.warning(f"Daemon already running with PID {existing_pid}")
+            return False
+
+        # Daemonize the process
+        success = self.lifecycle.daemonize()
+        if not success:
+            return False
+
+        # Start the server in daemon mode
+        return self._run_server()
+
+    def _start_foreground(self) -> bool:
+        """Start in foreground mode."""
+        self.logger.info(f"Starting unified monitor daemon on {self.host}:{self.port}")
+
+        # Setup signal handlers for graceful shutdown
+        self._setup_signal_handlers()
+
+        # Start the server
+        return self._run_server()
+
+    def _run_server(self) -> bool:
+        """Run the main server loop."""
+        try:
+            # Start health monitoring
+            self.health_monitor.start()
+
+            # Start the unified server
+            success = self.server.start()
+            if not success:
+                self.logger.error("Failed to start unified monitor server")
+                return False
+
+            self.running = True
+            self.logger.info("Unified monitor daemon started successfully")
+
+            # Keep running until shutdown
+            if self.daemon_mode:
+                # In daemon mode, run until shutdown signal
+                while self.running and not self.shutdown_event.is_set():
+                    time.sleep(1)
+            else:
+                # In foreground mode, run until interrupted
+                try:
+                    while self.running:
+                        time.sleep(1)
+                except KeyboardInterrupt:
+                    self.logger.info("Received keyboard interrupt, shutting down...")
+
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Error running unified monitor daemon: {e}")
+            return False
+        finally:
+            self._cleanup()
+
+    def stop(self) -> bool:
+        """Stop the unified monitor daemon.
+
+        Returns:
+            True if stopped successfully, False otherwise
+        """
+        try:
+            self.logger.info("Stopping unified monitor daemon")
+
+            # Signal shutdown
+            self.running = False
+            self.shutdown_event.set()
+
+            # Stop server
+            if self.server:
+                self.server.stop()
+
+            # Stop health monitoring
+            if self.health_monitor:
+                self.health_monitor.stop()
+
+            # Cleanup daemon files
+            if self.daemon_mode:
+                self.lifecycle.cleanup()
+
+            self.logger.info("Unified monitor daemon stopped")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Error stopping unified monitor daemon: {e}")
+            return False
+
+    def restart(self) -> bool:
+        """Restart the unified monitor daemon.
+
+        Returns:
+            True if restarted successfully, False otherwise
+        """
+        self.logger.info("Restarting unified monitor daemon")
+
+        # Stop first
+        if not self.stop():
+            return False
+
+        # Wait a moment
+        time.sleep(2)
+
+        # Start again
+        return self.start()
+
+    def status(self) -> dict:
+        """Get daemon status information.
+
+        Returns:
+            Dictionary with status information
+        """
+        is_running = self.lifecycle.is_running() if self.daemon_mode else self.running
+        pid = self.lifecycle.get_pid() if self.daemon_mode else os.getpid()
+
+        status = {
+            "running": is_running,
+            "pid": pid,
+            "host": self.host,
+            "port": self.port,
+            "daemon_mode": self.daemon_mode,
+            "health": (
+                self.health_monitor.get_status() if self.health_monitor else "unknown"
+            ),
+        }
+
+        if self.server:
+            status.update(self.server.get_status())
+
+        return status
+
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful shutdown."""
+
+        def signal_handler(signum, frame):
+            self.logger.info(f"Received signal {signum}, shutting down...")
+            self.stop()
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+    def _cleanup(self):
+        """Cleanup resources."""
+        try:
+            if self.server:
+                self.server.stop()
+
+            if self.health_monitor:
+                self.health_monitor.stop()
+
+        except Exception as e:
+            self.logger.error(f"Error during cleanup: {e}")