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

claude_mpm/cli/commands/run.py

@@ -15,16 +15,17 @@ DESIGN DECISIONS:
 
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 from ...constants import LogLevel
 from ...core.logger import get_logger
 from ...core.unified_paths import get_scripts_dir
-from ...services.cli.dashboard_launcher import DashboardLauncher
 from ...services.cli.session_manager import SessionManager
-from ...services.cli.socketio_manager import SocketIOManager
+
+# SocketIOManager functionality now provided by UnifiedDashboardManager
 from ...services.cli.startup_checker import StartupCheckerService
+from ...services.cli.unified_dashboard_manager import UnifiedDashboardManager
 from ..shared import BaseCommand, CommandResult
 from ..startup_logging import (
     cleanup_old_startup_logs,
@@ -67,6 +68,7 @@ def filter_claude_mpm_args(claude_args):
         "--no-native-agents",
         "--launch-method",
         "--mpm-resume",
+        "--reload-agents",  # New flag to force rebuild system agents
         # Dependency checking flags (MPM-specific)
         "--no-check-dependencies",
         "--force-check-dependencies",
@@ -324,7 +326,7 @@ class RunCommand(BaseCommand):
                         self.logger.warning(f"Session {resume_session_id} not found")
                 else:
                     self.logger.info("No recent interactive sessions found")
-                    print("ℹ️  No recent interactive sessions found to resume")
+                    print("[INFO]️  No recent interactive sessions found to resume")
             else:
                 # Resume specific session by ID
                 resume_session_id = args.mpm_resume
@@ -359,7 +361,7 @@ class RunCommand(BaseCommand):
                 loader = AgentDependencyLoader(auto_install=False)
 
                 # Check if agents have changed
-                has_changed, deployment_hash = loader.has_agents_changed()
+                _has_changed, deployment_hash = loader.has_agents_changed()
 
                 # Determine if we should check dependencies
                 should_check, check_reason = smart_checker.should_check_dependencies(
@@ -423,16 +425,16 @@ class RunCommand(BaseCommand):
                 self.logger.warning(f"Dependency check failed: {e}")
 
     def _setup_monitoring(self, args):
-        """Setup monitoring configuration using SocketIOManager."""
+        """Setup monitoring configuration using UnifiedDashboardManager."""
         monitor_mode = getattr(args, "monitor", False)
         websocket_port = 8765  # Default port
 
         if monitor_mode:
-            # Use SocketIOManager for server management
-            socketio_manager = SocketIOManager(self.logger)
+            # Use UnifiedDashboardManager for server management
+            dashboard_manager = UnifiedDashboardManager(self.logger)
 
             # Check dependencies
-            deps_ok, error_msg = socketio_manager.ensure_dependencies()
+            deps_ok, error_msg = dashboard_manager.ensure_dependencies()
             if not deps_ok:
                 self.logger.warning(
                     f"Socket.IO dependencies not available: {error_msg}, disabling monitor mode"
@@ -440,8 +442,8 @@ class RunCommand(BaseCommand):
                 monitor_mode = False
             else:
                 # Find available port and start server
-                websocket_port = socketio_manager.find_available_port(8765)
-                success, server_info = socketio_manager.start_server(
+                websocket_port = dashboard_manager.find_available_port(8765)
+                success, _server_info = dashboard_manager.start_server(
                     port=websocket_port
                 )
 
@@ -451,12 +453,12 @@ class RunCommand(BaseCommand):
                     )
                     monitor_mode = False
                 else:
-                    # Use DashboardLauncher for browser opening only
-                    dashboard_launcher = DashboardLauncher(self.logger)
-                    monitor_url = dashboard_launcher.get_dashboard_url(websocket_port)
+                    # Use UnifiedDashboardManager for browser opening only
+                    dashboard_manager = UnifiedDashboardManager(self.logger)
+                    monitor_url = dashboard_manager.get_dashboard_url(websocket_port)
 
                     # Try to open browser
-                    browser_opened = dashboard_launcher._open_browser(monitor_url)
+                    browser_opened = dashboard_manager.open_browser(monitor_url)
                     args._browser_opened_by_cli = browser_opened
 
                     if not browser_opened:
@@ -521,7 +523,7 @@ class RunCommand(BaseCommand):
             # Update session usage
             session = session_manager.load_session(resume_session_id)
             if session:
-                session.last_used = datetime.now().isoformat()
+                session.last_used = datetime.now(timezone.utc).isoformat()
                 session.use_count += 1
                 session_manager.save_session(session)
         else:
@@ -567,6 +569,112 @@ class RunCommand(BaseCommand):
             return False
 
 
+def _ensure_mcp_services_configured(logger):
+    """
+    Ensure MCP services are configured in .mcp.json on startup.
+
+    This function automatically configures the core MCP services
+    (mcp-vector-search, mcp-browser, mcp-ticketer) if they're not
+    already configured in the project's .mcp.json file.
+
+    Args:
+        logger: Logger instance for output
+    """
+    try:
+        from ...services.mcp_config_manager import MCPConfigManager
+
+        logger.debug("Checking MCP service configuration...")
+        manager = MCPConfigManager()
+
+        # Check and auto-configure missing MCP services
+        success, message = manager.ensure_mcp_services_configured()
+
+        if success:
+            if "already configured" not in message.lower():
+                logger.info(message)
+                print(f"✅ {message}")
+            else:
+                logger.debug(message)
+        else:
+            logger.warning(f"MCP auto-configuration issue: {message}")
+            # Don't fail the session, just warn
+
+    except Exception as e:
+        logger.debug(f"MCP auto-configuration skipped: {e}")
+        # Don't fail the session if auto-configuration fails
+
+
+def _handle_reload_agents(logger):
+    """
+    Handle the --reload-agents flag by deleting all local claude-mpm system agents.
+
+    This forces a fresh rebuild of system agents on the next deployment,
+    while preserving user-created agents.
+
+    Args:
+        logger: Logger instance for output
+    """
+    try:
+        logger.info("Reloading system agents - cleaning existing deployments...")
+
+        # Import the cleanup service
+        from ...services.agents.deployment.agent_deployment import (
+            AgentDeploymentService,
+        )
+        from ...services.cli.agent_cleanup_service import AgentCleanupService
+
+        # Create services
+        deployment_service = AgentDeploymentService()
+        cleanup_service = AgentCleanupService(deployment_service)
+
+        # Determine the agents directory
+        agents_dir = None  # Will auto-detect project or user directory
+
+        # Clean deployed agents (preserves user agents)
+        result = cleanup_service.clean_deployed_agents(agents_dir)
+
+        # Check if cleanup was successful based on the result structure
+        # The service returns a dict with 'removed', 'preserved', and possibly 'errors' keys
+        # If it has 'success' key, use it; otherwise infer from the result
+        success = (
+            result.get("success", True)
+            if "success" in result
+            else not result.get("errors")
+        )
+
+        if success:
+            removed_count = result.get("cleaned_count", len(result.get("removed", [])))
+            removed_agents = result.get("removed", [])
+            preserved_agents = result.get("preserved", [])
+
+            if removed_count > 0:
+                logger.info(f"✅ Successfully removed {removed_count} system agents")
+                if removed_agents:
+                    logger.debug(f"Removed agents: {', '.join(removed_agents)}")
+                print(f"🔄 Cleaned {removed_count} claude-mpm system agents")
+            else:
+                logger.info("No system agents found to clean")
+                print("[INFO]️  No system agents found - already clean")
+
+            if preserved_agents:
+                logger.info(f"Preserved {len(preserved_agents)} user-created agents")
+                print(f"✅ Preserved {len(preserved_agents)} user-created agents")
+
+            print("🚀 System agents will be rebuilt on next use")
+        else:
+            error = result.get("error", "Cleanup failed")
+            if result.get("errors"):
+                error = f"Cleanup errors: {', '.join(result['errors'])}"
+            logger.error(f"Failed to clean system agents: {error}")
+            print(f"❌ Error cleaning agents: {error}")
+
+    except Exception as e:
+        logger.error(f"Error handling --reload-agents: {e}", exc_info=True)
+        print(f"❌ Failed to reload agents: {e}")
+        # Don't fail the entire session, just log the error
+        print("⚠️  Continuing with existing agents...")
+
+
 def run_session(args):
     """
     Main entry point for run command.
@@ -623,6 +731,21 @@ def run_session_legacy(args):
     # Check for memory usage issues with .claude.json
     _check_claude_json_memory(args, logger)
 
+    # Handle --reload-agents flag if specified
+    if getattr(args, "reload_agents", False):
+        _handle_reload_agents(logger)
+
+    # Auto-configure MCP services on startup
+    _ensure_mcp_services_configured(logger)
+
+    # Trigger vector search indexing after MCP is configured
+    try:
+        from ...cli.startup_logging import start_vector_search_indexing
+
+        start_vector_search_indexing()
+    except Exception as e:
+        logger.debug(f"Failed to start vector search indexing: {e}")
+
     try:
         from ...core.claude_runner import ClaudeRunner, create_simple_context
     except ImportError:
@@ -651,7 +774,7 @@ def run_session_legacy(args):
                     logger.warning(f"Session {resume_session_id} not found")
             else:
                 logger.info("No recent interactive sessions found")
-                print("ℹ️  No recent interactive sessions found to resume")
+                print("[INFO]️  No recent interactive sessions found to resume")
         else:
             # Resume specific session by ID
             resume_session_id = args.mpm_resume
@@ -697,7 +820,7 @@ def run_session_legacy(args):
                 loader = AgentDependencyLoader(auto_install=False)
 
                 # Check if agents have changed
-                has_changed, deployment_hash = loader.has_agents_changed()
+                _has_changed, deployment_hash = loader.has_agents_changed()
 
                 # Determine if we should check dependencies
                 should_check, check_reason = smart_checker.should_check_dependencies(
@@ -824,7 +947,7 @@ def run_session_legacy(args):
             raw_claude_args = ["--resume", *raw_claude_args]
             logger.info("✅ Added --resume to claude_args")
         else:
-            logger.info("ℹ️ --resume already in claude_args")
+            logger.info("[INFO]️ --resume already in claude_args")
 
     # Filter out claude-mpm specific flags before passing to Claude CLI
     logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
@@ -855,12 +978,12 @@ def run_session_legacy(args):
 
     # Display Socket.IO server info if enabled
     if enable_websocket:
-        # Use SocketIOManager for server management
-        socketio_manager = SocketIOManager(logger)
+        # Use UnifiedDashboardManager for server management
+        dashboard_manager = UnifiedDashboardManager(logger)
 
         # Check dependencies
         print("🔧 Checking Socket.IO dependencies...")
-        deps_ok, error_msg = socketio_manager.ensure_dependencies()
+        deps_ok, error_msg = dashboard_manager.ensure_dependencies()
 
         if not deps_ok:
             print(f"❌ Failed to install Socket.IO dependencies: {error_msg}")
@@ -874,8 +997,8 @@ def run_session_legacy(args):
 
             # Find available port and start server if in monitor mode
             if monitor_mode:
-                websocket_port = socketio_manager.find_available_port(websocket_port)
-                success, server_info = socketio_manager.start_server(
+                websocket_port = dashboard_manager.find_available_port(websocket_port)
+                success, server_info = dashboard_manager.start_server(
                     port=websocket_port
                 )
 
@@ -886,18 +1009,23 @@ def run_session_legacy(args):
                             "  Note: Socket.IO monitoring using exec mode with Claude Code hooks"
                         )
 
-                    # Use DashboardLauncher for browser opening
-                    dashboard_launcher = DashboardLauncher(logger)
-                    monitor_url = dashboard_launcher.get_dashboard_url(websocket_port)
-                    browser_opened = dashboard_launcher._open_browser(monitor_url)
+                    # Use UnifiedDashboardManager for browser opening
+                    dashboard_manager = UnifiedDashboardManager(logger)
+                    monitor_url = dashboard_manager.get_dashboard_url(websocket_port)
+                    browser_opened = dashboard_manager.open_browser(monitor_url)
                     args._browser_opened_by_cli = browser_opened
 
                     if not browser_opened:
                         print(f"💡 Monitor interface available at: {monitor_url}")
                 else:
                     print("⚠️  Failed to launch Socket.IO monitor")
+                    print("Dashboard is not running. To enable monitoring:")
+                    print("  1. Use the --monitor flag: claude-mpm run --monitor")
+                    print(
+                        "  2. Or start dashboard separately: claude-mpm dashboard start"
+                    )
                     print(
-                        f"  You can manually run: python scripts/launch_socketio_dashboard.py --port {websocket_port}"
+                        f"  3. Dashboard will be available at: http://localhost:{websocket_port}"
                     )
                     args._browser_opened_by_cli = False
             else:
@@ -930,7 +1058,7 @@ def run_session_legacy(args):
         # Update session usage
         session = session_manager.load_session(resume_session_id)
         if session:
-            session.last_used = datetime.now().isoformat()
+            session.last_used = datetime.now(timezone.utc).isoformat()
             session.use_count += 1
             session_manager.save_session(session)
     else:
@@ -966,16 +1094,15 @@ def run_session_legacy(args):
         runner.run_interactive(context)
 
 
-# Legacy helper functions - now delegating to SocketIOManager
+# Legacy helper functions - now delegating to UnifiedDashboardManager
 def launch_socketio_monitor(port, logger):
     """Launch the Socket.IO monitoring dashboard (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    success, server_info = socketio_manager.start_server(port=port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    success, server_info = dashboard_manager.start_server(port=port)
 
     if success:
-        # Open browser using DashboardLauncher
-        launcher = DashboardLauncher(logger)
-        browser_opened = launcher._open_browser(server_info.url)
+        # Open browser using UnifiedDashboardManager
+        browser_opened = dashboard_manager.open_browser(server_info.url)
         return success, browser_opened
 
     return False, False
@@ -983,21 +1110,21 @@ def launch_socketio_monitor(port, logger):
 
 def _check_socketio_server_running(port, logger):
     """Check if a Socket.IO server is running on the specified port (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    return socketio_manager.is_server_running(port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    return dashboard_manager.is_server_running(port)
 
 
 def _start_standalone_socketio_server(port, logger):
     """Start a standalone Socket.IO server (legacy compatibility)."""
-    socketio_manager = SocketIOManager(logger)
-    success, _ = socketio_manager.start_server(port=port)
+    dashboard_manager = UnifiedDashboardManager(logger)
+    success, _ = dashboard_manager.start_server(port=port)
     return success
 
 
 def open_in_browser_tab(url, logger):
     """Open URL in browser, attempting to reuse existing tabs when possible."""
-    launcher = DashboardLauncher(logger)
-    return launcher._open_browser(url)
+    manager = UnifiedDashboardManager(logger)
+    return manager.open_browser(url)
 
 
 def _check_claude_json_memory(args, logger):