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

claude_mpm/cli/commands/run.py

@@ -15,23 +15,24 @@ 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,
     log_startup_status,
     setup_startup_logging,
 )
-from ..utils import get_user_input, list_agent_versions_at_startup
+from ..utils import get_user_input
 
 
 def filter_claude_mpm_args(claude_args):
@@ -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",
@@ -165,10 +167,10 @@ def create_session_context(session_id, session_manager):
 # Session Resumption
 
 You are resuming session {session_id[:8]}... which was:
-- Created: {session_data.get('created_at', 'unknown')}
-- Last used: {session_data.get('last_used', 'unknown')}
-- Context: {session_data.get('context', 'default')}
-- Use count: {session_data.get('use_count', 0)}
+- Created: {session_data.get("created_at", "unknown")}
+- Last used: {session_data.get("last_used", "unknown")}
+- Context: {session_data.get("context", "default")}
+- Use count: {session_data.get("use_count", 0)}
 """
 
     # Add information about agents previously run in this session
@@ -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,77 @@ class RunCommand(BaseCommand):
             return False
 
 
+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.
@@ -595,8 +668,10 @@ def run_session_legacy(args):
     Args:
         args: Parsed command line arguments
     """
-    # Set up startup logging to file early in the process
-    setup_startup_logging(Path.cwd())
+    # Only setup startup logging if user wants logging
+    if args.logging != LogLevel.OFF.value:
+        # Set up startup logging to file early in the process
+        setup_startup_logging(Path.cwd())
 
     logger = get_logger("cli")
     if args.logging != LogLevel.OFF.value:
@@ -604,12 +679,13 @@ def run_session_legacy(args):
         # Log file already announced in startup_logging.py when created
 
     # Clean up old startup logs (using configured retention count)
-    try:
-        deleted_count = cleanup_old_startup_logs(Path.cwd())
-        if deleted_count > 0:
-            logger.debug(f"Cleaned up {deleted_count} old startup log files")
-    except Exception as e:
-        logger.debug(f"Failed to clean up old logs: {e}")
+    if args.logging != LogLevel.OFF.value:
+        try:
+            deleted_count = cleanup_old_startup_logs(Path.cwd())
+            if deleted_count > 0:
+                logger.debug(f"Cleaned up {deleted_count} old startup log files")
+        except Exception as e:
+            logger.debug(f"Failed to clean up old logs: {e}")
 
     # Log MCP and monitor startup status
     if args.logging != LogLevel.OFF.value:
@@ -623,6 +699,18 @@ 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)
+
+    # Trigger vector search indexing
+    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 +739,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
@@ -682,134 +770,127 @@ def run_session_legacy(args):
     if getattr(args, "no_native_agents", False):
         print("Native agents disabled")
     else:
-        # List deployed agent versions at startup
-        list_agent_versions_at_startup()
-
-        # Smart dependency checking - only when needed
-        if getattr(args, "check_dependencies", True):  # Default to checking
-            try:
-                from ...utils.agent_dependency_loader import AgentDependencyLoader
-                from ...utils.dependency_cache import SmartDependencyChecker
-                from ...utils.environment_context import should_prompt_for_dependencies
+        # Agent versions removed from startup display - use /mpm-agents to view
+        # list_agent_versions_at_startup()
+        pass
 
-                # Initialize smart checker
-                smart_checker = SmartDependencyChecker()
-                loader = AgentDependencyLoader(auto_install=False)
+    # Smart dependency checking - only when needed
+    if getattr(args, "check_dependencies", True):  # Default to checking
+        try:
+            from ...utils.agent_dependency_loader import AgentDependencyLoader
+            from ...utils.dependency_cache import SmartDependencyChecker
+            from ...utils.environment_context import should_prompt_for_dependencies
 
-                # Check if agents have changed
-                has_changed, deployment_hash = loader.has_agents_changed()
+            # Initialize smart checker
+            smart_checker = SmartDependencyChecker()
+            loader = AgentDependencyLoader(auto_install=False)
 
