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

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.7
+4.2.11

claude_mpm/cli/commands/dashboard.py

@@ -5,21 +5,20 @@ WHY: This module provides CLI commands for managing the web dashboard interface,
 allowing users to start, stop, check status, and open the dashboard in a browser.
 
 DESIGN DECISIONS:
-- Use DashboardLauncher service for consistent dashboard management
+- Use UnifiedMonitorDaemon for integrated dashboard and monitoring
 - Support both foreground and background operation modes
-- Integrate with SocketIO server for real-time event streaming
+- Integrate with EventBus for real-time event streaming
 - Provide browser auto-opening functionality
 """
 
 import signal
 import sys
-import time
 from typing import Optional
 
 from ...constants import DashboardCommands
-from ...services.cli.dashboard_launcher import DashboardLauncher
+from ...services.cli.unified_dashboard_manager import UnifiedDashboardManager
+from ...services.monitor.daemon import UnifiedMonitorDaemon
 from ...services.port_manager import PortManager
-from ...services.socketio.dashboard_server import DashboardServer
 from ..shared import BaseCommand, CommandResult
 
 
@@ -28,7 +27,7 @@ class DashboardCommand(BaseCommand):
 
     def __init__(self):
         super().__init__("dashboard")
-        self.dashboard_launcher = DashboardLauncher(self.logger)
+        self.dashboard_manager = UnifiedDashboardManager(self.logger)
         self.port_manager = PortManager()
         self.server = None
 
@@ -79,20 +78,20 @@ class DashboardCommand(BaseCommand):
         )
 
         # Check if dashboard is already running
-        if self.dashboard_launcher.is_dashboard_running(port):
-            dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+        if self.dashboard_manager.is_dashboard_running(port):
+            dashboard_url = self.dashboard_manager.get_dashboard_url(port)
             return CommandResult.success_result(
                 f"Dashboard already running at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},
             )
 
         if background:
-            # Use the dashboard launcher for background mode
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            # Use the unified dashboard manager for background mode
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started at {dashboard_url}",
                     data={
@@ -102,102 +101,45 @@ class DashboardCommand(BaseCommand):
                     },
                 )
             return CommandResult.error_result("Failed to start dashboard in background")
-        
-        # Run in foreground mode
-        server_started = False
-        
-        # Try stable server first (or if explicitly requested)
-        if use_stable:
-            try:
-                self.logger.info("Starting stable dashboard server (no monitor dependency)...")
-                print(f"Starting stable dashboard server on {host}:{port}...")
-                print("Press Ctrl+C to stop the server")
-                print("\n✅ Using stable server - works without monitor service\n")
-                
-                # Create and run the stable server
-                from ...services.dashboard.stable_server import StableDashboardServer
-                stable_server = StableDashboardServer(host=host, port=port, debug=debug)
-                
-                # Set up signal handlers for graceful shutdown
-                def signal_handler(signum, frame):
-                    print("\nShutting down dashboard server...")
-                    sys.exit(0)
-                
-                signal.signal(signal.SIGINT, signal_handler)
-                signal.signal(signal.SIGTERM, signal_handler)
-                
-                # Run the server (blocking)
-                result = stable_server.run()
-                if result:
-                    # Server ran successfully and stopped normally
-                    server_started = True
-                    return CommandResult.success_result("Dashboard server stopped")
-                else:
-                    # Server failed to start (e.g., couldn't find templates)
-                    server_started = False
-                    self.logger.warning("Stable server failed to start, trying advanced server...")
-                    
-            except KeyboardInterrupt:
-                print("\nDashboard server stopped by user")
-                return CommandResult.success_result("Dashboard server stopped")
-            except Exception as e:
-                self.logger.warning(f"Stable server failed: {e}")
-                if not getattr(args, "no_fallback", False):
-                    print(f"\n⚠️ Stable server failed: {e}")
-                    print("Attempting fallback to advanced server...")
-                else:
-                    return CommandResult.error_result(f"Failed to start stable dashboard: {e}")
-        
-        # Fallback to advanced DashboardServer if stable server failed or not requested
-        if not server_started and not getattr(args, "stable_only", False):
-            try:
-                self.logger.info("Attempting to start advanced dashboard server with monitor...")
-                print(f"\nStarting advanced dashboard server on {host}:{port}...")
-                print("Note: This requires monitor service on port 8766")
-                print("Press Ctrl+C to stop the server")
-
-                # Create and start the Dashboard server (with monitor client)
-                self.server = DashboardServer(host=host, port=port)
-
-                # Set up signal handlers for graceful shutdown
-                def signal_handler(signum, frame):
-                    print("\nShutting down dashboard server...")
-                    if self.server:
-                        self.server.stop_sync()
-                    sys.exit(0)
-
-                signal.signal(signal.SIGINT, signal_handler)
-                signal.signal(signal.SIGTERM, signal_handler)
-
-                # Start the server (this starts in background thread)
-                self.server.start_sync()
-
-                # Keep the main thread alive while server is running
-                # The server runs in a background thread, so we need to block here
-                try:
-                    while self.server.is_running():
-                        time.sleep(1)
-                except KeyboardInterrupt:
-                    # Ctrl+C pressed, stop the server
-                    pass
-
-                # Server has stopped or user interrupted
-                if self.server:
-                    self.server.stop_sync()
-
-                return CommandResult.success_result("Dashboard server stopped")
-
-            except KeyboardInterrupt:
-                print("\nDashboard server stopped by user")
-                return CommandResult.success_result("Dashboard server stopped")
-            except Exception as e:
-                # If both servers fail, provide helpful error message
-                error_msg = f"Failed to start dashboard: {e}\n\n"
-                error_msg += "💡 Troubleshooting tips:\n"
-                error_msg += f"  - Check if port {port} is already in use\n"
-                error_msg += "  - Try running with --stable flag for standalone mode\n"
-                error_msg += "  - Use --debug flag for more details\n"
-                return CommandResult.error_result(error_msg)
+
+        # Run in foreground mode using unified monitor daemon
+        try:
+            self.logger.info("Starting unified monitor daemon with dashboard...")
+            print(f"Starting unified dashboard and monitor on {host}:{port}...")
+            print("Press Ctrl+C to stop the server")
+            print(
+                "\n✅ Using unified daemon - includes dashboard, monitoring, and EventBus integration\n"
+            )
+
+            # Create and start the unified monitor daemon
+            daemon = UnifiedMonitorDaemon(host=host, port=port, daemon_mode=False)
+
+            # Set up signal handlers for graceful shutdown
+            def signal_handler(signum, frame):
+                print("\nShutting down unified monitor daemon...")
+                daemon.stop()
+                sys.exit(0)
+
+            signal.signal(signal.SIGINT, signal_handler)
+            signal.signal(signal.SIGTERM, signal_handler)
+
+            # Start the daemon (blocking in foreground mode)
+            success = daemon.start()
+            if success:
+                return CommandResult.success_result("Unified monitor daemon stopped")
+            return CommandResult.error_result("Failed to start unified monitor daemon")
+
+        except KeyboardInterrupt:
+            print("\nUnified monitor daemon stopped by user")
+            return CommandResult.success_result("Unified monitor daemon stopped")
+        except Exception as e:
+            self.logger.error(f"Unified monitor daemon failed: {e}")
+            error_msg = f"Failed to start unified monitor daemon: {e}\n\n"
+            error_msg += "💡 Troubleshooting tips:\n"
+            error_msg += f"  - Check if port {port} is already in use\n"
+            error_msg += "  - Use --debug flag for more details\n"
+            error_msg += "  - Check that all dependencies are installed\n"
+            return CommandResult.error_result(error_msg)
 
     def _stop_dashboard(self, args) -> CommandResult:
         """Stop the dashboard server."""
@@ -205,10 +147,10 @@ class DashboardCommand(BaseCommand):
 
         self.logger.info(f"Stopping dashboard on port {port}")
 
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             return CommandResult.success_result(f"No dashboard running on port {port}")
 
-        if self.dashboard_launcher.stop_dashboard(port):
+        if self.dashboard_manager.stop_dashboard(port):
             return CommandResult.success_result(f"Dashboard stopped on port {port}")
 
         return CommandResult.error_result(f"Failed to stop dashboard on port {port}")
@@ -220,7 +162,7 @@ class DashboardCommand(BaseCommand):
 
         # Check default port first
         default_port = 8765
-        dashboard_running = self.dashboard_launcher.is_dashboard_running(default_port)
+        dashboard_running = self.dashboard_manager.is_dashboard_running(default_port)
 
         status_data = {
             "running": dashboard_running,
@@ -228,17 +170,17 @@ class DashboardCommand(BaseCommand):
         }
 
         if dashboard_running:
-            status_data["url"] = self.dashboard_launcher.get_dashboard_url(default_port)
+            status_data["url"] = self.dashboard_manager.get_dashboard_url(default_port)
 
         # Check all ports if requested
         if show_ports:
             port_status = {}
             for port in range(8765, 8786):
-                is_running = self.dashboard_launcher.is_dashboard_running(port)
+                is_running = self.dashboard_manager.is_dashboard_running(port)
                 port_status[port] = {
                     "running": is_running,
                     "url": (
-                        self.dashboard_launcher.get_dashboard_url(port)
+                        self.dashboard_manager.get_dashboard_url(port)
                         if is_running
                         else None
                     ),
@@ -271,14 +213,14 @@ class DashboardCommand(BaseCommand):
         port = getattr(args, "port", 8765)
 
         # Check if dashboard is running
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             self.logger.info("Dashboard not running, starting it first...")
             # Start dashboard in background
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started and opened at {dashboard_url}",
                     data={
@@ -289,8 +231,8 @@ class DashboardCommand(BaseCommand):
                 )
             return CommandResult.error_result("Failed to start and open dashboard")
         # Dashboard already running, just open browser
-        dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
-        if self.dashboard_launcher._open_browser(dashboard_url):
+        dashboard_url = self.dashboard_manager.get_dashboard_url(port)
+        if self.dashboard_manager.open_browser(dashboard_url):
             return CommandResult.success_result(
                 f"Opened dashboard at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},

claude_mpm/cli/commands/monitor.py

@@ -1,36 +1,31 @@
 """
 Monitor command implementation for claude-mpm.
 
