claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/cli/commands/mcp_command_router.py

@@ -0,0 +1,139 @@
+"""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 typing import Any
+
+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))
+
+        elif args.mcp_command == MCPCommands.STOP.value:
+            return self._stop_server(args)
+
+        elif args.mcp_command == MCPCommands.STATUS.value:
+            return self._show_status(args)
+
+        elif args.mcp_command == MCPCommands.TOOLS.value:
+            return self._manage_tools(args)
+
+        elif args.mcp_command == MCPCommands.REGISTER.value:
+            return self._register_tool(args)
+
+        elif args.mcp_command == MCPCommands.TEST.value:
+            return self._test_tool(args)
+
+        elif args.mcp_command == MCPCommands.INSTALL.value:
+            return self._install_gateway(args)
+
+        elif args.mcp_command == MCPCommands.CONFIG.value:
+            return self._manage_config(args)
+
+        elif args.mcp_command == "cleanup":
+            return self._cleanup_locks(args)
+
+        else:
+            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 _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("  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("  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 start --instructions    # Show setup instructions")
+        print("  claude-mpm mcp start --test           # Test mode with debug output")
+        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_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

claude_mpm/cli/commands/mcp_install_commands.py

@@ -0,0 +1,20 @@
+"""MCP install command implementations.
+
+This module provides MCP installation commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+
+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 MCP gateway command."""
+        self.logger.info("MCP gateway installation command called")
+        print("📦 MCP gateway installation functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0

claude_mpm/cli/commands/mcp_server_commands.py

@@ -0,0 +1,175 @@
+"""MCP server command implementations.
+
+This module provides MCP server management commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+import asyncio
+import subprocess
+import sys
+from pathlib import Path
+
+
+class MCPServerCommands:
+    """Handles MCP server commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP server commands handler."""
+        self.logger = logger
+
+    async def start_server(self, args):
+        """Start MCP server command.
+
+        WHY: This command starts the MCP server using the proper stdio-based
+        implementation that Claude Code can communicate with.
+        NOTE: MCP is ONLY for Claude Code - NOT for Claude Desktop.
+
+        DESIGN DECISION: When called without flags, we run the server directly
+        for Claude Code compatibility. With --instructions flag, we show setup info.
+        """
+        self.logger.info("MCP server start command called")
+
+        # Check if we're being called by Claude Code (no special flags)
+        show_instructions = getattr(args, "instructions", False)
+        test_mode = getattr(args, "test", False)
+        daemon_mode = getattr(args, "daemon", False)
+
+        if daemon_mode:
+            # Daemon mode - not recommended for MCP
+            print("⚠️  MCP servers are designed to be spawned by Claude Code")
+            print("   Running as a daemon is not recommended.")
+            print("   Note: MCP is ONLY for Claude Code, not Claude Desktop.")
+            return 1
+
+        if show_instructions:
+            # Show configuration instructions
+            print("🚀 MCP Server Setup Instructions for Claude Code")
+            print("=" * 50)
+            print("\nℹ️  IMPORTANT: MCP is ONLY for Claude Code - NOT for Claude Desktop!")
+            print("   Claude Desktop uses a different system for agent deployment.")
+            print("\nThe MCP server is designed to be spawned by Claude Code.")
+            print("\nTo use the MCP server with Claude Code:")
+            print("\n1. Add this to your Claude Code configuration (~/.claude.json):")
+            print("\n{")
+            print('  "mcpServers": {')
+            print('    "claude-mpm": {')
+
+            # Find the correct binary path
+            bin_path = Path(sys.executable).parent / "claude-mpm-mcp"
+            if not bin_path.exists():
+                # Try to find it in the project bin directory
+                project_root = Path(__file__).parent.parent.parent.parent.parent
+                bin_path = project_root / "bin" / "claude-mpm-mcp"
+
+            if bin_path.exists():
+                print(f'      "command": "{bin_path}"')
+            else:
+                print('      "command": "claude-mpm-mcp"')
+                print("      // Or use the full path if not in PATH:")
+                print('      // "command": "/path/to/claude-mpm/bin/claude-mpm-mcp"')
+
+            print("    }")
+            print("  }")
+            print("}")
+            print("\n2. Restart Claude Code to load the MCP server")
+            print("\n3. The server will be automatically started when needed")
+            print("\nOr use the registration script:")
+            print("  python scripts/register_mcp_gateway.py")
+            print("\nTo test the server directly, run:")
+            print("  claude-mpm mcp start --test")
+            print("\nFor more information, see:")
+            print("  https://github.com/anthropics/mcp")
+
+            return 0
+
+        # Default behavior: Run the server directly (for Claude Code compatibility)
+        # When Claude Code spawns "claude-mpm mcp start", it expects the server to run
+        if test_mode:
+            print("🧪 Starting MCP server in test mode...")
+            print("   This will run the server with stdio communication.")
+            print("   Press Ctrl+C to stop.\n")
+
+        try:
+            # Configure logging to stderr for MCP mode
+            import logging
+            import sys
+
+            # Disable all stdout logging when running MCP server
+            # to prevent interference with JSON-RPC protocol
+            root_logger = logging.getLogger()
+
+            # Remove any existing handlers that might log to stdout
+            for handler in root_logger.handlers[:]:
+                if hasattr(handler, "stream") and handler.stream == sys.stdout:
+                    root_logger.removeHandler(handler)
+
+            # Add stderr handler if needed (but keep it minimal)
+            if not test_mode:
+                # In production mode, minimize stderr output too
+                logging.basicConfig(
+                    level=logging.ERROR,
+                    format="%(message)s",
+                    stream=sys.stderr,
+                    force=True,
+                )
+            else:
+                # In test mode, allow more verbose stderr logging
+                logging.basicConfig(
+                    level=logging.INFO,
+                    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                    stream=sys.stderr,
+                    force=True,
+                )
+
+            # Import and run the stdio server directly
+            from ...services.mcp_gateway.server.stdio_server import SimpleMCPServer
+
+            server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
+
+            # Run the server (handles stdio communication)
+            await server.run()
+            return 0
+
+        except ImportError as e:
+            self.logger.error(f"Failed to import MCP server: {e}")
+            # Don't print to stdout as it would interfere with JSON-RPC protocol
+            # Log to stderr instead
+            import sys
+
+            print(
+                f"❌ Error: Could not import MCP server components: {e}", file=sys.stderr
+            )
+            print("\nMake sure the MCP package is installed:", file=sys.stderr)
+            print("  pip install mcp", file=sys.stderr)
+            return 1
+        except KeyboardInterrupt:
+            # Graceful shutdown
+            self.logger.info("MCP server interrupted")
+            return 0
+        except Exception as e:
+            self.logger.error(f"Server error: {e}")
+            import sys
+
+            print(f"❌ Error running server: {e}", file=sys.stderr)
+            return 1
+
+    def stop_server(self, args):
+        """Stop MCP server command."""
+        self.logger.info("MCP server stop command called")
+        print("🛑 MCP server stop functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0
+
+    def show_status(self, args):
+        """Show MCP server status command."""
+        self.logger.info("MCP server status command called")
+        print("📊 MCP server status functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0
+
+    def cleanup_locks(self, args):
+        """Cleanup MCP server locks command."""
+        self.logger.info("MCP server cleanup locks command called")
+        print("🧹 MCP server cleanup locks functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0

claude_mpm/cli/commands/mcp_tool_commands.py

@@ -0,0 +1,34 @@
+"""MCP tool command implementations.
+
+This module provides MCP tool management commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+
+class MCPToolCommands:
+    """Handles MCP tool commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP tool commands handler."""
+        self.logger = logger
+
+    def manage_tools(self, args):
+        """Manage MCP tools command."""
+        self.logger.info("MCP tools management command called")
+        print("🔧 MCP tools management functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0
+
+    def register_tool(self, args):
+        """Register MCP tool command."""
+        self.logger.info("MCP tool registration command called")
+        print("📝 MCP tool registration functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0
+
+    def test_tool(self, args):
+        """Test MCP tool command."""
+        self.logger.info("MCP tool testing command called")
+        print("🧪 MCP tool testing functionality has been simplified")
+        print("   This command is now a placeholder - full implementation needed")
+        return 0