code-puppy 0.0.214__py3-none-any.whl → 0.0.366__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

@@ -8,10 +8,12 @@ to their respective command modules.
 import logging
 import shlex
 
+from rich.text import Text
+
 from code_puppy.messaging import emit_info
 
-from .add_command import AddCommand
 from .base import MCPCommandBase
+from .edit_command import EditCommand
 from .help_command import HelpCommand
 from .install_command import InstallCommand
 
@@ -60,7 +62,7 @@ class MCPCommandHandler(MCPCommandBase):
             "restart": RestartCommand(),
             "status": StatusCommand(),
             "test": TestCommand(),
-            "add": AddCommand(),
+            "edit": EditCommand(),
             "remove": RemoveCommand(),
             "logs": LogsCommand(),
             "search": SearchCommand(),
@@ -101,7 +103,8 @@ class MCPCommandHandler(MCPCommandBase):
                 args = shlex.split(args_str)
             except ValueError as e:
                 emit_info(
-                    f"[red]Invalid command syntax: {e}[/red]", message_group=group_id
+                    Text.from_markup(f"[red]Invalid command syntax: {e}[/red]"),
+                    message_group=group_id,
                 )
                 return True
 
@@ -119,7 +122,9 @@ class MCPCommandHandler(MCPCommandBase):
                 return True
             else:
                 emit_info(
-                    f"[yellow]Unknown MCP subcommand: {subcommand}[/yellow]",
+                    Text.from_markup(
+                        f"[yellow]Unknown MCP subcommand: {subcommand}[/yellow]"
+                    ),
                     message_group=group_id,
                 )
                 emit_info(

code_puppy/command_line/mcp/help_command.py

@@ -7,7 +7,7 @@ from typing import List, Optional
 
 from rich.text import Text
 
-from code_puppy.messaging import emit_info
+from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
 
@@ -102,8 +102,8 @@ class HelpCommand(MCPCommandBase):
                 + Text(" <name> [limit] Show recent events (default limit: 10)")
             )
             help_lines.append(
-                Text("/mcp add", style="cyan")
-                + Text(" [json]         Add new server (JSON or wizard)")
+                Text("/mcp edit", style="cyan")
+                + Text(" <name>        Edit existing server config")
             )
             help_lines.append(
                 Text("/mcp remove", style="cyan")
@@ -129,7 +129,8 @@ class HelpCommand(MCPCommandBase):
 /mcp start filesystem    # Start a specific server
 /mcp start-all           # Start all servers at once
 /mcp stop-all            # Stop all running servers
-/mcp add {"name": "test", "type": "stdio", "command": "echo"}"""
+/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
@@ -143,4 +144,4 @@ class HelpCommand(MCPCommandBase):
 
         except Exception as e:
             logger.error(f"Error showing help: {e}")
-            emit_info(f"[red]Error showing help: {e}[/red]", message_group=group_id)
+            emit_error(f"Error showing help: {e}", message_group=group_id)

code_puppy/command_line/mcp/install_command.py

@@ -5,11 +5,12 @@ MCP Install Command - Installs pre-configured MCP servers from the registry.
 import logging
 from typing import List, Optional
 
-from code_puppy.messaging import emit_info
-from code_puppy.tui_state import is_tui_mode
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
-from .wizard_utils import run_interactive_install_wizard
+from .install_menu import run_mcp_install_menu
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -19,7 +20,7 @@ class InstallCommand(MCPCommandBase):
     """
     Command handler for installing MCP servers from registry.
 
-    Installs pre-configured MCP servers with optional interactive wizard.
+    Installs pre-configured MCP servers with interactive menu-based browser.
     """
 
     def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
@@ -34,25 +35,10 @@ class InstallCommand(MCPCommandBase):
             group_id = self.generate_group_id()
 
         try:
-            # If in TUI mode, show message to use Ctrl+T
-            if is_tui_mode():
-                emit_info(
-                    "In TUI mode, use Ctrl+T to open the MCP Install Wizard",
-                    message_group=group_id,
-                )
-                return
-
-            # In interactive mode, use the comprehensive installer
+            # In interactive mode, use the menu-based browser
             if not args:
-                # No args - launch interactive wizard
-                success = run_interactive_install_wizard(self.manager, group_id)
-                if success:
-                    try:
-                        from code_puppy.agent import reload_mcp_servers
-
-                        reload_mcp_servers()
-                    except ImportError:
-                        pass
+                # No args - launch interactive menu
+                run_mcp_install_menu(self.manager)
                 return
 
             # Has args - install directly from catalog
@@ -166,7 +152,9 @@ class InstallCommand(MCPCommandBase):
             required_env_vars = selected_server.get_environment_vars()
             if required_env_vars:
                 emit_info(
-                    "\n[yellow]Required Environment Variables:[/yellow]",
+                    Text.from_markup(
+                        "\n[yellow]Required Environment Variables:[/yellow]"
+                    ),
                     message_group=group_id,
                 )
                 for var in required_env_vars:
@@ -176,7 +164,7 @@ class InstallCommand(MCPCommandBase):
                     current_value = os.environ.get(var, "")
                     if current_value:
                         emit_info(
-                            f"  {var}: [green]Already set[/green]",
+                            Text.from_markup(f"  {var}: [green]Already set[/green]"),
                             message_group=group_id,
                         )
                         env_vars[var] = current_value
@@ -189,7 +177,8 @@ class InstallCommand(MCPCommandBase):
             required_cmd_args = selected_server.get_command_line_args()
             if required_cmd_args:
                 emit_info(
-                    "\n[yellow]Command Line Arguments:[/yellow]", message_group=group_id
+                    Text.from_markup("\n[yellow]Command Line Arguments:[/yellow]"),
+                    message_group=group_id,
                 )
                 for arg_config in required_cmd_args:
                     name = arg_config.get("name", "")
@@ -221,5 +210,5 @@ class InstallCommand(MCPCommandBase):
             return False
         except Exception as e:
             logger.error(f"Error installing from catalog: {e}")
-            emit_info(f"[red]Installation error: {e}[/red]", message_group=group_id)
+            emit_error(f"Installation error: {e}", message_group=group_id)
             return False