codepp 0.0.437__py3-none-any.whl

code_puppy/command_line/mcp/custom_server_installer.py

@@ -0,0 +1,195 @@
+"""Custom MCP server installation logic.
+
+Handles prompting users for custom server configuration and installing
+custom MCP servers with JSON configuration.
+"""
+
+import json
+import os
+
+from code_puppy.command_line.utils import safe_input
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+
+# Example configurations for each server type
+CUSTOM_SERVER_EXAMPLES = {
+    "stdio": """{
+  "type": "stdio",
+  "command": "npx",
+  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
+  "env": {
+    "NODE_ENV": "production"
+  },
+  "timeout": 30
+}""",
+    "http": """{
+  "type": "http",
+  "url": "http://localhost:8080/mcp",
+  "headers": {
+    "Authorization": "Bearer $MY_API_KEY",
+    "Content-Type": "application/json"
+  },
+  "timeout": 30
+}""",
+    "sse": """{
+  "type": "sse",
+  "url": "http://localhost:8080/sse",
+  "headers": {
+    "Authorization": "Bearer $MY_API_KEY"
+  }
+}""",
+}
+
+
+def prompt_and_install_custom_server(manager) -> bool:
+    """Prompt for custom server configuration and install it.
+
+    Args:
+        manager: MCP manager instance
+
+    Returns:
+        True if successful, False otherwise
+    """
+    from code_puppy.config import MCP_SERVERS_FILE
+    from code_puppy.mcp_.managed_server import ServerConfig
+
+    from .utils import find_server_id_by_name
+
+    emit_info("\n➕ Add Custom MCP Server\n")
+    emit_info("  Configure your own MCP server using JSON.\n")
+
+    # Get server name
+    try:
+        server_name = safe_input("  Server name: ")
+        if not server_name:
+            emit_warning("Server name is required")
+            return False
+    except (KeyboardInterrupt, EOFError):
+        emit_info("")
+        emit_warning("Cancelled")
+        return False
+
+    # Check if server already exists
+    existing = find_server_id_by_name(manager, server_name)
+    if existing:
+        try:
+            override = safe_input(f"  Server '{server_name}' exists. Override? [y/N]: ")
+            if not override.lower().startswith("y"):
+                emit_warning("Cancelled")
+                return False
+        except (KeyboardInterrupt, EOFError):
+            emit_info("")
+            emit_warning("Cancelled")
+            return False
+
+    # Select server type
+    emit_info("\n  Select server type:\n")
+    emit_info("    1. 📟 stdio  - Local command (npx, python, uvx, etc.)")
+    emit_info("    2. 🌐 http   - HTTP endpoint")
+    emit_info("    3. 📡 sse    - Server-Sent Events\n")
+
+    try:
+        type_choice = safe_input("  Enter choice [1-3]: ")
+    except (KeyboardInterrupt, EOFError):
+        emit_info("")
+        emit_warning("Cancelled")
+        return False
+
+    type_map = {"1": "stdio", "2": "http", "3": "sse"}
+    server_type = type_map.get(type_choice)
+    if not server_type:
+        emit_warning("Invalid choice")
+        return False
+
+    # Show example for selected type
+    example = CUSTOM_SERVER_EXAMPLES.get(server_type, "{}")
+    emit_info(f"\n  Example {server_type} configuration:\n")
+    for line in example.split("\n"):
+        emit_info(f"    {line}")
+    emit_info("")
+
+    # Get JSON configuration
+    emit_info("  Enter your JSON configuration (paste and press Enter twice):\n")
+
+    json_lines = []
+    empty_count = 0
+    try:
+        while True:
+            line = safe_input("")
+            if line == "":
+                empty_count += 1
+                if empty_count >= 2:
+                    break
+                json_lines.append(line)
+            else:
+                empty_count = 0
+                json_lines.append(line)
+    except (KeyboardInterrupt, EOFError):
+        emit_info("")
+        emit_warning("Cancelled")
+        return False
+
+    json_str = "\n".join(json_lines).strip()
+    if not json_str:
+        emit_warning("No configuration provided")
+        return False
+
+    # Parse JSON
+    try:
+        config_dict = json.loads(json_str)
+    except json.JSONDecodeError as e:
+        emit_error(f"Invalid JSON: {e}")
+        return False
+
+    # Validate required fields based on type
+    if server_type == "stdio":
+        if "command" not in config_dict:
+            emit_error("stdio servers require a 'command' field")
+            return False
+    elif server_type in ("http", "sse"):
+        if "url" not in config_dict:
+            emit_error(f"{server_type} servers require a 'url' field")
+            return False
+
+    # Create server config
+    try:
+        server_config = ServerConfig(
+            id=server_name,
+            name=server_name,
+            type=server_type,
+            enabled=True,
+            config=config_dict,
+        )
+
+        # Register with manager
+        server_id = manager.register_server(server_config)
+
+        if not server_id:
+            emit_error("Failed to register server")
+            return False
+
+        # Save to mcp_servers.json for persistence
+        if os.path.exists(MCP_SERVERS_FILE):
+            with open(MCP_SERVERS_FILE, "r") as f:
+                data = json.load(f)
+                servers = data.get("mcp_servers", {})
+        else:
+            servers = {}
+            data = {"mcp_servers": servers}
+
+        # Add new server with type
+        save_config = config_dict.copy()
+        save_config["type"] = server_type
+        servers[server_name] = save_config
+
+        # Save back
+        os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
+        with open(MCP_SERVERS_FILE, "w") as f:
+            json.dump(data, f, indent=2)
+
+        emit_success(f"\n  ✅ Successfully added custom server '{server_name}'!")
+        emit_info(f"  Use '/mcp start {server_name}' to start the server.\n")
+        return True
+
+    except Exception as e:
+        emit_error(f"Failed to add server: {e}")
+        return False