-                # Determine if we should check dependencies
-                should_check, check_reason = smart_checker.should_check_dependencies(
-                    force_check=getattr(args, "force_check_dependencies", False),
-                    deployment_hash=deployment_hash,
-                )
+            # Check if agents have changed
+            _has_changed, deployment_hash = loader.has_agents_changed()
 
-                if should_check:
-                    # Check if we're in an environment where prompting makes sense
-                    can_prompt, prompt_reason = should_prompt_for_dependencies(
-                        force_prompt=getattr(args, "force_prompt", False),
-                        force_skip=getattr(args, "no_prompt", False),
-                    )
+            # Determine if we should check dependencies
+            should_check, check_reason = smart_checker.should_check_dependencies(
+                force_check=getattr(args, "force_check_dependencies", False),
+                deployment_hash=deployment_hash,
+            )
 
-                    logger.debug(f"Dependency check needed: {check_reason}")
-                    logger.debug(
-                        f"Interactive prompting: {can_prompt} ({prompt_reason})"
-                    )
+            if should_check:
+                # Check if we're in an environment where prompting makes sense
+                can_prompt, prompt_reason = should_prompt_for_dependencies(
+                    force_prompt=getattr(args, "force_prompt", False),
+                    force_skip=getattr(args, "no_prompt", False),
+                )
 
-                    # Get or check dependencies
-                    results, was_cached = smart_checker.get_or_check_dependencies(
-                        loader=loader,
-                        force_check=getattr(args, "force_check_dependencies", False),
-                    )
+                logger.debug(f"Dependency check needed: {check_reason}")
+                logger.debug(f"Interactive prompting: {can_prompt} ({prompt_reason})")
 
-                    # Show summary if there are missing dependencies
-                    if results["summary"]["missing_python"]:
-                        missing_count = len(results["summary"]["missing_python"])
-                        print(f"⚠️  {missing_count} agent dependencies missing")
-
-                        if can_prompt and missing_count > 0:
-                            # Interactive prompt for installation
-                            print("\n📦 Missing dependencies detected:")
-                            for dep in results["summary"]["missing_python"][:5]:
-                                print(f"   - {dep}")
-                            if missing_count > 5:
-                                print(f"   ... and {missing_count - 5} more")
-
-                            print("\nWould you like to install them now?")
-                            print("  [y] Yes, install missing dependencies")
-                            print("  [n] No, continue without installing")
-                            print("  [q] Quit")
-
-                            sys.stdout.flush()  # Ensure prompt is displayed before input
-
-                            # Check if we're in a TTY environment for proper input handling
-                            if not sys.stdin.isatty():
-                                # In non-TTY environment (like pipes), use readline
-                                print("\nChoice [y/n/q]: ", end="", flush=True)
-                                try:
-                                    response = sys.stdin.readline().strip().lower()
-                                    # Handle various line endings and control characters
-                                    response = (
-                                        response.replace("\r", "")
-                                        .replace("\n", "")
-                                        .strip()
-                                    )
-                                except (EOFError, KeyboardInterrupt):
-                                    response = "q"
-                            else:
-                                # In TTY environment, use normal input()
-                                try:
-                                    response = (
-                                        input("\nChoice [y/n/q]: ").strip().lower()
-                                    )
-                                except (EOFError, KeyboardInterrupt):
-                                    response = "q"
+                # Get or check dependencies
+                results, was_cached = smart_checker.get_or_check_dependencies(
+                    loader=loader,
+                    force_check=getattr(args, "force_check_dependencies", False),
+                )
 
+                # Show summary if there are missing dependencies
+                if results["summary"]["missing_python"]:
+                    missing_count = len(results["summary"]["missing_python"])
+                    print(f"⚠️  {missing_count} agent dependencies missing")
+
+                    if can_prompt and missing_count > 0:
+                        # Interactive prompt for installation
+                        print("\n📦 Missing dependencies detected:")
+                        for dep in results["summary"]["missing_python"][:5]:
+                            print(f"   - {dep}")
+                        if missing_count > 5:
+                            print(f"   ... and {missing_count - 5} more")
+
+                        print("\nWould you like to install them now?")
+                        print("  [y] Yes, install missing dependencies")
+                        print("  [n] No, continue without installing")
+                        print("  [q] Quit")
+
+                        sys.stdout.flush()  # Ensure prompt is displayed before input
+
+                        # Check if we're in a TTY environment for proper input handling
+                        if not sys.stdin.isatty():
+                            # In non-TTY environment (like pipes), use readline
+                            print("\nChoice [y/n/q]: ", end="", flush=True)
                             try:
