py-mcpdock-cli 1.0.13__py3-none-any.whl

cli/runners/ws_runner.py

@@ -0,0 +1,43 @@
+"""
+WebSocket Runner implementation for remote MCP servers
+"""
+import json
+import asyncio
+import signal
+import sys
+from typing import Dict, Any, Optional
+
+from rich import print as rprint
+
+from ..utils.logger import verbose
+
+
+async def create_ws_runner(
+    deployment_url: str,
+    config: Dict[str, Any],
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Creates a WebSocket runner for connecting to a remote server.
+    This is a placeholder function that will be connected to a real implementation.
+    """
+    verbose(f"Starting WebSocket runner: {deployment_url}")
+    rprint(f"[green]WebSocket connection successful: {deployment_url}[/green]")
+    rprint(f"Configuration: {json.dumps(config, indent=2)}")
+    rprint("Press Ctrl+C to stop the connection")
+
+    # Setup signal handling for graceful shutdown
+    def handle_sigint(sig, frame):
+        rprint("[yellow]Received stop signal, closing connection...[/yellow]")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, handle_sigint)
+
+    # Keep the process running (equivalent to the Promise in JS)
+    try:
+        # This is a simple placeholder that keeps the process running
+        # In a real implementation, this would be replaced with actual connection logic
+        while True:
+            await asyncio.sleep(1)
+    except asyncio.CancelledError:
+        rprint("[yellow]WebSocket connection cancelled.[/yellow]")

cli/types/registry.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+
+# Using dataclasses for structured type definitions
+
+
+@dataclass
+class ConfigSchemaProperty:
+    # Represents a single property within the configSchema
+    # Using Any for now, can be refined if specific property types are known
+    type: Optional[str] = None
+    description: Optional[str] = None
+    default: Any = None
+    # Add other potential schema attributes if needed
+
+
+@dataclass
+class ConfigSchema:
+    env: Dict[str, ConfigSchemaProperty] = field(default_factory=dict)
+    required: List[str] = field(default_factory=list)
+    args: Optional[List[str]] = None
+
+
+@dataclass
+class ConnectionDetails:
+    type: str
+    stdioFunction: Optional[List[str]] = None
+    deploymentUrl: Optional[str] = None
+    published: Optional[bool] = None
+    configSchema: Optional[ConfigSchema] = None  # Use the nested dataclass
+
+
+@dataclass
+class ConfiguredServer:
+    command: str
+    args: List[str]
+    env: Optional[Dict[str, str]] = None
+
+
+@dataclass
+class MCPConfig:
+    # Represents the overall configuration structure potentially saved
+    mcpServers: Dict[str, ConfiguredServer] = field(default_factory=dict)
+
+
+@dataclass
+class ServerConfig:
+    # Represents the configuration *for* a specific server instance
+    # Using a general dict for extra keys corresponding to `[key: string]: unknown`
+    qualifiedName: str
+    connections: List[ConnectionDetails]
+    remote: Optional[bool] = None
+    additional_config: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ClientConfig:
+    # Represents the client-side configuration (e.g., installed servers)
+    # Using Dict[str, Any] for flexibility as the TS type was Record<string, unknown>
+    mcpServers: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class RegistryServer:
+    # Represents a server as listed in a registry
+    qualifiedName: str
+    connections: List[ConnectionDetails]
+    displayName: Optional[str] = None
+    remote: Optional[bool] = None

cli/utils/config.py

@@ -0,0 +1,441 @@
+import json
+import questionary
+from rich import print as rprint
+from typing import Any, Dict, List, Optional, Set, Tuple, TypeVar
+
+# Import proper types from registry module
+from ..types.registry import (
+    ConnectionDetails, RegistryServer,
+    ServerConfig, ConfiguredServer, ConfigSchemaProperty
+)
+
+
+def convert_value_to_type(value: Any, type_str: Optional[str]) -> Any:
+    """Converts a value to the specified type string."""
+    if not type_str:
+        return value
+
+    def invalid(expected: str):
+        raise ValueError(f"Invalid {expected} value: {json.dumps(value)}")
+
+    try:
+        if type_str == "boolean":
+            str_val = str(value).lower()
+            if str_val == "true":
+                return True
+            if str_val == "false":
+                return False
+            invalid("boolean")
+        elif type_str == "number":
+            return float(value)
+        elif type_str == "integer":
+            return int(value)
+        elif type_str == "string":
+            return str(value)
+        elif type_str == "array":
+            if isinstance(value, list):
+                return value
+            return [v.strip() for v in str(value).split(",")]
+        else:
+            return value
+    except (ValueError, TypeError):
+        invalid(type_str)
+
+
+def format_config_values(
+    connection: ConnectionDetails,
+    config_values: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Formats and validates config values based on the connection's schema."""
+    formatted_values: Dict[str, Any] = {}
+    missing_required: List[str] = []
+    config_values = config_values or {}
+
+    schema = connection.configSchema or {}
+    env = schema.env if schema else {}
+    if not env:
+        return config_values
+
+    required: Set[str] = set(schema.required if schema else [])
+
+    for property_name, prop_details in env.items():
+        value = config_values.get(property_name)
+        prop_type = prop_details.type
+
+        if value is None:
+            if property_name in required:
+                missing_required.append(property_name)
+            else:
+                formatted_values[property_name] = prop_details.default
+        else:
+            try:
+                formatted_values[property_name] = convert_value_to_type(value, prop_type)
+            except ValueError as e:
+                # If conversion fails but it's not required, set to default or None
+                if property_name not in required:
+                    formatted_values[property_name] = prop_details.default
+                else:
+                    # Re-raise or handle error if conversion fails for a required field
+                    # For now, let's add to missing required to indicate an issue
+                    print(f"Warning: Could not convert required value for {property_name}: {e}")
+                    missing_required.append(f"{property_name} (invalid format)")
+
+    if missing_required:
+        raise ValueError(
+            f"Missing or invalid required config values: {', '.join(missing_required)}"
+        )
+
+    return formatted_values
+
+
+def validate_config(
+    connection: ConnectionDetails,
+    saved_config: Optional[Dict[str, Any]] = None,
+) -> Tuple[bool, Optional[Dict[str, Any]]]:
+    """Validates saved config against the connection schema."""
+    schema = connection.configSchema or {}
+    env = schema.env if schema else {}
+    if not env:
+        return True, {}
+
+    saved_config = saved_config or {}
+
+    try:
+        formatted_config = format_config_values(connection, saved_config)
+        required = set(schema.required if schema else [])
+        has_all_required = all(
+            key in formatted_config and formatted_config[key] is not None
+            for key in required
+        )
+        return has_all_required, formatted_config
+    except ValueError:
+        # Attempt to return partially valid config if formatting fails
+        try:
+            partial_config = {
+                k: v for k, v in saved_config.items() if v is not None
+            }
+            # Check if the partial config *still* satisfies required fields *that are present*
+            # This is tricky, maybe just return False and the original partial config
+            return False, partial_config
+        except Exception:
+            return False, None
+
+
+async def prompt_for_config_value(
+    key: str,
+    schema_prop: ConfigSchemaProperty,
+    required: Set[str],
+) -> Any:
+    """Prompts the user for a single config value based on schema property."""
+    is_required = key in required
+    required_text = " [red](required)[/red]" if is_required else " (optional)"
+    message = f"{schema_prop.description or f'Enter value for {key}'}{required_text}"
+    prop_type = schema_prop.type
+    default_value = schema_prop.default
+
+    # Determine questionary prompt type
+    if key.lower().endswith("key") or key.lower().endswith("secret") or key.lower().endswith("token"):
+        prompt_method = questionary.password
+    elif prop_type == "boolean":
+        prompt_method = questionary.confirm
+        # questionary confirm default needs bool or None
+        if default_value is not None:
+            default_value = str(default_value).lower() == 'true'
+        else:
+            default_value = None  # Or False if you prefer
+    elif prop_type == "number" or prop_type == "integer":
+        # Using text prompt with validation for numbers
+        prompt_method = questionary.text
+    elif prop_type == "array":
+        message += " (comma-separated)"
+        prompt_method = questionary.text
+    else:
+        prompt_method = questionary.text
+
+    # Validation function
+    def validate_input(text: str) -> bool | str:
+        if is_required and not text:
+            return "This field is required."
+        if prop_type == "number" or prop_type == "integer":
+            try:
+                if prop_type == "integer":
+                    int(text)
+                else:
+                    float(text)
+                return True
+            except ValueError:
+                return "Please enter a valid number."
+        return True
+
+    # Use appropriate prompt method
+    if prompt_method == questionary.confirm:
+        # Handle confirm separately as it doesn't take validate
+        # Note: questionary.confirm returns True/False directly
+        # We need to handle the case where the user might skip an optional confirm
+        # For simplicity, let's assume confirm always gets an answer if prompted
+        answer = await prompt_method(message, default=default_value).ask_async()
+        # If it's required and they somehow skip (e.g., Ctrl+C), handle appropriately
+        if is_required and answer is None:
+            rprint("[bold red]Required field cannot be skipped.[/bold red]")
+            # Re-prompt or exit - for now, return None which might fail later validation
+            return None
+        return answer
+    else:
+        # For text, password
+        q = prompt_method(
+            message,
+            default=str(default_value) if default_value is not None else "",
+            validate=validate_input
+        )
+        result = await q.ask_async()
+        if result is None and is_required:
+            rprint("[bold red]Required field cannot be skipped.[/bold red]")
+            return None  # Or raise an error / re-prompt
+        # Convert back if needed (e.g., for numbers, arrays)
+        if result is not None:
+            try:
+                return convert_value_to_type(result, prop_type)
+            except ValueError:
+                rprint(
+                    f"[yellow]Warning: Could not convert input '{result}' to type '{prop_type}'. Using raw input.[/yellow]")
+                return result  # Return raw input if conversion fails after prompt
+        return result  # Return None if skipped (and not required)
+
+
+async def collect_config_values(
+    connection: ConnectionDetails,
+    existing_values: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Collects config values from existing values or user prompts."""
+    schema = connection.configSchema or {}
+    env = schema.env if schema else {}
+    if not env:
+        return {}
+
+    base_config: Dict[str, Any] = {}
+
+    # Validate existing values first
+    if existing_values:
+        is_valid, validated_config = validate_config(connection, existing_values)
+        if is_valid and validated_config is not None:
+            return validated_config
+        # Use partially validated config as base if validation failed
+        base_config = validated_config or {}
+
+    required = set(schema.required if schema else [])
+
+    rprint("[bold blue]Please provide the following configuration values:[/bold blue]")
+
+    for key, prop_details in env.items():
+        # Skip if value already exists and is not None in the base_config
+        if key in base_config and base_config[key] is not None:
+            continue
+
+        # Prompt if missing
+        value = await prompt_for_config_value(key, prop_details, required)
+
+        # Handle skipped required fields after prompt
+        if value is None and key in required:
+            # This case should ideally be handled within prompt_for_config_value
+            # but as a fallback:
+            rprint(f"[bold red]Error: Required configuration '{key}' was not provided.[/bold red]")
+            raise ValueError(f"Missing required configuration: {key}")
+
+        # Assign even if None (for optional fields skipped)
+        base_config[key] = value
+
+    # Final format and validation after collecting all values
+    try:
+        return format_config_values(connection, base_config)
+    except ValueError as e:
+        rprint(f"[bold red]Configuration error:[/bold red] {e}")
+        # Return the collected (potentially incomplete/invalid) config
+        # or raise the error depending on desired strictness
+        return base_config
+
+
+def choose_stdio_connection(connections: List[ConnectionDetails]) -> Optional[ConnectionDetails]:
+    """Chooses the best stdio connection from a list based on priority."""
+    stdio_connections = [conn for conn in connections if conn.type == "stdio"]
+    if not stdio_connections:
+        return None
+
+    priority_order = ["npx", "uvx", "docker"]  # Assuming similar priority in Python context
+
+    # Prioritize published connections first
+    for priority in priority_order:
+        for conn in stdio_connections:
+            stdio_func = conn.stdioFunction
+            if (
+                conn.published
+                and isinstance(stdio_func, list)
+                and stdio_func
+                and isinstance(stdio_func[0], str)
+                and stdio_func[0].startswith(priority)
+            ):
+                return conn
+
+    # If no published connection found, check non-published
+    for priority in priority_order:
+        for conn in stdio_connections:
+            stdio_func = conn.stdioFunction
+            if (
+                isinstance(stdio_func, list)
+                and stdio_func
+                and isinstance(stdio_func[0], str)
+                and stdio_func[0].startswith(priority)
+            ):
+                return conn
+
+    # Fallback to the first stdio connection if no priority match
+    return stdio_connections[0]
+
+
+def choose_connection(server: RegistryServer) -> ConnectionDetails:
+    """Chooses the most suitable connection for a server."""
+    connections = server.connections  # Directly access the dataclass attribute
+    if not connections:
+        raise ValueError(f"No connection configurations found for server {server.qualifiedName}")
+
+    # Prefer stdio for local servers if available
+    if not server.remote:  # Directly access the dataclass attribute
+        stdio_connection = choose_stdio_connection(connections)
+        if stdio_connection:
+            return stdio_connection
+
+    # Otherwise, look for WebSocket (ws) connection
+    ws_connection = next((conn for conn in connections if conn.type == "ws"), None)
+    if ws_connection:
+        return ws_connection
+
+    # Fallback: try stdio again (even for remote, if ws wasn't found)
+    stdio_connection = choose_stdio_connection(connections)
+    if stdio_connection:
+        return stdio_connection
+
+    # Final fallback: return the first connection whatever it is
+    return connections[0]
+
+
+def normalize_server_id(server_id: str) -> str:
+    """Normalizes server ID by replacing the first slash after '@' with a dash."""
+    if server_id.startswith("@"):
+        parts = server_id.split("/", 1)
+        if len(parts) == 2:
+            return f"{parts[0]}-{parts[1]}"
+    return server_id
+
+
+def denormalize_server_id(normalized_id: str) -> str:
+    """Converts a normalized server ID back to its original form (with slash)."""
+    if normalized_id.startswith("@"):
+        parts = normalized_id.split("-", 1)  # Split only on the first dash
+        # Check if the first part looks like a scope (@scope)
+        if len(parts) == 2 and parts[0].startswith("@") and "/" not in parts[0]:
+            return f"{parts[0]}/{parts[1]}"
+    return normalized_id
+
+
+def get_server_name(server_id: str) -> str:
+    """Extracts the server name part from a potentially scoped server ID."""
+    if server_id.startswith("@") and "/" in server_id:
+        return server_id.split("/", 1)[1]
+    return server_id
+
+
+def format_run_config_values(
+    connection: ConnectionDetails,
+    config_values: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Formats config values specifically for the 'run' command,
+       allowing empty strings for missing required fields."""
+    formatted_values: Dict[str, Any] = {}
+    config_values = config_values or {}
+
+    schema = connection.configSchema or {}
+    env = schema.env if schema else {}
+    if not env:
+        return config_values
+
+    required: Set[str] = set(schema.required if schema else [])
+
+    for key, prop_details in env.items():
+        value = config_values.get(key)
+        prop_type = prop_details.type
+        final_value: Any
+
+        if value is not None:
+            final_value = value
+        elif key not in required:
+            final_value = prop_details.default
+        else:
+            # Key is required but value is missing: use empty string
+            final_value = ""
+
+        # Handle cases where even the default might be None
+        if final_value is None:
+            # If required use empty string, otherwise None is acceptable for optional
+            formatted_values[key] = "" if key in required else None
+            continue
+
+        try:
+            formatted_values[key] = convert_value_to_type(final_value, prop_type)
+        except ValueError:
+            # If conversion fails, use empty string if required, None otherwise
+            formatted_values[key] = "" if key in required else None
+
+    return formatted_values
+
+# Implementation for formatServerConfig with proxy command support
+
+
+def format_server_config(
+    qualified_name: str,
+    user_config: Dict[str, Any],
+    api_key: Optional[str] = None,
+    config_needed: bool = True,
+) -> ConfiguredServer:
+    """
+    Formats server config into a command structure with proxy command support.
+
+    Args:
+        qualified_name: The package identifier (被代理的命令标识)
+        user_config: User configuration values
+        api_key: Optional API key
+        config_needed: Whether config flag is needed
+
+    Returns:
+        ConfiguredServer instance with command and args and env
+    """
+    # 固定使用 uv 命令，因为代理是用 Python 写的
+    command = "uv"  # 固定使用 uv 作为 Python 包管理器
+    proxy_package = "@mcpspace/proxy"  # 默认代理包
+
+    # 构建参数列表
+    args = ["-y"]
+
+    # 添加代理包标识符
+    args.append(proxy_package)
+
+    # 添加 run 命令
+    args.append("run")
+
+    # 添加实际的包标识符（被代理的命令）
+    args.append(qualified_name)
+
+    # 添加配置（如果需要）
+    # if config_needed and user_config:
+    #     args.append("--config")
+    #     args.append(json.dumps(user_config))
+
+    # 添加 API 密钥（如果有提供）
+    if api_key:
+        args.append("--api-key")
+        args.append(api_key)
+
+    # env = user_config.get("env", {})  # Extract 'env' from user_config if available
+    return ConfiguredServer(
+        command=command,
+        args=args,
+        env=user_config
+    )

cli/utils/logger.py

@@ -0,0 +1,79 @@
+import logging
+import os
+from datetime import datetime
+from pathlib import Path
+from ..config.app_config import APP_ENV
+
+# Get project root directory
+
+
+def get_project_root():
+    current_path = Path(__file__).resolve()
+    for parent in current_path.parents:
+        if parent.name == 'cli':
+            return parent
+    return current_path.parents[2]  # Fallback to 2 levels up from logger.py
+
+
+ROOT_DIR = get_project_root()
+
+# Set date format
+date = datetime.now()
+date_str = f"{date.year}-{date.month}-{date.day}"
+
+
+def create_dir_if_not_exist(dir_name: str):
+    """Create directory if it doesn't exist"""
+    dir_path = os.path.join(ROOT_DIR, dir_name)
+    if not os.path.exists(dir_path):
+        os.makedirs(dir_path, exist_ok=True)
+
+
+# Define log formatter
+class CustomFormatter(logging.Formatter):
+    def __init__(self, worker_id: str = 'main'):
+        super().__init__(fmt='[%(levelname)s] - [%(asctime)s] [%(worker_id)s] %(message)s',
+                         datefmt='%Y-%m-%d %H:%M:%S.%f')
+        self.worker_id = worker_id
+
+    def format(self, record):
+        record.worker_id = self.worker_id
+        return super().format(record)
+
+
+# Create logs directory
+create_dir_if_not_exist('logs')
+create_dir_if_not_exist('logs/cli')
+
+# Create CLI Logger
+cli_logger = logging.getLogger('cli_logger')
+cli_logger.setLevel(logging.DEBUG)
+
+# Prevent duplicate logs if logger is imported multiple times
+if not cli_logger.handlers:
+    # File handler
+    cli_log_file = os.path.join(ROOT_DIR, f'logs/cli/{date_str}.log')
+    fh_cli = logging.FileHandler(cli_log_file, encoding='utf-8')
+    fh_cli.setLevel(logging.DEBUG)
+    fh_cli.setFormatter(CustomFormatter())
+    cli_logger.addHandler(fh_cli)
+
+    # Console handler: 仅在开发环境或DEBUG_STDIO_RUNNER=1时输出到终端
+    # if APP_ENV == "dev":
+    ch_cli = logging.StreamHandler()
+    ch_cli.setLevel(logging.DEBUG)
+    ch_cli.setFormatter(CustomFormatter())
+    cli_logger.addHandler(ch_cli)
+
+
+def verbose(message: str) -> None:
+    """Logs a verbose message to both file and console (if INFO level)"""
+    cli_logger.debug(message)
+
+
+# For compatibility with existing code
+debug = cli_logger.debug
+info = cli_logger.info
+warning = cli_logger.warning
+error = cli_logger.error
+critical = cli_logger.critical