code_puppy/command_line/mcp/edit_command.py

@@ -0,0 +1,148 @@
+"""MCP Edit Command - Edit existing MCP server configurations.
+
+Provides a TUI for editing custom MCP server configurations.
+"""
+
+import json
+import logging
+import os
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.config import MCP_SERVERS_FILE
+from code_puppy.messaging import emit_error, emit_info, emit_warning
+
+from .base import MCPCommandBase
+from .custom_server_form import run_custom_server_form
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class EditCommand(MCPCommandBase):
+    """Command handler for editing existing MCP servers.
+
+    Opens the same TUI form as /mcp install custom, but pre-populated
+    with the existing server's configuration.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """Edit an existing MCP server configuration.
+
+        Args:
+            args: Server name to edit
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            # Need a server name
+            if not args:
+                emit_info(
+                    Text.from_markup("[yellow]Usage: /mcp edit <server_name>[/yellow]"),
+                    message_group=group_id,
+                )
+                emit_info(
+                    "Use '/mcp list' to see available servers.",
+                    message_group=group_id,
+                )
+                return
+
+            server_name = args[0]
+
+            # Load existing server config
+            server_config = self._load_server_config(server_name, group_id)
+            if server_config is None:
+                return
+
+            server_type, config_dict = server_config
+
+            # Run the form in edit mode
+            success = run_custom_server_form(
+                self.manager,
+                edit_mode=True,
+                existing_name=server_name,
+                existing_type=server_type,
+                existing_config=config_dict,
+            )
+
+            if success:
+                # Reload MCP servers to pick up changes
+                try:
+                    from code_puppy.agent import reload_mcp_servers
+
+                    reload_mcp_servers()
+                except ImportError:
+                    pass
+
+        except Exception as e:
+            logger.error(f"Error editing server: {e}")
+            emit_error(f"Error: {e}", message_group=group_id)
+
+    def _load_server_config(
+        self, server_name: str, group_id: str
+    ) -> Optional[tuple[str, dict]]:
+        """Load an existing server configuration from mcp_servers.json.
+
+        Args:
+            server_name: Name of the server to load
+            group_id: Message group ID for output
+
+        Returns:
+            Tuple of (server_type, config_dict) or None if not found
+        """
+        if not os.path.exists(MCP_SERVERS_FILE):
+            emit_error(
+                "No MCP servers configured yet.",
+                message_group=group_id,
+            )
+            emit_info(
+                "Use '/mcp install' to add a server first.",
+                message_group=group_id,
+            )
+            return None
+
+        try:
+            with open(MCP_SERVERS_FILE, "r") as f:
+                data = json.load(f)
+
+            servers = data.get("mcp_servers", {})
+
+            if server_name not in servers:
+                emit_error(
+                    f"Server '{server_name}' not found.",
+                    message_group=group_id,
+                )
+                # Show available servers
+                if servers:
+                    emit_warning(
+                        "\nAvailable servers:",
+                        message_group=group_id,
+                    )
+                    for name in sorted(servers.keys()):
+                        emit_info(f"  • {name}", message_group=group_id)
+                return None
+
+            config = servers[
+                server_name
+            ].copy()  # Make a copy to avoid modifying original
+
+            # Extract type from config (default to stdio)
+            server_type = config.pop("type", "stdio")
+
+            return (server_type, config)
+
+        except json.JSONDecodeError as e:
+            emit_error(
+                f"Error reading config file: {e}",
+                message_group=group_id,
+            )
+            return None
+        except Exception as e:
+            emit_error(
+                f"Error loading server config: {e}",
+                message_group=group_id,
+            )
+            return None

