codepp 0.0.437__py3-none-any.whl

code_puppy/command_line/mcp/test_command.py

@@ -0,0 +1,107 @@
+"""
+MCP Test Command - Tests connectivity to a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from code_puppy.messaging import emit_error, emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class TestCommand(MCPCommandBase):
+    """
+    Command handler for testing MCP server connectivity.
+
+    Tests connectivity and basic functionality of a specific MCP server.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Test connectivity to a specific MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info("Usage: /mcp test <server_name>", message_group=group_id)
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(f"Server '{server_name}' not found", message_group=group_id)
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Get managed server
+            managed_server = self.manager.get_server(server_id)
+            if not managed_server:
+                emit_info(
+                    f"Server '{server_name}' not accessible", message_group=group_id
+                )
+                return
+
+            emit_info(
+                f"🔍 Testing connectivity to server: {server_name}",
+                message_group=group_id,
+            )
+
+            # Basic connectivity test - try to get the pydantic server
+            try:
+                managed_server.get_pydantic_server()  # Test server instantiation
+                emit_info(
+                    "✓ Server instance created successfully", message_group=group_id
+                )
+
+                # Try to get server info if available
+                emit_info(
+                    f"  • Server type: {managed_server.config.type}",
+                    message_group=group_id,
+                )
+                emit_info(
+                    f"  • Server enabled: {managed_server.is_enabled()}",
+                    message_group=group_id,
+                )
+                emit_info(
+                    f"  • Server quarantined: {managed_server.is_quarantined()}",
+                    message_group=group_id,
+                )
+
+                if not managed_server.is_enabled():
+                    emit_info(
+                        "  • Server is disabled - enable it with '/mcp start'",
+                        message_group=group_id,
+                    )
+
+                if managed_server.is_quarantined():
+                    emit_info(
+                        "  • Server is quarantined - may have recent errors",
+                        message_group=group_id,
+                    )
+
+                emit_info(
+                    f"✓ Connectivity test passed for: {server_name}",
+                    message_group=group_id,
+                )
+
+            except Exception as test_error:
+                emit_info(
+                    f"✗ Connectivity test failed: {test_error}", message_group=group_id
+                )
+
+        except Exception as e:
+            logger.error(f"Error testing server '{server_name}': {e}")
+            emit_error(f"Error testing server: {e}", message_group=group_id)

code_puppy/command_line/mcp/utils.py