-                                if response == "y":
-                                    print("\n🔧 Installing missing dependencies...")
-                                    loader.auto_install = True
-                                    (
-                                        success,
-                                        error,
-                                    ) = loader.install_missing_dependencies(
-                                        results["summary"]["missing_python"]
-                                    )
-                                    if success:
-                                        print("✅ Dependencies installed successfully")
-                                        # Invalidate cache after installation
-                                        smart_checker.cache.invalidate(deployment_hash)
-                                    else:
-                                        print(f"❌ Installation failed: {error}")
-                                elif response == "q":
-                                    print("👋 Exiting...")
-                                    return
-                                else:
-                                    print(
-                                        "⏩ Continuing without installing dependencies"
-                                    )
+                                response = sys.stdin.readline().strip().lower()
+                                # Handle various line endings and control characters
+                                response = (
+                                    response.replace("\r", "").replace("\n", "").strip()
+                                )
                             except (EOFError, KeyboardInterrupt):
-                                print("\n⏩ Continuing without installing dependencies")
+                                response = "q"
                         else:
-                            # Non-interactive environment or prompting disabled
-                            print(
-                                "   Run 'pip install \"claude-mpm[agents]\"' to install all agent dependencies"
-                            )
-                            if not can_prompt:
-                                logger.debug(
-                                    f"Not prompting for installation: {prompt_reason}"
+                            # In TTY environment, use normal input()
+                            try:
+                                response = input("\nChoice [y/n/q]: ").strip().lower()
+                            except (EOFError, KeyboardInterrupt):
+                                response = "q"
+
+                        try:
+                            if response == "y":
+                                print("\n🔧 Installing missing dependencies...")
+                                loader.auto_install = True
+                                (
+                                    success,
+                                    error,
+                                ) = loader.install_missing_dependencies(
+                                    results["summary"]["missing_python"]
                                 )
-                    elif was_cached:
-                        logger.debug("Dependencies satisfied (cached result)")
+                                if success:
+                                    print("✅ Dependencies installed successfully")
+                                    # Invalidate cache after installation
+                                    smart_checker.cache.invalidate(deployment_hash)
+                                else:
+                                    print(f"❌ Installation failed: {error}")
+                            elif response == "q":
+                                print("👋 Exiting...")
+                                return
+                            else:
+                                print("⏩ Continuing without installing dependencies")
+                        except (EOFError, KeyboardInterrupt):
+                            print("\n⏩ Continuing without installing dependencies")
                     else:
-                        logger.debug("All dependencies satisfied")
+                        # Non-interactive environment or prompting disabled
+                        print(
+                            "   Run 'pip install \"claude-mpm[agents]\"' to install all agent dependencies"
+                        )
+                        if not can_prompt:
+                            logger.debug(
+                                f"Not prompting for installation: {prompt_reason}"
+                            )
+                elif was_cached:
+                    logger.debug("Dependencies satisfied (cached result)")
                 else:
-                    logger.debug(f"Skipping dependency check: {check_reason}")
+                    logger.debug("All dependencies satisfied")
+            else:
+                logger.debug(f"Skipping dependency check: {check_reason}")
 
-            except Exception as e:
-                if args.logging != LogLevel.OFF.value:
-                    logger.debug(f"Could not check agent dependencies: {e}")
+        except Exception as e:
+            if args.logging != LogLevel.OFF.value:
+                logger.debug(f"Could not check agent dependencies: {e}")
                 # Continue anyway - don't block execution
 
     # Create simple runner
@@ -824,7 +905,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 +936,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 +955,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 +967,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 +1016,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 +1052,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 +1068,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):