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

claude_mpm/cli/commands/mcp.py

@@ -0,0 +1,205 @@
+"""
+MCP Gateway command implementation for claude-mpm.
+
+WHY: This module provides CLI commands for managing the MCP (Model Context Protocol) Gateway,
+allowing users to start, stop, configure, and test MCP server functionality.
+
+DESIGN DECISION: We follow the existing CLI pattern using a main function
+that dispatches to specific subcommand handlers, maintaining consistency
+with other command modules like agents.py and memory.py.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+from ...constants import MCPCommands
+from ...core.logger import get_logger
+
+
+def manage_mcp(args):
+    """
+    Manage MCP Gateway server and tools.
+
+    WHY: The MCP Gateway provides Model Context Protocol integration for Claude MPM,
+    enabling tool invocation and external service integration. This command provides
+    a unified interface for all MCP-related operations.
+
+    DESIGN DECISION: When no subcommand is provided, we show the server status
+    as the default action, giving users a quick overview of the MCP system state.
+
+    Args:
+        args: Parsed command line arguments with mcp_command attribute
+    """
+    logger = get_logger("cli.mcp")
+
+    # First check if MCP package is installed for any command
+    import importlib.util
+
+    mcp_spec = importlib.util.find_spec("mcp")
+    if not mcp_spec:
+        if args.mcp_command != MCPCommands.INSTALL.value:
+            print("\nMCP package is not installed.", file=sys.stderr)
+            print("Please install it first:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
+            print("\nOr manually:", file=sys.stderr)
+            print("  pip install mcp", file=sys.stderr)
+            return 1
+
+    try:
+        # Import MCP Gateway services with error handling
+        try:
+            from ...services.mcp_gateway import (
+                MCPConfiguration,
+                MCPServiceRegistry,
+                ToolRegistry,
+            )
+            from ...services.mcp_gateway.server.mcp_gateway import MCPGateway
+        except ImportError as e:
+            # Provide minimal fallbacks for basic commands
+            logger.warning(f"Some MCP Gateway services not available: {e}")
+
+            # Allow install command to proceed
+            if args.mcp_command == MCPCommands.INSTALL.value:
+                MCPConfiguration = None
+                MCPServiceRegistry = None
+                ToolRegistry = None
+                MCPGateway = None
+            else:
+                print(
+                    "\nError: MCP Gateway services not fully available",
+                    file=sys.stderr,
+                )
+                print(f"Details: {e}", file=sys.stderr)
+                print("\nTry running:", file=sys.stderr)
+                print("  claude-mpm mcp install", file=sys.stderr)
+                return 1
+
+        if not args.mcp_command:
+            # No subcommand - show status by default
+            return _show_status(
+                args,
+                logger,
+                MCPConfiguration,
+                MCPServiceRegistry,
+                ToolRegistry,
+                MCPGateway,
+            )
+
+        # Route to specific command handlers
+        from .mcp_command_router import MCPCommandRouter
+
+        router = MCPCommandRouter(logger)
+        return router.route_command(args)
+
+    except ImportError as e:
+        logger.error(f"MCP Gateway services not available: {e}")
+        print("Error: MCP Gateway services not available")
+        print("This may indicate a missing dependency. Try running:")
+        print("  pip install mcp")
+        return 1
+    except Exception as e:
+        logger.error(f"Error managing MCP Gateway: {e}", exc_info=True)
+        print(f"Error: {e}")
+        return 1
+
+
+# Command handlers moved to separate modules
+
+
+# All command handler functions moved to separate modules
+# - MCPServerCommands: start, stop, status, cleanup
+# - MCPToolCommands: tools, register, test
+# - MCPInstallCommands: install
+# - MCPConfigCommands: config
+
+
+def _show_status(
+    args,
+    logger,
+    MCPConfiguration,
+    MCPServiceRegistry,
+    ToolRegistry,
+    MCPGateway,
+):
+    """
+    Show MCP Gateway status when no subcommand is provided.
+
+    WHY: Users often want a quick overview of the MCP system state.
+    This provides server status, registered tools, and configuration info.
+
+    DESIGN DECISION: We show a comprehensive status including server state,
+    tool count, and configuration path to give users a complete picture.
+    """
+    print("📊 MCP Gateway Status")
+    print("=" * 50)
+
+    # Check if MCP package is installed
+    import importlib.util
+
+    mcp_spec = importlib.util.find_spec("mcp")
+    if mcp_spec:
+        print("✅ MCP package installed")
+    else:
+        print("❌ MCP package not installed")
+        print("   Run: claude-mpm mcp install")
+        return 1
+
+    # Show configuration status
+    print("\n📁 Configuration:")
+    config_path = Path.home() / ".claude" / "mcp_config.json"
+    if config_path.exists():
+        print(f"   Config file: {config_path}")
+        try:
+            with config_path.open() as f:
+                config = json.load(f)
+                if "servers" in config:
+                    print(f"   Configured servers: {len(config.get('servers', {}))}")
+        except Exception as e:
+            print(f"   ⚠️  Error reading config: {e}")
+    else:
+        print(f"   No config file at {config_path}")
+
+    # Show Claude Code configuration
+    claude_config = (
+        Path.home()
+        / "Library"
+        / "Application Support"
+        / "Claude"
+        / "claude_desktop_config.json"
+    )
+    if claude_config.exists():
+        print(f"\n🖥️  Claude Code Config: {claude_config}")
+        try:
+            with claude_config.open() as f:
+                config = json.load(f)
+                mcp_servers = config.get("mcpServers", {})
+                if "claude-mpm" in mcp_servers:
+                    print("   ✅ claude-mpm server configured")
+                else:
+                    print("   ⚠️  claude-mpm server not configured")
+                    print("   Run: claude-mpm mcp start (for instructions)")
+        except Exception as e:
+            print(f"   ⚠️  Error reading config: {e}")
+    else:
+        print("\n🖥️  Claude Code not configured for MCP")
+        print("   Run: claude-mpm mcp start (for instructions)")
+
+    # Show available tools count
+    if ToolRegistry:
+        try:
+            ToolRegistry()
+            # Don't initialize fully, just check
+            print("\n🔧 Tools: Check with 'claude-mpm mcp tools'")
+        except Exception:
+            print("\n🔧 Tools: Registry not available")
+
+    print("\n💡 Available Commands:")
+    print("   claude-mpm mcp install    - Install MCP dependencies")
+    print("   claude-mpm mcp start      - Start MCP server (stdio mode)")
+    print("   claude-mpm mcp start --instructions - Show setup instructions")
+    print("   claude-mpm mcp tools      - List available tools")
+    print("   claude-mpm mcp test       - Test tool invocation")
+    print("   claude-mpm mcp config     - Manage configuration")
+
+    return 0

claude_mpm/cli/commands/mcp_command_router.py

@@ -0,0 +1,161 @@
+"""MCP command router for CLI commands.
+
+This module routes MCP commands to their appropriate handlers.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+import asyncio
+
+from ...constants import MCPCommands
+
+
+class MCPCommandRouter:
+    """Routes MCP commands to appropriate handlers."""
+
+    def __init__(self, logger):
+        """Initialize the command router."""
+        self.logger = logger
+
+    def route_command(self, args) -> int:
+        """Route command to appropriate handler."""
+        if args.mcp_command == MCPCommands.START.value:
+            return asyncio.run(self._start_server(args))
+
+        if args.mcp_command == MCPCommands.STOP.value:
+            return self._stop_server(args)
+
+        if args.mcp_command == MCPCommands.STATUS.value:
+            return self._show_status(args)
+
+        if args.mcp_command == MCPCommands.TOOLS.value:
+            return self._manage_tools(args)
+
+        if args.mcp_command == MCPCommands.REGISTER.value:
+            return self._register_tool(args)
+
+        if args.mcp_command == MCPCommands.TEST.value:
+            return self._test_tool(args)
+
+        if args.mcp_command == MCPCommands.INSTALL.value:
+            return self._install_gateway(args)
+
+        if args.mcp_command == MCPCommands.CONFIG.value:
+            return self._manage_config(args)
+
+        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)
+
+        self.logger.error(f"Unknown MCP command: {args.mcp_command}")
+        print(f"Unknown MCP command: {args.mcp_command}")
+        self._show_help()
+        return 1
+
+    async def _start_server(self, args) -> int:
+        """Start server command handler."""
+        from .mcp_server_commands import MCPServerCommands
+
+        handler = MCPServerCommands(self.logger)
+        return await handler.start_server(args)
+
+    def _stop_server(self, args) -> int:
+        """Stop server command handler."""
+        from .mcp_server_commands import MCPServerCommands
+
+        handler = MCPServerCommands(self.logger)
+        return handler.stop_server(args)
+
+    def _show_status(self, args) -> int:
+        """Show status command handler."""
+        from .mcp_server_commands import MCPServerCommands
+
+        handler = MCPServerCommands(self.logger)
+        return handler.show_status(args)
+
+    def _manage_tools(self, args) -> int:
+        """Manage tools command handler."""
+        from .mcp_tool_commands import MCPToolCommands
+
+        handler = MCPToolCommands(self.logger)
+        return handler.manage_tools(args)
+
+    def _register_tool(self, args) -> int:
+        """Register tool command handler."""
+        from .mcp_tool_commands import MCPToolCommands
+
+        handler = MCPToolCommands(self.logger)
+        return handler.register_tool(args)
+
+    def _test_tool(self, args) -> int:
+        """Test tool command handler."""
+        from .mcp_tool_commands import MCPToolCommands
+
+        handler = MCPToolCommands(self.logger)
+        return handler.test_tool(args)
+
+    def _install_gateway(self, args) -> int:
+        """Install gateway command handler."""
+        from .mcp_install_commands import MCPInstallCommands
+
+        handler = MCPInstallCommands(self.logger)
+        return handler.install_gateway(args)
+
+    def _manage_config(self, args) -> int:
+        """Manage config command handler."""
+        from .mcp_config_commands import MCPConfigCommands
+
+        handler = MCPConfigCommands(self.logger)
+        return handler.manage_config(args)
+
+    def _cleanup_locks(self, args) -> int:
+        """Cleanup locks command handler."""
+        from .mcp_server_commands import MCPServerCommands
+
+        handler = MCPServerCommands(self.logger)
+        return handler.cleanup_locks(args)
+
+    def _run_server(self, args) -> int:
+        """Run server command handler - direct server execution."""
+        # Simply delegate to the async start_server method using asyncio.run
+        from .mcp_server_commands import MCPServerCommands
+
+        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:")
+        print("  install  - Install and configure MCP Gateway")
+        print("  start    - Start the MCP Gateway server (stdio mode)")
+        print("  server   - Run the MCP Gateway server directly")
+        print("  stop     - Stop the MCP Gateway server")
+        print("  status   - Show server and tool status")
+        print("  tools    - List and manage registered tools")
+        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")
+        print("\nExamples:")
+        print("  claude-mpm mcp install")
+        print("  claude-mpm mcp start                  # Run server (for Claude Code)")
+        print("  claude-mpm mcp server                 # Run server directly")
+        print("  claude-mpm mcp server --test          # Test mode with debug output")
+        print("  claude-mpm mcp start --instructions    # Show setup instructions")
+        print("  claude-mpm mcp tools")
+        print("  claude-mpm mcp register my-tool")
+        print("  claude-mpm mcp test my-tool")

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 config_path.open() 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 config_path.open() 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_config_commands.py

@@ -0,0 +1,20 @@
+"""MCP config command implementations.
+
+This module provides MCP configuration commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+
+class MCPConfigCommands:
+    """Handles MCP config commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP config commands handler."""
+        self.logger = logger
+
+    def manage_config(self, args):
+        """Manage MCP configuration command."""
+        self.logger.info("MCP configuration management command called")
+        print("⚙️  MCP configuration management functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0