claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/cli/commands/mcp_external_commands.py

@@ -0,0 +1,249 @@
+"""MCP external services command implementations.
+
+This module provides commands for managing external MCP services
+like mcp-vector-search and mcp-browser.
+"""
+
+
+class MCPExternalCommands:
+    """Handles MCP external service commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP external commands handler."""
+        self.logger = logger
+
+    def manage_external(self, args):
+        """Manage external MCP services.
+
+        Args:
+            args: Parsed command line arguments
+
+        Returns:
+            int: Exit code (0 for success, non-zero for failure)
+        """
+        # Get the external subcommand if it exists
+        external_action = getattr(args, "external_action", None)
+
+        if not external_action:
+            # No subcommand provided, show help
+            self._show_help()
+            return 0
+
+        # Route to appropriate handler
+        if external_action == "setup":
+            return self._setup_external(args)
+        if external_action == "list":
+            return self._list_external(args)
+        if external_action == "check":
+            return self._check_external(args)
+        if external_action == "fix-browser":
+            return self._fix_browser(args)
+        if external_action == "detect":
+            return self._detect_and_update(args)
+        print(f"Unknown external subcommand: {external_action}")
+        self._show_help()
+        return 1
+
+    def _setup_external(self, args):
+        """Setup external MCP services in Claude Code.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        print("📦 Setting up External MCP Services")
+        print("=" * 50)
+
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+
+        # First install Python packages
+        print("\n1️⃣  Installing Python packages...")
+        if not setup.check_and_install_pip_packages():
+            print("⚠️ Some Python packages could not be installed")
+            print("   You may need to install them manually:")
+            print("   pip install mcp-vector-search mcp-browser")
+
+        # Then configure in Claude Code
+        print("\n2️⃣  Configuring Claude Code...")
+        force = getattr(args, "force", False)
+        if setup.setup_external_services(force=force):
+            print("\n✅ External services setup completed successfully!")
+            print("\nNext steps:")
+            print("1. Restart Claude Code to load the new services")
+            print("2. Check status with: claude-mpm mcp external list")
+            print("3. The services will be available in Claude as separate MCP servers")
+            return 0
+        print("\n❌ Failed to setup external services")
+        print("Please check the error messages above and try again")
+        return 1
+
+    def _list_external(self, args):
+        """List external MCP services and their status.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        setup.list_external_services()
+        return 0
+
+    def _check_external(self, args):
+        """Check if external services are properly configured.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        print("🔍 Checking External MCP Services Configuration")
+        print("=" * 50)
+
+        import json
+        from pathlib import Path
+
+        # Check Claude Code configuration
+        config_paths = [
+            Path.home()
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "claude_desktop_config.json",  # macOS
+            Path.home() / ".config" / "Claude" / "claude_desktop_config.json",  # Linux
+            Path.home()
+            / "AppData"
+            / "Roaming"
+            / "Claude"
+            / "claude_desktop_config.json",  # Windows
+            Path.home() / ".claude" / "claude_desktop_config.json",  # Alternative
+            Path.home() / ".claude.json",  # Legacy
+        ]
+
+        config_found = False
+        for config_path in config_paths:
+            if config_path.exists():
+                config_found = True
+                print(f"\n📄 Found config: {config_path}")
+
+                try:
+                    with config_path.open() as f:
+                        config = json.load(f)
+
+                    mcp_servers = config.get("mcpServers", {})
+
+                    # Check for external services
+                    external_services = ["mcp-vector-search", "mcp-browser"]
+                    for service in external_services:
+                        if service in mcp_servers:
+                            print(f"  ✅ {service} is configured")
+                            server_config = mcp_servers[service]
+                            print(f"     Command: {server_config.get('command')}")
+                            print(f"     Args: {server_config.get('args')}")
+                        else:
+                            print(f"  ❌ {service} is NOT configured")
+
+                except Exception as e:
+                    print(f"  ❌ Error reading config: {e}")
+
+                break
+
+        if not config_found:
+            print("❌ No Claude Code configuration found")
+            print("   Please run: claude-mpm mcp install")
+
+        # Check Python packages
+        print("\n🐍 Python Package Status:")
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+
+        packages = [
+            ("mcp-vector-search", "mcp_vector_search"),
+            ("mcp-browser", "mcp_browser"),
+        ]
+
+        for package_name, module_name in packages:
+            if setup._check_python_package(module_name):
+                print(f"  ✅ {package_name} is installed")
+            else:
+                print(f"  ❌ {package_name} is NOT installed")
+
+        return 0
+
+    def _fix_browser(self, args):
+        """Fix mcp-browser configuration to use pipx installation.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        if setup.fix_browser_configuration():
+            return 0
+        return 1
+
+    def _detect_and_update(self, args):
+        """Auto-detect MCP service installations and update configuration.
+
+        Prioritizes local development installations over pipx/system.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        force = getattr(args, "force", False)
+
+        if setup.update_mcp_json_with_detected(force=force):
+            print("\n✅ Configuration updated successfully!")
+            print("\nNext steps:")
+            print("1. Review the .mcp.json file to verify the configuration")
+            print("2. Restart Claude Code to load the updated services")
+            return 0
+        print("\n❌ Failed to update configuration")
+        return 1
+
+    def _show_help(self):
+        """Show help for external commands."""
+        print("\nMCP External Services Management")
+        print("=" * 40)
+        print("\nAvailable commands:")
+        print(
+            "  setup       - Setup external MCP services (mcp-vector-search, mcp-browser)"
+        )
+        print("  list        - List available external services and their status")
+        print("  check       - Check configuration and installation status")
+        print(
+            "  detect      - Auto-detect installations and update .mcp.json (prioritizes local dev)"
+        )
+        print("  fix-browser - Fix mcp-browser configuration to use pipx installation")
+        print("\nUsage:")
+        print("  claude-mpm mcp external setup         # Interactive setup")
+        print("  claude-mpm mcp external setup --force # Force reconfiguration")
+        print("  claude-mpm mcp external detect        # Auto-detect and update config")
+        print(
+            "  claude-mpm mcp external detect --force # Force update even if configured"
+        )
+        print("  claude-mpm mcp external list          # Show service status")
+        print("  claude-mpm mcp external check         # Detailed configuration check")
+        print("  claude-mpm mcp external fix-browser   # Fix mcp-browser to use pipx")
+        print("\nExternal services provide additional capabilities:")
+        print("  - mcp-vector-search: Semantic code search with embeddings")
+        print("  - mcp-browser: Web browsing and content extraction")

claude_mpm/cli/commands/mcp_install_commands.py

@@ -0,0 +1,346 @@
+"""MCP install command implementations.
+
+This module provides MCP installation and configuration commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+class MCPInstallCommands:
+    """Handles MCP install commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP install commands handler."""
+        self.logger = logger
+
+    def install_gateway(self, args):
+        """Install and configure MCP gateway.
+
+        WHY: This command installs the MCP package dependencies and configures
+        Claude Code to use the MCP gateway server directly via the CLI command.
+
+        DESIGN DECISION: We handle both package installation and configuration
+        in one command for user convenience, using the new direct CLI approach.
+        """
+        self.logger.info("MCP gateway installation command called")
+        print("📦 Installing and Configuring MCP Gateway")
+        print("=" * 50)
+
+        # Step 1: Install MCP package if needed
+        print("\n1️⃣  Checking MCP package installation...")
+        import importlib.util
+
+        mcp_spec = importlib.util.find_spec("mcp")
+        if mcp_spec:
+            print("✅ MCP package already installed")
+        else:
+            print("📦 Installing MCP package...")
+            try:
+                subprocess.check_call([sys.executable, "-m", "pip", "install", "mcp"])
+                print("✅ MCP package installed successfully")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Error installing MCP package: {e}")
+                print("\nPlease install manually with: pip install mcp")
+                return 1
+
+        # Step 2: Configure Claude Code with the new CLI command
+        print("\n2️⃣  Configuring Claude Code...")
+        try:
+            success = self._configure_claude_desktop(args.force)
+            if not success:
+                print("❌ Main gateway configuration failed")
+                return 1
+
+            # Step 3: Setup external MCP services
+            print("\n3️⃣  Setting up External MCP Services...")
+            from .mcp_setup_external import MCPExternalServicesSetup
+
+            external_setup = MCPExternalServicesSetup(self.logger)
+
+            # Check if user wants to set up external services
+            response = (
+                input(
+                    "\nDo you want to set up external MCP services (mcp-vector-search, mcp-browser)? (Y/n): "
+                )
+                .strip()
+                .lower()
+            )
+            if response in ["", "y", "yes"]:
+                # Install Python packages for external services
+                external_setup.check_and_install_pip_packages()
+
+                # Setup external services in Claude Code config
+                if external_setup.setup_external_services(force=args.force):
+                    print("✅ External services configured successfully")
+                else:
+                    print("⚠️ Some external services may not have been configured")
+            else:
+                print("⏭️ Skipping external services setup")
+                print(
+                    "   You can set them up later with: claude-mpm mcp external setup"
+                )
+
+            print("\n✅ Configuration completed successfully")
+            print("\n🎉 MCP Gateway is ready to use!")
+            print("\nNext steps:")
+            print("1. Restart Claude Code (if running)")
+            print("2. Test the server: claude-mpm mcp server --test")
+            print("3. Check status: claude-mpm mcp status")
+            print("4. List external services: claude-mpm mcp external list")
+            return 0
+
+        except Exception as e:
+            print(f"❌ Error during configuration: {e}")
+            return 1
+
+    def _configure_claude_desktop(self, force=False):
+        """Configure Claude Code to use the MCP gateway via CLI command.
+
+        WHY: Claude Code reads MCP server configurations from a platform-specific
+        configuration file. This method updates that file to include the claude-mpm-gateway
+        server configuration.
+
+        Args:
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            bool: True if configuration was successful
+        """
+
+        # Determine Claude Code config path
+        config_path = self._get_claude_config_path()
+        if not config_path:
+            print("❌ Could not determine Claude Code configuration path")
+            return False
+
+        print(f"   Configuration path: {config_path}")
+
+        # Load existing configuration or create new one
+        config = self._load_or_create_config(config_path, force)
+        if config is None:
+            return False
+
+        # Configure the claude-mpm-gateway server using the CLI command
+        claude_mpm_path = self._find_claude_mpm_executable()
+        if not claude_mpm_path:
+            print("❌ Could not find claude-mpm executable")
+            return False
+
+        # Determine if we need to use -m claude_mpm or direct command
+        if claude_mpm_path.endswith(("python", "python3", "python.exe", "python3.exe")):
+            # Using Python interpreter directly
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["-m", "claude_mpm", "mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production",
+                },
+            }
+        else:
+            # Using installed claude-mpm command
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production",
+                },
+            }
+
+        # Update configuration
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        config["mcpServers"]["claude-mpm-gateway"] = mcp_config
+
+        print("\n✅ Configured claude-mpm-gateway server:")
+        print(f"   Command: {mcp_config['command']}")
+        print(f"   Args: {mcp_config['args']}")
+        print(f"   Environment variables: {list(mcp_config['env'].keys())}")
+
+        # Save configuration
+        return self._save_config(config, config_path)
+
+    def _get_claude_config_path(self):
+        """Get the Claude Code configuration file path.
+
+        Returns:
+            Path or None: Path to Claude Code config file
+        """
+        import platform
+
+        # Try multiple possible locations for Claude Code config
+        possible_paths = [
+            Path.home()
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "claude_desktop_config.json",  # macOS
+            Path.home() / ".config" / "Claude" / "claude_desktop_config.json",  # Linux
+            Path.home()
+            / "AppData"
+            / "Roaming"
+            / "Claude"
+            / "claude_desktop_config.json",  # Windows
+            Path.home() / ".claude" / "claude_desktop_config.json",  # Alternative
+            Path.home() / ".claude.json",  # Legacy
+        ]
+
+        for path in possible_paths:
+            if path.exists():
+                return path
+
+        # If none exist, return the platform-appropriate default
+        system = platform.system()
+        if system == "Darwin":  # macOS
+            return (
+                Path.home()
+                / "Library"
+                / "Application Support"
+                / "Claude"
+                / "claude_desktop_config.json"
+            )
+        if system == "Windows":
+            return (
+                Path.home()
+                / "AppData"
+                / "Roaming"
+                / "Claude"
+                / "claude_desktop_config.json"
+            )
+        # Linux and others
+        return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+
+    def _find_claude_mpm_executable(self):
+        """Find the claude-mpm executable path.
+
+        WHY: We need to find the installed claude-mpm command to use as the
+        MCP server command. This ensures we're using the properly installed
+        version with all dependencies, not a raw Python script.
+
+        DESIGN DECISION: We prioritize in this order:
+        1. System-installed claude-mpm (most reliable)
+        2. pipx-installed claude-mpm (detected via deployment context)
+        3. Virtual environment claude-mpm (development)
+        4. Python module invocation (fallback)
+
+        Returns:
+            str or None: Path to claude-mpm executable
+        """
+        import sys
+
+        from ...core.unified_paths import get_executable_path
+
+        # Use the enhanced unified path manager for executable detection
+        executable_path = get_executable_path()
+        if executable_path:
+            print(f"   Found claude-mpm: {executable_path}")
+            return str(executable_path)
+
+        # Fallback: Use Python module invocation if no executable found
+        import importlib.util
+
+        claude_mpm_spec = importlib.util.find_spec("claude_mpm")
+        if claude_mpm_spec:
+            print(f"   Using Python module: {sys.executable} -m claude_mpm")
+            return sys.executable
+
+        return None
+
+    def _load_or_create_config(self, config_path, force=False):
+        """Load existing configuration or create a new one.
+
+        Args:
+            config_path: Path to configuration file
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            dict or None: Configuration dictionary
+        """
+        import json
+        from datetime import datetime, timezone
+
+        config = {}
+
+        if config_path.exists():
+            if not force:
+                # Check if claude-mpm-gateway already exists
+                try:
+                    with config_path.open() as f:
+                        existing_config = json.load(f)
+
+                    if (
+                        existing_config.get("mcpServers", {}).get("claude-mpm-gateway")
+                        and not force
+                    ):
+                        print("⚠️  claude-mpm-gateway is already configured")
+                        response = (
+                            input("Do you want to overwrite it? (y/N): ")
+                            .strip()
+                            .lower()
+                        )
+                        if response not in ["y", "yes"]:
+                            print("❌ Configuration cancelled")
+                            return None
+
+                    config = existing_config
+
+                except (OSError, json.JSONDecodeError) as e:
+                    print(f"⚠️  Error reading existing config: {e}")
+                    print("Creating backup and starting fresh...")
+
+                    # Create backup
+                    backup_path = config_path.with_suffix(
+                        f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
+                    )
+                    try:
+                        config_path.rename(backup_path)
+                        print(f"   Backup created: {backup_path}")
+                    except Exception as backup_error:
+                        print(f"   Warning: Could not create backup: {backup_error}")
+            else:
+                # Force mode - create backup but proceed
+                try:
+                    with config_path.open() as f:
+                        existing_config = json.load(f)
+                    config = existing_config
+                    print("   Force mode: Overwriting existing configuration")
+                except Exception:
+                    pass  # File doesn't exist or is invalid, start fresh
+
+        # Ensure mcpServers section exists
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        return config
+
+    def _save_config(self, config, config_path):
+        """Save configuration to file.
+
+        Args:
+            config: Configuration dictionary
+            config_path: Path to save configuration
+
+        Returns:
+            bool: True if successful
+        """
+        import json
+
+        try:
+            # Ensure directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write configuration with nice formatting
+            with config_path.open("w") as f:
+                json.dump(config, f, indent=2)
+
+            print(f"\n✅ Configuration saved to {config_path}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Error saving configuration: {e}")
+            return False