code_puppy/command_line/mcp/handler.py

@@ -0,0 +1,138 @@
+"""
+MCP Command Handler - Main router for MCP server management commands.
+
+This module provides the MCPCommandHandler class that routes MCP commands
+to their respective command modules.
+"""
+
+import logging
+import shlex
+
+from rich.text import Text
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .edit_command import EditCommand
+from .help_command import HelpCommand
+from .install_command import InstallCommand
+
+# Import all command modules
+from .list_command import ListCommand
+from .logs_command import LogsCommand
+from .remove_command import RemoveCommand
+from .restart_command import RestartCommand
+from .search_command import SearchCommand
+from .start_all_command import StartAllCommand
+from .start_command import StartCommand
+from .status_command import StatusCommand
+from .stop_all_command import StopAllCommand
+from .stop_command import StopCommand
+from .test_command import TestCommand
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class MCPCommandHandler(MCPCommandBase):
+    """
+    Main command handler for MCP server management operations.
+
+    Routes MCP commands to their respective command modules.
+    Each command is implemented in its own module for better maintainability.
+
+    Example usage:
+        handler = MCPCommandHandler()
+        handler.handle_mcp_command("/mcp list")
+        handler.handle_mcp_command("/mcp start filesystem")
+        handler.handle_mcp_command("/mcp status filesystem")
+    """
+
+    def __init__(self):
+        """Initialize the MCP command handler."""
+        super().__init__()
+
+        # Initialize command handlers
+        self._commands = {
+            "list": ListCommand(),
+            "start": StartCommand(),
+            "start-all": StartAllCommand(),
+            "stop": StopCommand(),
+            "stop-all": StopAllCommand(),
+            "restart": RestartCommand(),
+            "status": StatusCommand(),
+            "test": TestCommand(),
+            "edit": EditCommand(),
+            "remove": RemoveCommand(),
+            "logs": LogsCommand(),
+            "search": SearchCommand(),
+            "install": InstallCommand(),
+            "help": HelpCommand(),
+        }
+
+        logger.info("MCPCommandHandler initialized with all command modules")
+
+    def handle_mcp_command(self, command: str) -> bool:
+        """
+        Handle MCP commands and route to appropriate handler.
+
+        Args:
+            command: The full command string (e.g., "/mcp list", "/mcp start server")
+
+        Returns:
+            True if command was handled successfully, False otherwise
+        """
+        group_id = self.generate_group_id()
+
+        try:
+            # Remove /mcp prefix and parse arguments
+            command = command.strip()
+            if not command.startswith("/mcp"):
+                return False
+
+            # Remove the /mcp prefix
+            args_str = command[4:].strip()
+
+            # If no subcommand, show status dashboard
+            if not args_str:
+                self._commands["list"].execute([], group_id=group_id)
+                return True
+
+            # Parse arguments using shlex for proper handling of quoted strings
+            try:
+                args = shlex.split(args_str)
+            except ValueError as e:
+                emit_info(
+                    Text.from_markup(f"[red]Invalid command syntax: {e}[/red]"),
+                    message_group=group_id,
+                )
+                return True
+
+            if not args:
+                self._commands["list"].execute([], group_id=group_id)
+                return True
+
+            subcommand = args[0].lower()
+            sub_args = args[1:] if len(args) > 1 else []
+
+            # Route to appropriate command handler
+            command_handler = self._commands.get(subcommand)
+            if command_handler:
+                command_handler.execute(sub_args, group_id=group_id)
+                return True
+            else:
+                emit_info(
+                    Text.from_markup(
+                        f"[yellow]Unknown MCP subcommand: {subcommand}[/yellow]"
+                    ),
+                    message_group=group_id,
+                )
+                emit_info(
+                    "Type '/mcp help' for available commands", message_group=group_id
+                )
+                return True
+
+        except Exception as e:
+            logger.error(f"Error handling MCP command '{command}': {e}")
+            emit_info(f"Error executing MCP command: {e}", message_group=group_id)
+            return True