@@ -0,0 +1,129 @@
+"""
+MCP Command Utilities - Shared helper functions for MCP command handlers.
+
+Provides common utility functions used across multiple MCP command modules.
+"""
+
+from typing import Optional
+
+from rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
+
+
+def format_state_indicator(state: ServerState) -> Text:
+    """
+    Format a server state with appropriate color and icon.
+
+    Args:
+        state: Server state to format
+
+    Returns:
+        Rich Text object with colored state indicator
+    """
+    state_map = {
+        ServerState.RUNNING: ("✓ Run", "green"),
+        ServerState.STOPPED: ("✗ Stop", "red"),
+        ServerState.STARTING: ("↗ Start", "yellow"),
+        ServerState.STOPPING: ("↙ Stop", "yellow"),
+        ServerState.ERROR: ("⚠ Err", "red"),
+        ServerState.QUARANTINED: ("⏸ Quar", "yellow"),
+    }
+
+    display, color = state_map.get(state, ("? Unk", "dim"))
+    return Text(display, style=color)
+
+
+def format_uptime(uptime_seconds: Optional[float]) -> str:
+    """
+    Format uptime in a human-readable format.
+
+    Args:
+        uptime_seconds: Uptime in seconds, or None
+
+    Returns:
+        Formatted uptime string
+    """
+    if uptime_seconds is None or uptime_seconds <= 0:
+        return "-"
+
+    # Convert to readable format
+    if uptime_seconds < 60:
+        return f"{int(uptime_seconds)}s"
+    elif uptime_seconds < 3600:
+        minutes = int(uptime_seconds // 60)
+        seconds = int(uptime_seconds % 60)
+        return f"{minutes}m {seconds}s"
+    else:
+        hours = int(uptime_seconds // 3600)
+        minutes = int((uptime_seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"
+
+
+def find_server_id_by_name(manager, server_name: str) -> Optional[str]:
+    """
+    Find a server ID by its name.
+
+    Args:
+        manager: MCP manager instance
+        server_name: Name of the server to find
+
+    Returns:
+        Server ID if found, None otherwise
+    """
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        servers = manager.list_servers()
+        for server in servers:
+            if server.name.lower() == server_name.lower():
+                return server.id
+        return None
+    except Exception as e:
+        logger.error(f"Error finding server by name '{server_name}': {e}")
+        return None
+
+
+def suggest_similar_servers(
+    manager, server_name: str, group_id: Optional[str] = None
+) -> None:
+    """
+    Suggest similar server names when a server is not found.
+
+    Args:
+        manager: MCP manager instance
+        server_name: The server name that was not found
+        group_id: Optional message group ID for grouping related messages
+    """
+    import logging
+
+    from code_puppy.messaging import emit_info
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        servers = manager.list_servers()
+        if not servers:
+            emit_info("No servers are registered", message_group=group_id)
+            return
+
+        # Simple suggestion based on partial matching
+        suggestions = []
+        server_name_lower = server_name.lower()
+
+        for server in servers:
+            if server_name_lower in server.name.lower():
+                suggestions.append(server.name)
+
+        if suggestions:
+            emit_info(f"Did you mean: {', '.join(suggestions)}", message_group=group_id)
+        else:
+            server_names = [s.name for s in servers]
+            emit_info(
+                f"Available servers: {', '.join(server_names)}", message_group=group_id
+            )
+
+    except Exception as e:
+        logger.error(f"Error suggesting similar servers: {e}")

code_puppy/command_line/mcp/wizard_utils.py

@@ -0,0 +1,334 @@
+"""
+MCP Interactive Wizard Utilities - Shared interactive installation wizard functions.
+
+Provides interactive functionality for installing and configuring MCP servers.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info, emit_prompt
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def run_interactive_install_wizard(manager, group_id: str) -> bool:
+    """
+    Run the interactive MCP server installation wizard.
+
+    Args:
+        manager: MCP manager instance
+        group_id: Message group ID for grouping related messages
+
+    Returns:
+        True if installation was successful, False otherwise
+    """
+    try:
+        # Show welcome message
+        emit_info("🚀 MCP Server Installation Wizard", message_group=group_id)
+        emit_info(
+            "This wizard will help you install pre-configured MCP servers",
+            message_group=group_id,
+        )
+        emit_info("", message_group=group_id)
+
+        # Let user select a server
+        selected_server = interactive_server_selection(group_id)
+        if not selected_server:
+            return False
+
+        # Get custom name
+        server_name = interactive_get_server_name(selected_server, group_id)
+        if not server_name:
+            return False
+
+        # Collect environment variables and command line arguments
+        env_vars = {}
+        cmd_args = {}
+
+        # Get environment variables
+        required_env_vars = selected_server.get_environment_vars()
+        if required_env_vars:
+            emit_info(
+                Text.from_markup("\n[yellow]Required Environment Variables:[/yellow]"),
+                message_group=group_id,
+            )
+            for var in required_env_vars:
+                # Check if already set in environment
+                import os
+
+                current_value = os.environ.get(var, "")
+                if current_value:
+                    emit_info(
+                        Text.from_markup(f"  {var}: [green]Already set[/green]"),
+                        message_group=group_id,
+                    )
+                    env_vars[var] = current_value
+                else:
+                    value = emit_prompt(f"  Enter value for {var}: ").strip()
+                    if value:
+                        env_vars[var] = value
+
+        # Get command line arguments
+        required_cmd_args = selected_server.get_command_line_args()
+        if required_cmd_args:
+            emit_info(
+                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", "")
+                prompt = arg_config.get("prompt", name)
+                default = arg_config.get("default", "")
+                required = arg_config.get("required", True)
+
+                # If required or has default, prompt user
+                if required or default:
+                    arg_prompt = f"  {prompt}"
+                    if default:
+                        arg_prompt += f" [{default}]"
+                    if not required:
+                        arg_prompt += " (optional)"
+
+                    value = emit_prompt(f"{arg_prompt}: ").strip()
+                    if value:
+                        cmd_args[name] = value
+                    elif default:
+                        cmd_args[name] = default
+
+        # Configure the server
+        return interactive_configure_server(
+            manager, selected_server, server_name, group_id, env_vars, cmd_args
+        )
+
+    except ImportError:
+        emit_error("Server catalog not available", message_group=group_id)
+        return False
+    except Exception as e:
+        logger.error(f"Error in interactive wizard: {e}")
+        emit_error(f"Wizard error: {e}", message_group=group_id)
+        return False
+
+
+def interactive_server_selection(group_id: str):
+    """
+    Interactive server selection from catalog.
+
+    Returns selected server or None if cancelled.
+    """
+    # This is a simplified version - the full implementation would have
+    # category browsing, search, etc. For now, we'll just show popular servers
+    try:
+        from code_puppy.mcp_.server_registry_catalog import catalog
+
+        servers = catalog.get_popular(10)
+        if not servers:
+            emit_info("No servers available in catalog", message_group=group_id)
+            return None
+
+        emit_info("Popular MCP Servers:", message_group=group_id)
+        for i, server in enumerate(servers, 1):
+            indicators = []
+            if server.verified:
+                indicators.append("✓")
+            if server.popular:
+                indicators.append("⭐")
+
+            indicator_str = ""
+            if indicators:
+                indicator_str = " " + "".join(indicators)
+
+            emit_info(
+                f"{i:2}. {server.display_name}{indicator_str}", message_group=group_id
+            )
+            emit_info(f"    {server.description[:80]}...", message_group=group_id)
+
+        choice = emit_prompt(
+            "Enter number (1-{}) or 'q' to quit: ".format(len(servers))
+        )
+
+        if choice.lower() == "q":
+            return None
+
+        try:
+            index = int(choice) - 1
+            if 0 <= index < len(servers):
+                return servers[index]
+            else:
+                emit_error("Invalid selection", message_group=group_id)
+                return None
+        except ValueError:
+            emit_error("Invalid input", message_group=group_id)
+            return None
+
+    except Exception as e:
+        logger.error(f"Error in server selection: {e}")
+        return None
+
+
+def interactive_get_server_name(selected_server, group_id: str) -> Optional[str]:
+    """
+    Get custom server name from user.
+
+    Returns server name or None if cancelled.
+    """
+    default_name = selected_server.name
+    server_name = emit_prompt(f"Enter name for this server [{default_name}]: ").strip()
+
+    if not server_name:
+        server_name = default_name
+
+    return server_name
+
+
+def interactive_configure_server(
+    manager,
+    selected_server,
+    server_name: str,
+    group_id: str,
+    env_vars: Dict[str, Any],
+    cmd_args: Dict[str, Any],
+) -> bool:
+    """
+    Configure and install the selected server.
+
+    Returns True if successful, False otherwise.
+    """
+    try:
+        # Check if server already exists
+        from .utils import find_server_id_by_name
+
+        existing_server = find_server_id_by_name(manager, server_name)
+        if existing_server:
+            override = emit_prompt(
+                f"Server '{server_name}' already exists. Override? [y/N]: "
+            )
+            if not override.lower().startswith("y"):
+                emit_info("Installation cancelled", message_group=group_id)
+                return False
+
+        # Show confirmation
+        emit_info(f"Installing: {selected_server.display_name}", message_group=group_id)
+        emit_info(f"Name: {server_name}", message_group=group_id)
+
+        if env_vars:
+            emit_info("Environment Variables:", message_group=group_id)
+            for var, _value in env_vars.items():
+                emit_info(f"  {var}: ***", message_group=group_id)
+
+        if cmd_args:
+            emit_info("Command Line Arguments:", message_group=group_id)
+            for arg, value in cmd_args.items():
+                emit_info(f"  {arg}: {value}", message_group=group_id)
+
+        confirm = emit_prompt("Proceed with installation? [Y/n]: ")
+        if confirm.lower().startswith("n"):
+            emit_info("Installation cancelled", message_group=group_id)
+            return False
+
+        # Install the server (simplified version)
+        return install_server_from_catalog(
+            manager, selected_server, server_name, env_vars, cmd_args, group_id
+        )
+
+    except Exception as e:
+        logger.error(f"Error configuring server: {e}")
+        emit_error(f"Configuration error: {e}", message_group=group_id)
+        return False
+
+
+def install_server_from_catalog(
+    manager,
+    selected_server,
+    server_name: str,
+    env_vars: Dict[str, Any],
+    cmd_args: Dict[str, Any],
+    group_id: str,
+) -> bool:
+    """
+    Install a server from the catalog with the given configuration.
+
+    Returns True if successful, False otherwise.
+    """
+    try:
+        import json
+        import os
+
+        from code_puppy.config import MCP_SERVERS_FILE
+        from code_puppy.mcp_.managed_server import ServerConfig
+
+        # Set environment variables in the current environment
+        for var, value in env_vars.items():
+            os.environ[var] = value
+
+        # Get server config with command line argument overrides
+        config_dict = selected_server.to_server_config(server_name, **cmd_args)
+
+        # Update the config with actual environment variable values
+        if "env" in config_dict:
+            for env_key, env_value in config_dict["env"].items():
+                # If it's a placeholder like $GITHUB_TOKEN, replace with actual value
+                if env_value.startswith("$"):
+                    var_name = env_value[1:]  # Remove the $
+                    if var_name in env_vars:
+                        config_dict["env"][env_key] = env_vars[var_name]
+
+        # Create ServerConfig
+        server_config = ServerConfig(
+            id=server_name,
+            name=server_name,
+            type=selected_server.type,
+            enabled=True,
+            config=config_dict,
+        )
+
+        # Register with manager
+        server_id = manager.register_server(server_config)
+
+        if not server_id:
+            emit_info(
+                "Failed to register server with manager",
+                message_group=group_id,
+            )
+            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
+        # Copy the config dict and add type before saving
+        save_config = config_dict.copy()
+        save_config["type"] = selected_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_info(
+            Text.from_markup(
+                f"[green]✓ Successfully installed server: {server_name}[/green]"
+            ),
+            message_group=group_id,
+        )
+        emit_info(
+            "Use '/mcp start {}' to start the server".format(server_name),
+            message_group=group_id,
+        )
+
+        return True
+
+    except Exception as e:
+        logger.error(f"Error installing server: {e}")
+        emit_error(f"Installation failed: {e}", message_group=group_id)
+        return False