claude-mpm 4.2.1__py3-none-any.whl → 4.2.3__py3-none-any.whl

claude_mpm/cli/commands/monitor.py

@@ -1,31 +1,36 @@
 """
 Monitor command implementation for claude-mpm.
 
-WHY: This module provides CLI commands for managing the Socket.IO monitoring server,
-allowing users to start, stop, restart, and check status of the monitoring infrastructure.
-The monitor command now delegates to the unified dashboard service for consolidated operation.
+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).
 
 DESIGN DECISIONS:
-- Delegate to dashboard command for unified service architecture
-- Use BaseCommand for consistent CLI patterns
-- Maintain backward compatibility with existing Socket.IO server management
-- Support multiple output formats (json, yaml, table, text)
+- 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
 """
 
+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 ..shared import BaseCommand, CommandResult
-from .dashboard import DashboardCommand
 
 
 class MonitorCommand(BaseCommand):
-    """Monitor command that delegates to the unified dashboard service."""
+    """Monitor command for managing the independent monitoring server."""
 
     def __init__(self):
         super().__init__("monitor")
-        # Create dashboard command instance for delegation
-        self.dashboard_command = DashboardCommand()
+        self.port_manager = PortManager()
+        self.server = None
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -38,25 +43,25 @@ class MonitorCommand(BaseCommand):
         return None
 
     def run(self, args) -> CommandResult:
-        """Execute the monitor command by delegating to dashboard service."""
+        """Execute the monitor command using independent MonitorServer."""
         try:
-            self.logger.info("Monitor command delegating to unified dashboard service")
+            self.logger.info("Monitor command using independent monitoring server")
 
             # Handle default case (no subcommand) - default to status
             if not hasattr(args, "monitor_command") or not args.monitor_command:
-                return self._status_dashboard(args)
+                return self._status_monitor(args)
 
-            # Map monitor commands to dashboard commands
+            # Route to specific monitor commands
             if args.monitor_command == MonitorCommands.START.value:
-                return self._start_dashboard(args)
+                return self._start_monitor(args)
             if args.monitor_command == MonitorCommands.STOP.value:
-                return self._stop_dashboard(args)
+                return self._stop_monitor(args)
             if args.monitor_command == MonitorCommands.RESTART.value:
-                return self._restart_dashboard(args)
+                return self._restart_monitor(args)
             if args.monitor_command == MonitorCommands.STATUS.value:
-                return self._status_dashboard(args)
+                return self._status_monitor(args)
             if args.monitor_command == MonitorCommands.PORT.value:
-                return self._start_dashboard_on_port(args)
+                return self._start_monitor_on_port(args)
 
             return CommandResult.error_result(
                 f"Unknown monitor command: {args.monitor_command}"
@@ -66,66 +71,230 @@ class MonitorCommand(BaseCommand):
             self.logger.error(f"Error executing monitor command: {e}", exc_info=True)
             return CommandResult.error_result(f"Error executing monitor command: {e}")
 
-    def _start_dashboard(self, args) -> CommandResult:
-        """Start the dashboard service (unified HTTP + Socket.IO)."""
-        self.logger.info("Starting unified dashboard service (HTTP + Socket.IO)")
-        # Set default port to 8765 for unified service and background mode
-        if not hasattr(args, "port") or args.port is None:
-            args.port = 8765
-        # Monitor command defaults to background mode for better UX
-        if not hasattr(args, "background"):
-            args.background = True
+    def _start_monitor(self, args) -> CommandResult:
+        """Start the monitor server."""
+        port = getattr(args, "port", 8765)  # Default to 8765 for monitor
+        host = getattr(args, "host", "localhost")
+        background = getattr(
+            args, "background", True
+        )  # Default to background for monitor
+
+        self.logger.info(
+            f"Starting monitor server on {host}:{port} (background: {background})"
+        )
 
-        return self.dashboard_command._start_dashboard(args)
+        # Check if monitor is already running
+        if self._is_monitor_running(port):
+            return CommandResult.success_result(
+                f"Monitor server already running on {host}:{port}",
+                data={"url": f"http://{host}:{port}", "port": port},
+            )
 
-    def _stop_dashboard(self, args) -> CommandResult:
-        """Stop the dashboard service."""
-        self.logger.info("Stopping unified dashboard service")
-        # Use default port if not specified
-        if not hasattr(args, "port") or args.port is None:
-            args.port = 8765
+        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):
+            return CommandResult.success_result(
+                f"No monitor server running on port {port}"
+            )
 
-        return self.dashboard_command._stop_dashboard(args)
+        # 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)"
+                    )
+
+            return CommandResult.success_result(
+                f"No monitor server found on port {port}"
+            )
 
-    def _restart_dashboard(self, args) -> CommandResult:
-        """Restart the dashboard service."""
-        self.logger.info("Restarting unified dashboard service")
+        except Exception as e:
+            return CommandResult.error_result(
+                f"Error checking monitor server status: {e}"
+            )
+
+    def _restart_monitor(self, args) -> CommandResult:
+        """Restart the monitor server."""
+        self.logger.info("Restarting monitor server")
 
         # Stop first