code_puppy/command_line/mcp/help_command.py

@@ -0,0 +1,147 @@
+"""
+MCP Help Command - Shows help for all MCP commands.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info
+
+from .base import MCPCommandBase
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class HelpCommand(MCPCommandBase):
+    """
+    Command handler for showing MCP command help.
+
+    Displays comprehensive help information for all available MCP commands.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Show help for MCP commands.
+
+        Args:
+            args: Command arguments (unused)
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            # Build help text programmatically to avoid markup conflicts
+            help_lines = []
+
+            # Title
+            help_lines.append(
+                Text("MCP Server Management Commands", style="bold magenta")
+            )
+            help_lines.append(Text(""))
+
+            # Registry Commands
+            help_lines.append(Text("Registry Commands:", style="bold cyan"))
+            help_lines.append(
+                Text("/mcp search", style="cyan")
+                + Text(" [query]     Search 30+ pre-configured servers")
+            )
+            help_lines.append(
+                Text("/mcp install", style="cyan")
+                + Text(" <id>       Install server from registry")
+            )
+            help_lines.append(Text(""))
+
+            # Core Commands
+            help_lines.append(Text("Core Commands:", style="bold cyan"))
+            help_lines.append(
+                Text("/mcp", style="cyan")
+                + Text("                    Show server status dashboard")
+            )
+            help_lines.append(
+                Text("/mcp list", style="cyan")
+                + Text("               List all registered servers")
+            )
+            help_lines.append(
+                Text("/mcp start", style="cyan")
+                + Text(" <name>       Start a specific server")
+            )
+            help_lines.append(
+                Text("/mcp start-all", style="cyan")
+                + Text("          Start all servers")
+            )
+            help_lines.append(
+                Text("/mcp stop", style="cyan")
+                + Text(" <name>        Stop a specific server")
+            )
+            help_lines.append(
+                Text("/mcp stop-all", style="cyan")
+                + Text(" [group_id]  Stop all running servers")
+            )
+            help_lines.append(
+                Text("/mcp restart", style="cyan")
+                + Text(" <name>     Restart a specific server")
+            )
+            help_lines.append(Text(""))
+
+            # Management Commands
+            help_lines.append(Text("Management Commands:", style="bold cyan"))
+            help_lines.append(
+                Text("/mcp status", style="cyan")
+                + Text(" [name]      Show detailed status (all servers or specific)")
+            )
+            help_lines.append(
+                Text("/mcp test", style="cyan")
+                + Text(" <name>        Test connectivity to a server")
+            )
+            help_lines.append(
+                Text("/mcp logs", style="cyan")
+                + Text(" <name> [limit] Show recent events (default limit: 10)")
+            )
+            help_lines.append(
+                Text("/mcp edit", style="cyan")
+                + Text(" <name>        Edit existing server config")
+            )
+            help_lines.append(
+                Text("/mcp remove", style="cyan")
+                + Text(" <name>      Remove/disable a server")
+            )
+            help_lines.append(
+                Text("/mcp help", style="cyan")
+                + Text("               Show this help message")
+            )
+            help_lines.append(Text(""))
+
+            # Status Indicators
+            help_lines.append(Text("Status Indicators:", style="bold"))
+            help_lines.append(
+                Text("✓ Running    ✗ Stopped    ⚠ Error    ⏸ Quarantined    ⭐ Popular")
+            )
+            help_lines.append(Text(""))
+
+            # Examples
+            help_lines.append(Text("Examples:", style="bold"))
+            examples_text = """/mcp search database     # Find database servers
+/mcp install postgres    # Install PostgreSQL server
+/mcp start filesystem    # Start a specific server
+/mcp start-all           # Start all servers at once
+/mcp stop-all            # Stop all running servers
+/mcp edit filesystem     # Edit an existing server config
+/mcp remove filesystem # Remove a server"""
+            help_lines.append(Text(examples_text, style="dim"))
+
+            # Combine all lines
+            final_text = Text()
+            for i, line in enumerate(help_lines):
+                if i > 0:
+                    final_text.append("\n")
+                final_text.append_text(line)
+
+            emit_info(final_text, message_group=group_id)
+
+        except Exception as e:
+            logger.error(f"Error showing help: {e}")
+            emit_error(f"Error showing help: {e}", message_group=group_id)