claude-mpm 4.3.11__py3-none-any.whl → 4.3.13__py3-none-any.whl

claude_mpm/cli/commands/mcp.py

@@ -186,7 +186,7 @@ def _show_status(
             ToolRegistry()
             # Don't initialize fully, just check
             print("\n🔧 Tools: Check with 'claude-mpm mcp tools'")
-        except:
+        except Exception:
             print("\n🔧 Tools: Registry not available")
 
     print("\n💡 Available Commands:")

claude_mpm/cli/commands/mcp_command_router.py

@@ -16,7 +16,7 @@ class MCPCommandRouter:
         """Initialize the command router."""
         self.logger = logger
 
-    def route_command(self, args) -> int:
+    def route_command(self, args) -> int:  # noqa: PLR0911
         """Route command to appropriate handler."""
         if args.mcp_command == MCPCommands.START.value:
             return asyncio.run(self._start_server(args))
@@ -45,6 +45,9 @@ class MCPCommandRouter:
         if args.mcp_command == MCPCommands.SERVER.value:
             return self._run_server(args)
 
+        if args.mcp_command == MCPCommands.EXTERNAL.value:
+            return self._manage_external(args)
+
         if args.mcp_command == "cleanup":
             return self._cleanup_locks(args)
 
@@ -124,6 +127,13 @@ class MCPCommandRouter:
         handler = MCPServerCommands(self.logger)
         return asyncio.run(handler.start_server(args))
 
+    def _manage_external(self, args) -> int:
+        """Manage external MCP services command handler."""
+        from .mcp_external_commands import MCPExternalCommands
+
+        handler = MCPExternalCommands(self.logger)
+        return handler.manage_external(args)
+
     def _show_help(self):
         """Show available MCP commands."""
         print("\nAvailable MCP commands:")
@@ -136,6 +146,7 @@ class MCPCommandRouter:
         print("  register - Register a new tool")
         print("  test     - Test tool invocation")
         print("  config   - View and manage configuration")
+        print("  external - Manage external MCP services")
         print("  cleanup  - Clean up legacy files")
         print("\nFor help with a specific command:")
         print("  claude-mpm mcp <command> --help")

claude_mpm/cli/commands/mcp_config.py

@@ -0,0 +1,154 @@
+"""
+MCP Configuration Command
+=========================
+
+Command for managing MCP service configurations with pipx preference.
+"""
+
+import json
+from pathlib import Path
+
+from ...services.mcp_config_manager import MCPConfigManager
+from ..shared import BaseCommand, CommandResult
+
+
+class MCPConfigCommand(BaseCommand):
+    """Manage MCP service configurations."""
+
+    def __init__(self):
+        super().__init__("mcp-config")
+
+    def run(self, args) -> CommandResult:
+        """Execute the MCP configuration command."""
+        manager = MCPConfigManager()
+
+        # Handle different sub-commands
+        if hasattr(args, "mcp_config_command"):
+            command = args.mcp_config_command
+
+            if command == "detect":
+                return self._detect_services(manager)
+            if command == "update":
+                return self._update_config(manager, args)
+            if command == "validate":
+                return self._validate_config(manager)
+            if command == "install":
+                return self._install_services(manager)
+            return self._show_status(manager)
+        return self._show_status(manager)
+
+    def _detect_services(self, manager: MCPConfigManager) -> CommandResult:
+        """Detect available MCP services."""
+        results = {}
+        for service in manager.PIPX_SERVICES:
+            path = manager.detect_service_path(service)
+            results[service] = {
+                "found": path is not None,
+                "path": path or "Not found",
+            }
+
+        return CommandResult(
+            success=True,
+            message="MCP service detection complete",
+            data=results,
+        )
+
+    def _update_config(self, manager: MCPConfigManager, args) -> CommandResult:
+        """Update MCP configuration."""
+        force_pipx = getattr(args, "force_pipx", True)
+        success, message = manager.update_mcp_config(force_pipx=force_pipx)
+
+        if success:
+            # Show the updated configuration
+            config_path = Path.cwd() / ".mcp.json"
+            if config_path.exists():
+                with open(config_path) as f:
+                    config = json.load(f)
+                return CommandResult(
+                    success=True,
+                    message=message,
+                    data=config,
+                )
+
+        return CommandResult(
+            success=success,
+            message=message,
+        )
+
+    def _validate_config(self, manager: MCPConfigManager) -> CommandResult:
+        """Validate current MCP configuration."""
+        results = manager.validate_configuration()
+
+        all_valid = all(results.values()) if results else False
+        message = (
+            "All MCP services are properly configured"
+            if all_valid
+            else "Some MCP services are not accessible"
+        )
+
+        return CommandResult(
+            success=all_valid,
+            message=message,
+            data=results,
+        )
+
+    def _install_services(self, manager: MCPConfigManager) -> CommandResult:
+        """Install missing MCP services."""
+        success, message = manager.install_missing_services()
+        return CommandResult(
+            success=success,
+            message=message,
+        )
+
+    def _show_status(self, manager: MCPConfigManager) -> CommandResult:
+        """Show current MCP configuration status."""
+        # Detect services
+        detected = {}
+        for service in manager.PIPX_SERVICES:
+            path = manager.detect_service_path(service)
+            detected[service] = {
+                "installed": path is not None,
+                "path": path or "Not installed",
+                "via_pipx": path and "pipx" in path if path else False,
+            }
+
+        # Validate configuration
+        config_valid = manager.validate_configuration()
+
+        # Read current config
+        config_path = Path.cwd() / ".mcp.json"
+        current_config = {}
+        if config_path.exists():
+            try:
+                with open(config_path) as f:
+                    current_config = json.load(f)
+            except Exception:
+                pass
+
+        status_data = {
+            "services": detected,
+            "configuration_valid": config_valid,
+            "config_file_exists": config_path.exists(),
+            "configured_services": list(current_config.get("mcpServers", {}).keys()),
+        }
+
+        return CommandResult(
+            success=True,
+            message="MCP configuration status",
+            data=status_data,
+        )
+
+
+def manage_mcp_config(args):
+    """
+    Entry point for MCP configuration command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code
+    """
+    command = MCPConfigCommand()
+    result = command.execute(args)
+    return result.exit_code

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):  # noqa: PLR0911
+        """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 Desktop.
+
+        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 Desktop
+        print("\n2️⃣  Configuring Claude Desktop...")
+        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 Desktop 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 Desktop 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 open(config_path) 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 Desktop 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 Desktop 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

@@ -46,31 +46,62 @@ class MCPInstallCommands:
                 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 (~/.claude.json)...")
+        # Step 2: Configure Claude Desktop with the new CLI command
+        print("\n2️⃣  Configuring Claude Desktop...")
         try:
             success = self._configure_claude_desktop(args.force)
-            if success:
-                print("✅ 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")
-                return 0
-            print("❌ Configuration failed")
-            return 1
+            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 Desktop 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 Desktop (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.
+        """Configure Claude Desktop to use the MCP gateway via CLI command.
 
-        WHY: Claude Code reads MCP server configurations from ~/.claude.json
-        (not ~/.claude/settings.local.json). This method updates that file
-        to include the claude-mpm-gateway server configuration.
+        WHY: Claude Desktop 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
@@ -135,16 +166,54 @@ class MCPInstallCommands:
         return self._save_config(config, config_path)
 
     def _get_claude_config_path(self):
-        """Get the Claude Code configuration file path.
+        """Get the Claude Desktop configuration file path.
 
         Returns:
-            Path or None: Path to Claude Code config file
+            Path or None: Path to Claude Desktop config file
         """
-
-        # Claude Code reads MCP server configurations from ~/.claude.json
-        # This is the actual file that Claude Code uses for MCP servers
-        # NOT ~/.claude/settings.local.json
-        return Path.home() / ".claude.json"
+        import platform
+
+        # Try multiple possible locations for Claude Desktop 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.
@@ -240,7 +309,7 @@ class MCPInstallCommands:
                         existing_config = json.load(f)
                     config = existing_config
                     print("   Force mode: Overwriting existing configuration")
-                except:
+                except Exception:
                     pass  # File doesn't exist or is invalid, start fresh
 
         # Ensure mcpServers section exists