-WHY: This module provides CLI commands for managing the lightweight monitoring server,
-allowing users to start, stop, restart, and check status of the independent monitoring service.
-The monitor service runs as a stable background service on port 8766 (configurable).
+WHY: This module provides CLI commands for managing the unified monitoring daemon,
+providing a single stable way to launch all monitoring functionality including
+HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hook ingestion.
 
 DESIGN DECISIONS:
-- Use independent MonitorServer for decoupled architecture
-- Monitor runs on port 8766, Dashboard runs on port 8765
-- Support background mode by default for stable always-on operation
-- Provide status checking and port configuration
-- Maintain minimal dependencies and resource usage
+- Use UnifiedMonitorDaemon for single stable monitoring service
+- Single port (8765) for all functionality
+- Support both foreground and daemon modes
+- Real AST analysis using CodeTreeAnalyzer
+- Integrated dashboard and Socket.IO server
 """
 
-import signal
-import sys
-import time
 from typing import Optional
 
 from ...constants import MonitorCommands
-from ...services.port_manager import PortManager
-from ...services.socketio.monitor_server import MonitorServer
+from ...services.monitor.daemon import UnifiedMonitorDaemon
 from ..shared import BaseCommand, CommandResult
 
 
 class MonitorCommand(BaseCommand):
-    """Monitor command for managing the independent monitoring server."""
+    """Monitor command for managing the unified monitoring daemon."""
 
     def __init__(self):
         super().__init__("monitor")
-        self.port_manager = PortManager()
-        self.server = None
+        self.daemon = None
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -43,9 +38,9 @@ class MonitorCommand(BaseCommand):
         return None
 
     def run(self, args) -> CommandResult:
-        """Execute the monitor command using independent MonitorServer."""
+        """Execute the monitor command using unified monitoring daemon."""
         try:
-            self.logger.info("Monitor command using independent monitoring server")
+            self.logger.info("Monitor command using unified monitoring daemon")
 
             # Handle default case (no subcommand) - default to status
             if not hasattr(args, "monitor_command") or not args.monitor_command:
@@ -60,8 +55,6 @@ class MonitorCommand(BaseCommand):
                 return self._restart_monitor(args)
             if args.monitor_command == MonitorCommands.STATUS.value:
                 return self._status_monitor(args)
-            if args.monitor_command == MonitorCommands.PORT.value:
-                return self._start_monitor_on_port(args)
 
             return CommandResult.error_result(
                 f"Unknown monitor command: {args.monitor_command}"
@@ -72,229 +65,95 @@ class MonitorCommand(BaseCommand):
             return CommandResult.error_result(f"Error executing monitor command: {e}")
 
     def _start_monitor(self, args) -> CommandResult:
-        """Start the monitor server."""
-        port = getattr(args, "port", 8765)  # Default to 8765 for monitor
+        """Start the unified monitor daemon."""
+        port = getattr(args, "port", None)
+        if port is None:
+            port = 8765  # Default to 8765 for unified monitor
         host = getattr(args, "host", "localhost")
-        background = getattr(
-            args, "background", True
-        )  # Default to background for monitor
+        daemon_mode = getattr(args, "daemon", False)  # Default to foreground
 
         self.logger.info(
-            f"Starting monitor server on {host}:{port} (background: {background})"
+            f"Starting unified monitor daemon on {host}:{port} (daemon: {daemon_mode})"
         )
 
-        # Check if monitor is already running
-        if self._is_monitor_running(port):
+        # Create unified monitor daemon
+        self.daemon = UnifiedMonitorDaemon(
+            host=host, port=port, daemon_mode=daemon_mode
+        )
+
+        # Check if already running
+        if self.daemon.lifecycle.is_running():
+            existing_pid = self.daemon.lifecycle.get_pid()
             return CommandResult.success_result(
-                f"Monitor server already running on {host}:{port}",
-                data={"url": f"http://{host}:{port}", "port": port},
+                f"Unified monitor daemon already running with PID {existing_pid}",
+                data={
+                    "url": f"http://{host}:{port}",
+                    "port": port,
+                    "pid": existing_pid,
+                },
             )
 
-        if background:
-            # Start monitor server in background
-            try:
-                self.server = MonitorServer(host=host, port=port)
-                if self.server.start_sync():
-                    return CommandResult.success_result(
-                        f"Monitor server started on {host}:{port}",
-                        data={"url": f"http://{host}:{port}", "port": port},
-                    )
-                return CommandResult.error_result("Failed to start monitor server")
-            except Exception as e:
-                return CommandResult.error_result(
-                    f"Failed to start monitor server: {e}"
-                )
-        else:
-            # Run monitor in foreground mode
-            try:
-                print(f"Starting monitor server on {host}:{port}...")
-                print("Press Ctrl+C to stop the server")
-
-                self.server = MonitorServer(host=host, port=port)
-
-                # Set up signal handlers for graceful shutdown
-                def signal_handler(signum, frame):
-                    print("\nShutting down monitor server...")
-                    if self.server:
-                        self.server.stop_sync()
-                    sys.exit(0)
-
-                signal.signal(signal.SIGINT, signal_handler)
-                signal.signal(signal.SIGTERM, signal_handler)
-
-                # Start the server
-                if not self.server.start_sync():
-                    return CommandResult.error_result("Failed to start monitor server")
-
-                # Keep the main thread alive while server is running
-                try:
-                    while self.server.is_running():
-                        time.sleep(1)
-                except KeyboardInterrupt:
-                    pass
-
-                # Stop the server
-                if self.server:
-                    self.server.stop_sync()
-
-                return CommandResult.success_result("Monitor server stopped")
-
-            except KeyboardInterrupt:
-                print("\nMonitor server stopped by user")
-                return CommandResult.success_result("Monitor server stopped")
-            except Exception as e:
-                return CommandResult.error_result(
-                    f"Failed to start monitor server: {e}"
-                )
-
-    def _stop_monitor(self, args) -> CommandResult:
-        """Stop the monitor server."""
-        port = getattr(args, "port", 8766)
-
-        self.logger.info(f"Stopping monitor server on port {port}")
-
-        if not self._is_monitor_running(port):
+        # Start the daemon
+        if self.daemon.start():
             return CommandResult.success_result(
-                f"No monitor server running on port {port}"
+                f"Unified monitor daemon started on {host}:{port}",
+                data={"url": f"http://{host}:{port}", "port": port},
             )
+        return CommandResult.error_result("Failed to start unified monitor daemon")
 
-        # Try to stop our server instance if we have one
-        if self.server and self.server.is_running():
-            try:
-                self.server.stop_sync()
-                return CommandResult.success_result(
-                    f"Monitor server stopped on port {port}"
-                )
-            except Exception as e:
-                return CommandResult.error_result(f"Error stopping monitor server: {e}")
-
-        # If we don't have a server instance, try port manager cleanup
-        try:
-            self.port_manager.cleanup_dead_instances()
-            active_instances = self.port_manager.list_active_instances()
-
-            # Look for instances on the target port
-            for instance in active_instances:
-                if (
-                    instance.get("port") == port
-                    and instance.get("service_type") == "monitor"
-                ):
-                    # Found an instance, but we can't stop it directly
-                    # This would need to be implemented with a proper process manager
-                    return CommandResult.error_result(
-                        f"Monitor server found on port {port} but cannot be stopped "
-                        "(no direct control - you may need to kill the process manually)"
-                    )
+    def _stop_monitor(self, args) -> CommandResult:
+        """Stop the unified monitor daemon."""
+        self.logger.info("Stopping unified monitor daemon")
 
-            return CommandResult.success_result(
-                f"No monitor server found on port {port}"
-            )
+        # Create daemon instance to check status and stop
+        daemon = UnifiedMonitorDaemon()
 
-        except Exception as e:
-            return CommandResult.error_result(
-                f"Error checking monitor server status: {e}"
-            )
+        if not daemon.lifecycle.is_running():
+            return CommandResult.success_result("No unified monitor daemon running")
+
+        # Stop the daemon
+        if daemon.stop():
+            return CommandResult.success_result("Unified monitor daemon stopped")
+        return CommandResult.error_result("Failed to stop unified monitor daemon")
 
     def _restart_monitor(self, args) -> CommandResult:
-        """Restart the monitor server."""
-        self.logger.info("Restarting monitor server")
-
-        # Stop first
-        stop_result = self._stop_monitor(args)
-        if not stop_result.success:
-            self.logger.warning(
-                "Failed to stop monitor server for restart, proceeding anyway"
-            )
+        """Restart the unified monitor daemon."""
+        self.logger.info("Restarting unified monitor daemon")
 
-        # Wait a moment
-        time.sleep(2)
+        # Create daemon instance
+        daemon = UnifiedMonitorDaemon()
 
-        # Start again
-        return self._start_monitor(args)
+        # Restart the daemon
+        if daemon.restart():
+            return CommandResult.success_result("Unified monitor daemon restarted")
+        return CommandResult.error_result("Failed to restart unified monitor daemon")
 
     def _status_monitor(self, args) -> CommandResult:
-        """Get monitor server status."""
-        port = getattr(args, "port", 8766)
+        """Get unified monitor daemon status."""
         verbose = getattr(args, "verbose", False)
-        show_ports = getattr(args, "show_ports", False)
-
-        # Check if monitor is running
-        monitor_running = self._is_monitor_running(port)
-
-        status_data = {
-            "running": monitor_running,
-            "default_port": port,
-            "service_type": "monitor",
-        }
-
-        if monitor_running:
-            status_data["url"] = f"http://localhost:{port}"
-
-        # Check all ports if requested
-        if show_ports:
-            port_status = {}
-            for check_port in range(8766, 8776):  # Monitor port range
-                is_running = self._is_monitor_running(check_port)
-                port_status[check_port] = {
-                    "running": is_running,
-                    "url": f"http://localhost:{check_port}" if is_running else None,
-                }
-            status_data["ports"] = port_status
-
-        # Get active instances from port manager
-        self.port_manager.cleanup_dead_instances()
-        active_instances = self.port_manager.list_active_instances()
-        if active_instances:
-            monitor_instances = [
-                inst
-                for inst in active_instances
-                if inst.get("service_type") == "monitor"
-            ]
-            if monitor_instances:
-                status_data["active_instances"] = monitor_instances
-
-        if verbose and self.server:
-            status_data["server_stats"] = self.server.get_stats()
+
+        # Create daemon instance to check status
+        daemon = UnifiedMonitorDaemon()
+        status_data = daemon.status()
 
         # Format output message
-        if monitor_running:
-            message = f"Monitor server is running at {status_data['url']}"
+        if status_data["running"]:
+            message = f"Unified monitor daemon is running at http://{status_data['host']}:{status_data['port']}"
+            if status_data.get("pid"):
+                message += f" (PID: {status_data['pid']})"
         else:
-            message = "Monitor server is not running"
+            message = "Unified monitor daemon is not running"
 
         return CommandResult.success_result(message, data=status_data)
 
-    def _start_monitor_on_port(self, args) -> CommandResult:
-        """Start monitor server on specific port."""
-        port = getattr(args, "port", 8766)
-        self.logger.info(f"Starting monitor server on port {port}")
-
-        # Ensure background mode for port-specific starts
-        if not hasattr(args, "background"):
-            args.background = True
-
-        return self._start_monitor(args)
-
-    def _is_monitor_running(self, port: int) -> bool:
-        """Check if monitor server is running on given port."""
-        import socket
-
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.settimeout(1)
-                result = s.connect_ex(("localhost", port))
-                return result == 0
-        except Exception:
-            return False
-
 
 def manage_monitor(args):
     """
     Main entry point for monitor command.
 
-    The monitor command manages an independent lightweight monitoring server on port 8766.
-    This server runs separately from the dashboard (port 8765) and provides stable
-    event collection and relay services.
+    The monitor command manages the unified monitoring daemon that provides
+    a single stable way to launch all monitoring functionality including
+    HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hooks.
     """
     command = MonitorCommand()
     error = command.validate_args(args)