-        stop_result = self._stop_dashboard(args)
+        stop_result = self._stop_monitor(args)
         if not stop_result.success:
-            self.logger.warning("Failed to stop service for restart, proceeding anyway")
+            self.logger.warning(
+                "Failed to stop monitor server for restart, proceeding anyway"
+            )
 
         # Wait a moment
-        import time
-
-        time.sleep(1)
+        time.sleep(2)
 
         # Start again
-        return self._start_dashboard(args)
+        return self._start_monitor(args)
+
+    def _status_monitor(self, args) -> CommandResult:
+        """Get monitor server status."""
+        port = getattr(args, "port", 8766)
+        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()
+
+        # Format output message
+        if monitor_running:
+            message = f"Monitor server is running at {status_data['url']}"
+        else:
+            message = "Monitor server 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}")
 
-    def _status_dashboard(self, args) -> CommandResult:
-        """Get dashboard service status."""
-        return self.dashboard_command._status_dashboard(args)
-
-    def _start_dashboard_on_port(self, args) -> CommandResult:
-        """Start dashboard service on specific port."""
-        self.logger.info(
-            f"Starting dashboard service on port {getattr(args, 'port', 8765)}"
-        )
         # Ensure background mode for port-specific starts
         if not hasattr(args, "background"):
             args.background = True
 
-        return self.dashboard_command._start_dashboard(args)
+        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 now delegates to the unified dashboard service for consolidated operation.
-    Both dashboard and monitor commands now use the same underlying service on port 8765.
+    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.
     """
     command = MonitorCommand()
     error = command.validate_args(args)
@@ -148,9 +317,3 @@ def manage_monitor(args):
     if result.message:
         print(f"Error: {result.message}")
     return 1
-
-
-# All legacy functions have been removed.
-# The monitor command now delegates to the unified dashboard service.
-# This consolidation provides a single service that handles both HTTP (port 8765)
-# and Socket.IO (also on port 8765) rather than separate services on different ports.

claude_mpm/core/config.py

@@ -527,11 +527,36 @@ class Config:
                     },
                 },
             },
+            # Monitor server configuration (decoupled from dashboard)
+            "monitor_server": {
+                "host": "localhost",
+                "port": 8765,  # Default monitor port (shared with dashboard)
+                "enable_health_monitoring": True,
+                "auto_start": False,  # Don't auto-start with dashboard by default
+                "event_buffer_size": 2000,  # Larger buffer for monitor server
+                "client_timeout": 60,  # Timeout for inactive clients
+            },
+            # Dashboard server configuration (connects to monitor)
+            "dashboard_server": {
+                "host": "localhost",
+                "port": 8765,  # Dashboard UI port
+                "monitor_host": "localhost",  # Monitor server host to connect to
+                "monitor_port": 8765,  # Monitor server port to connect to
+                "auto_connect_monitor": True,  # Automatically connect to monitor
+                "monitor_reconnect": True,  # Auto-reconnect to monitor if disconnected
+                "fallback_standalone": True,  # Run in standalone mode if monitor unavailable
+            },
             # Agent deployment configuration
             "agent_deployment": {
                 "excluded_agents": [],  # List of agent IDs to exclude from deployment
                 "exclude_dependencies": False,  # Whether to exclude agent dependencies too
                 "case_sensitive": False,  # Whether agent name matching is case-sensitive
+                "filter_non_mpm_agents": True,  # Filter out non-MPM agents by default
+                "mpm_author_patterns": [
+                    "claude mpm",
+                    "claude-mpm",
+                    "anthropic",
+                ],  # Patterns for MPM agents
             },
             # Instruction reinforcement system configuration
             "instruction_reinforcement": {

claude_mpm/core/unified_agent_registry.py

@@ -420,8 +420,8 @@ class UnifiedAgentRegistry:
             for _i, line in enumerate(lines[1:], 1):
                 if line.strip() == "---":
                     break
-                if line.startswith("description:"):
-                    return line.split(":", 1)[1].strip().strip("\"'")
+                if line.strip().startswith("description:"):
+                    return line.strip().split(":", 1)[1].strip().strip("\"'")
 
         # Look for first paragraph
         for line in lines:

claude_mpm/dashboard/static/css/code-tree.css

@@ -459,7 +459,7 @@
     border-radius: 8px;
     padding: 20px;
     position: relative;
-    overflow: auto;
+    overflow: hidden;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
     border-left: 1px solid #e2e8f0;
 }
@@ -828,6 +828,8 @@
 .code-node text {
     font: 12px sans-serif;
     pointer-events: none;
+    /* Smooth transitions for zoom-based text scaling */
+    transition: font-size 0.2s ease;
 }
 
 .code-node.module circle {
@@ -974,6 +976,8 @@
     text-anchor: middle;
     dominant-baseline: central;
     font-weight: 500;
+    /* Smooth transitions for zoom-based scaling */
+    transition: font-size 0.2s ease;
 }
 
 .code-node.directory:hover .item-count-badge {
@@ -1405,4 +1409,219 @@
         transform: translateX(0);
         opacity: 1;
     }
+}
+
+/* Back Button for Focused Directory View */
+.tree-control-btn.back-btn {
+    background: #3182ce !important;
+    color: white !important;
+    border: 1px solid #2c5aa0 !important;
+    font-weight: 600;
+    margin-right: 10px;
+}
+
+.tree-control-btn.back-btn:hover {
+    background: #2c5aa0 !important;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(49, 130, 206, 0.3);
+}
+
+/* Focused Directory View Styling */
+.code-tree-container.focused {
+    border: 2px solid #3182ce;
+    border-radius: 8px;
+    background: linear-gradient(135deg, #f7fafc 0%, #edf2f7 100%);
+}
+
+.code-tree-container.focused .tree-controls-toolbar {
+    background: #e6fffa;
+    border-bottom: 1px solid #81e6d9;
+}
+
+/* Corner Controls Styling */
+.tree-corner-controls {
+    position: absolute;
+    z-index: 1000;
+    background: rgba(255, 255, 255, 0.95);
+    border: 1px solid #e2e8f0;
+    border-radius: 6px;
+    padding: 8px 12px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    backdrop-filter: blur(4px);
+    font-size: 12px;
+}
+
+.tree-corner-controls.top-left {
+    top: 10px;
+    left: 10px;
+}
+
+.tree-corner-controls.top-right {
+    top: 10px;
+    right: 10px;
+}
+
+.tree-corner-controls.bottom-left {
+    bottom: 10px;
+    left: 10px;
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 4px;
+}
+
+.tree-corner-controls.bottom-right {
+    bottom: 10px;
+    right: 10px;
+}
+
+.tree-corner-controls .control-group {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.tree-corner-controls .control-label {
+    font-weight: 600;
+    color: #4a5568;
+    white-space: nowrap;
+}
+
+.tree-corner-controls .checkbox-group {
+    display: flex;
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.tree-corner-controls .checkbox-label {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    font-size: 11px;
+    color: #4a5568;
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+.tree-corner-controls .checkbox-label input[type="checkbox"] {
+    margin: 0;
+    transform: scale(0.9);
+}
+
+.tree-corner-controls .select-compact,
+.tree-corner-controls .search-compact,
+.tree-corner-controls .input-compact {
+    font-size: 11px;
+    padding: 4px 8px;
+    border: 1px solid #d1d5db;
+    border-radius: 4px;
+    background: white;
+}
+
+.tree-corner-controls .search-compact {
+    width: 120px;
+}
+
+.tree-corner-controls .input-compact {
+    width: 140px;
+}
+
+.tree-corner-controls .stats-display {
+    font-size: 11px;
+    color: #6b7280;
+    font-weight: 500;
+    margin-bottom: 4px;
+}
+
+.tree-corner-controls .status-display {
+    font-size: 10px;
+    color: #4b5563;
+    font-style: italic;
+    opacity: 0.8;
+    max-width: 200px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.tree-corner-controls .status-display .breadcrumb-ticker {
+    display: block;
+}
+
+.tree-corner-controls .status-display #breadcrumb-content {
+    display: inline-block;
+    animation: none; /* Disable any existing animations for corner display */
+}
+
+/* Hide corner controls when in focused mode to avoid clutter */
+.code-tree-container.focused .tree-corner-controls {
+    opacity: 0.7;
+}
+
+.code-tree-container.focused .tree-corner-controls:hover {
+    opacity: 1;
+}
+
+/* Force horizontal text for specific nodes */
+.node-label.horizontal-text {
+    writing-mode: horizontal-tb !important;
+    text-orientation: mixed !important;
+    transform: rotate(0deg) !important;
+}
+
+/* Zoom controls styling */
+.zoom-level-display {
+    display: inline-block;
+    padding: 2px 6px;
+    background: rgba(0, 0, 0, 0.05);
+    border-radius: 3px;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    font-size: 11px !important;
+    color: #718096 !important;
+    margin-left: 8px !important;
+    vertical-align: middle;
+    min-width: 35px;
+    text-align: center;
+}
+
+/* Enhanced tree control buttons for zoom */
+.tree-control-btn {
+    background: #f8f9fa;
+    border: 1px solid #e2e8f0;
+    border-radius: 4px;
+    padding: 6px 8px;
+    margin: 0 2px;
+    cursor: pointer;
+    font-size: 12px;
+    color: #4a5568;
+    transition: all 0.2s;
+    display: inline-block;
+    vertical-align: middle;
+}
+
+.tree-control-btn:hover {
+    background: #e2e8f0;
+    border-color: #cbd5e0;
+    color: #2d3748;
+}
+
+.tree-control-btn:active {
+    background: #cbd5e0;
+    transform: translateY(1px);
+}
+
+/* Zoom-specific button styling */
+.tree-control-btn[title*="Zoom"] {
+    font-family: system-ui, -apple-system, sans-serif;
+    font-weight: 500;
+}
+
+/* Pan cursor when dragging */
+.code-tree-container svg {
+    cursor: grab;
+}
+
+.code-tree-container svg:active {
+    cursor: grabbing;
 }