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

cli/commands/install.py

@@ -0,0 +1,182 @@
+import click
+import json
+import asyncio
+from typing import Dict, Any, Optional
+
+from rich import print as rprint
+from rich.console import Console
+from rich.spinner import Spinner
+
+from ..utils.logger import verbose, info, debug, error, warning
+from ..registry import resolve_package
+from ..utils.runtime import ensure_uv_installed, ensure_bun_installed, check_and_notify_remote_server
+from ..utils.config import choose_connection, collect_config_values, get_server_name, format_server_config, format_config_values
+from ..config.client_config import read_config, write_config
+from ..types.registry import ConfiguredServer, ClientConfig
+
+
+async def validate_config_values(
+    connection: Any,
+    existing_values: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Validates config values without prompting for user input.
+    Only checks if required values are present.
+
+    Args:
+        connection: Connection details containing schema
+        existing_values: Existing config values to validate
+
+    Returns:
+        Dictionary with validated config values
+
+    Raises:
+        ValueError: If required configuration values are missing
+    """
+    schema = connection.configSchema or {}
+    env = schema.env if schema else {}
+    if not env:
+        return {}
+
+    # Use existing values or empty dict
+    config_values = existing_values or {}
+
+    # Get list of required env variables
+    required = set(schema.required if schema else [])
+
+    # Check if all required env variables are provided
+    missing_required = []
+    for key in required:
+        if key not in config_values or config_values[key] is None:
+            missing_required.append(key)
+
+    # Raise error if any required env variables are missing
+    if missing_required:
+        missing_fields = ", ".join(missing_required)
+        raise ValueError(f"Missing required configuration values: {missing_fields}")
+
+    # Format and return the validated config
+    return format_config_values(connection, config_values)
+
+
+async def install_mcp_server(
+    package_identifier: str,
+    target_client: Optional[str] = None,
+    initial_config: Optional[Dict[str, Any]] = None,
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Installs and configures an AI server package for a specified client.
+
+    Args:
+        package_identifier: The fully qualified name of the AI server package
+        target_client: The AI client to configure the server for
+        initial_config: Optional pre-defined configuration values
+        api_key: Optional API key for fetching saved configurations
+    """
+    target_client = target_client or "claude"  # Default to Claude if no client specified
+    verbose(f"Initiating installation of {package_identifier} for {target_client}")
+
+    console = Console()
+
+    # Create and start spinner for package resolution
+    with console.status(f"Resolving {package_identifier}...", spinner="dots") as status:
+        try:
+            # Resolve the package (fetch server metadata)
+            verbose(f"Resolving package: {package_identifier}")
+            server_data = await resolve_package(package_identifier)
+            verbose(f"Package resolved successfully: {server_data.qualifiedName}")
+
+            # Choose the appropriate connection type
+            verbose("Choosing connection type...")
+            connection = choose_connection(server_data)
+            verbose(f"Selected connection type: {connection.type}")
+
+            # Check for required runtimes and install if needed
+            # Commented out as these are specific to JS environment
+            # await ensure_uv_installed(connection)
+            # await ensure_bun_installed(connection)
+
+            # Inform users of remote server installation if applicable
+            is_remote = check_and_notify_remote_server(server_data)
+            if is_remote:
+                verbose("Remote server detected, notification displayed")
+
+            # Get the validated config values, no prompting
+            status.update(f"Validating configuration for {package_identifier}...")
+            collected_config_values = await validate_config_values(connection, initial_config)
+
+            # Determine if we need to pass config flag
+            config_flag_needed = initial_config is not None
+
+            verbose(f"Config values validated: {json.dumps(collected_config_values, indent=2)}")
+            verbose(f"Using config flag: {config_flag_needed}")
+
+            # Format the server configuration
+            verbose("Formatting server configuration...")
+            server_config = format_server_config(
+                package_identifier,
+                collected_config_values,
+                api_key,
+                config_flag_needed,
+            )
+            verbose(f"Formatted server config: {json.dumps(server_config.__dict__, indent=2)}")
+
+            # Read existing config from client
+            status.update(f"Installing for {target_client}...")
+            verbose(f"Reading configuration for client: {target_client}")
+            client_config = read_config(target_client)
+
+            # Get normalized server name to use as key
+            server_name = get_server_name(package_identifier)
+            verbose(f"Normalized server ID: {server_name}")
+
+            # Update client configuration with new server
+            verbose("Updating client configuration...")
+            if not isinstance(client_config.mcpServers, dict):
+                # Initialize if needed
+                client_config.mcpServers = {}
+
+            # Add the new server config
+            client_config.mcpServers[server_name] = server_config
+
+            # Write updated configuration
+            verbose("Writing updated configuration...")
+            write_config(client_config, target_client)
+            verbose("Configuration successfully written")
+
+            rprint(f"[green]{package_identifier} successfully installed for {target_client}[/green]")
+
+            # No prompt for client restart
+            verbose("Installation completed successfully")
+
+        except Exception as e:
+            verbose(f"Installation error: {str(e)}")
+            rprint(f"[red]Failed to install {package_identifier}[/red]")
+            rprint(f"[red]Error: {str(e)}[/red]")
+            raise
+
+
+@click.command("install")
+@click.argument("mcp_server", type=click.STRING)
+@click.option("--client", type=click.STRING, help="Specify the target AI client")
+@click.option("--env", "env_json", type=click.STRING, help="Provide configuration as JSON (bypasses interactive prompts)")
+@click.option("--api-key", type=click.STRING, help="Provide an API key for fetching saved configurations")
+def install(mcp_server: str, client: Optional[str], env_json: Optional[str], api_key: Optional[str]):
+    """Install an AI mcp-server with optional configuration."""
+    click.echo(f"Attempting to install {mcp_server}...")
+    user_config = None
+    if env_json:
+        try:
+            user_config = json.loads(env_json)
+            click.echo(f"Using provided config: {user_config}")
+        except json.JSONDecodeError as e:
+            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            return
+
+    try:
+        # Run the async installation process
+        asyncio.run(install_mcp_server(mcp_server, client, user_config, api_key))
+    except Exception as e:
+        click.echo(f"Installation failed: {str(e)}", err=True)
+        return 1

cli/commands/run.py

@@ -0,0 +1,148 @@
+import click
+import json
+import asyncio
+from typing import Dict, Any, Optional
+
+from rich import print as rprint
+from rich.console import Console
+
+from ..utils.logger import verbose
+from ..registry import resolve_package
+from ..utils.config import choose_connection, format_run_config_values
+from ..utils.runtime import check_and_notify_remote_server
+from ..types.registry import RegistryServer, ConnectionDetails
+from ..runners import create_stdio_runner, create_ws_runner, run_package_with_command, create_stream_http_runner
+
+
+# These runner functions have been moved to their respective modules in the runners package
+
+async def pick_server_and_run(
+    server_details: RegistryServer,
+    config: Dict[str, Any],
+    api_key: Optional[str] = None,
+    analytics_enabled: bool = False
+) -> None:
+    """
+    Selects the appropriate runner and starts the server.
+    """
+    connection = choose_connection(server_details)
+
+    if connection.type == "ws":
+        if not connection.deploymentUrl:
+            raise ValueError("Missing deployment URL")
+        await create_ws_runner(connection.deploymentUrl, config, api_key)
+    elif connection.type == "stdio":
+        await create_stdio_runner(server_details, config, api_key, analytics_enabled)
+    elif connection.type == "stream-http":
+        await create_stream_http_runner(server_details, config, api_key, analytics_enabled)
+    else:
+        raise ValueError(f"Unsupported connection type: {connection.type}")
+
+
+async def run_server(
+    qualified_name: str,
+    config: Dict[str, Any],
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Runs a server with the specified configuration.
+
+    The qualified_name can be in these formats:
+    - Standard MCP server name: "company/package"
+    - uv command: "uv:package_name [args]" 
+    - npx command: "npx:package_name [args]"
+    """
+    try:
+        # # Check if this is a special command format (uv: or npx:)
+        # if qualified_name.startswith("uv:") or qualified_name.startswith("npx:"):
+        #     command_parts = qualified_name.split(":", 1)
+        #     command_type = command_parts[0].lower()
+        #     package_spec = command_parts[1]
+
+        #     # Extract package name and args if provided
+        #     package_parts = package_spec.split(" ", 1)
+        #     package_name = package_parts[0]
+        #     args = package_parts[1].split() if len(package_parts) > 1 else []
+
+        #     verbose(f"Running {command_type} command for package: {package_name}")
+        #     await run_package_with_command(
+        #         command_type,
+        #         package_name,
+        #         args,
+        #         config,
+        #         api_key
+        #     )
+        #     return
+
+        # Initialize settings for regular MCP server
+        verbose("Initializing runtime environment settings")
+
+        # Resolve server package
+        verbose(f"Resolving server package: {qualified_name}")
+        resolved_server = await resolve_package(qualified_name)
+
+        if not resolved_server:
+            raise ValueError(f"Could not resolve server: {qualified_name}")
+
+        # Format the final configuration with validation
+        connection = choose_connection(resolved_server)
+        final_config = format_run_config_values(connection, config)
+
+        # Inform about remote server if applicable
+        # check_and_notify_remote_server(resolved_server)
+
+        rprint(f"[blue][Runner] Connecting to server:[/blue] {resolved_server.qualifiedName}")
+        rprint(f"Connection types: {[c.type for c in resolved_server.connections]}")
+
+        # Assume analytics is disabled for now
+        analytics_enabled = False
+
+        # Run the server with the appropriate runner
+        await pick_server_and_run(
+            resolved_server,
+            final_config,
+            api_key,
+            analytics_enabled
+        )
+    except Exception as e:
+        rprint(f"[red][Runner] Fatal error:[/red] {str(e)}")
+        raise
+
+
+@click.command("run")
+@click.argument("mcp_server", type=click.STRING)
+@click.option("--config", "config_json", type=click.STRING, help="Provide JSON format configuration")
+@click.option("--api-key", type=click.STRING, help="API key for retrieving saved configuration")
+def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
+    """Run an AI MCP server."""
+    click.echo(f"Attempting to run {mcp_server}...")
+    server_config = None
+
+    # Parse command line provided configuration
+    if config_json:
+        try:
+            server_config = json.loads(config_json)
+            click.echo(f"Using provided config: {server_config}")
+        except json.JSONDecodeError as e:
+            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            return 1
+
+    # If no config provided, use empty dict
+    if server_config is None:
+        verbose("No config provided, running with empty config")
+        server_config = {}
+
+    if api_key:
+        verbose(f"API key provided: {'*' * len(api_key)}")
+
+    console = Console()
+
+    try:
+        # with console.status(f"Starting {mcp_server}...", spinner="dots") as status:
+        # Run the server asynchronously
+        verbose('running server....')
+        asyncio.run(run_server(mcp_server, server_config, api_key))
+        # status.update(f"Successfully started {mcp_server}")
+    except Exception as e:
+        click.echo(f"Run failed: {str(e)}", err=True)
+        return 1

cli/config/app_config.py

@@ -0,0 +1,11 @@
+# config/app_config.py
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from a .env file
+load_dotenv()
+
+
+APP_NAME = os.getenv("APP_NAME", "My Application")
+APP_VERSION = os.getenv("APP_VERSION", "1.0.0")
+APP_ENV = os.getenv('ENV')

cli/config/client_config.py

@@ -0,0 +1,248 @@
+import os
+import json
+import sys
+import subprocess
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Union, Literal, TypedDict
+
+# Import types from the registry module
+from ..types.registry import ClientConfig, ConfiguredServer
+# Import logger
+from ..utils.logger import verbose
+
+# Define types for configuration targets
+
+
+class ClientFileTarget(TypedDict):
+    type: Literal["file"]
+    path: Path
+
+
+class ClientCommandTarget(TypedDict):
+    type: Literal["command"]
+    command: str
+    # Potentially add args template if needed later
+
+
+ClientInstallTarget = Union[ClientFileTarget, ClientCommandTarget]
+
+# Determine platform-specific paths using pathlib
+home_dir = Path.home()
+
+if sys.platform == "win32":
+    base_dir = Path(os.environ.get("APPDATA", home_dir / "AppData" / "Roaming"))
+    vscode_storage_path = Path("Code") / "User" / "globalStorage"
+    code_command = "code.cmd"
+    code_insiders_command = "code-insiders.cmd"
+elif sys.platform == "darwin":
+    base_dir = home_dir / "Library" / "Application Support"
+    vscode_storage_path = Path("Code") / "User" / "globalStorage"
+    code_command = "code"
+    code_insiders_command = "code-insiders"
+else:  # Assume Linux/other Unix-like
+    base_dir = Path(os.environ.get("XDG_CONFIG_HOME", home_dir / ".config"))
+    vscode_storage_path = Path("Code/User/globalStorage")  # Note: Path combines these
+    code_command = "code"
+    code_insiders_command = "code-insiders"
+
+default_claude_path = base_dir / "Claude" / "claude_desktop_config.json"
+
+# Define client paths using platform-specific base directories
+# Using lowercase keys for normalization
+CLIENT_PATHS: Dict[str, ClientInstallTarget] = {
+    "claude": {"type": "file", "path": default_claude_path},
+    "cline": {
+        "type": "file",
+        "path": base_dir / vscode_storage_path / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+    },
+    "roo-cline": {
+        "type": "file",
+        "path": base_dir / vscode_storage_path / "rooveterinaryinc.roo-cline" / "settings" / "cline_mcp_settings.json",
+    },
+    "windsurf": {"type": "file", "path": home_dir / ".codeium" / "windsurf" / "mcp_config.json"},
+    "witsy": {"type": "file", "path": base_dir / "Witsy" / "settings.json"},
+    "enconvo": {"type": "file", "path": home_dir / ".config" / "enconvo" / "mcp_config.json"},
+    "cursor": {"type": "file", "path": home_dir / ".cursor" / "mcp.json"},
+    "vscode": {"type": "command", "command": code_command},
+    "vscode-insiders": {"type": "command", "command": code_insiders_command},
+}
+
+
+def get_config_target(client: Optional[str] = None) -> ClientInstallTarget:
+    """Gets the configuration target (file path or command) for a given client."""
+    normalized_client = (client or "claude").lower()
+    verbose(f"Getting config target for client: {normalized_client}")
+
+    target = CLIENT_PATHS.get(normalized_client)
+
+    if target:
+        verbose(f"Config target resolved to: {target}")
+        return target
+    else:
+        # Fallback for unknown clients (similar to JS version)
+        fallback_path = default_claude_path.parent.parent / (client or "claude") / f"{normalized_client}_config.json"
+        fallback_target: ClientFileTarget = {"type": "file", "path": fallback_path}
+        verbose(f"Client '{normalized_client}' not predefined, using fallback path: {fallback_target}")
+        return fallback_target
+
+
+def read_config(client: Optional[str] = None) -> ClientConfig:
+    """Reads the configuration for the specified client."""
+    client_name = (client or "claude").lower()
+    verbose(f"Reading config for client: {client_name}")
+    target = get_config_target(client_name)
+
+    if target["type"] == "command":
+        verbose(f"Client '{client_name}' uses command-based config. Reading not supported.")
+        # Command-based installers don't support reading config back easily
+        return ClientConfig(mcpServers={})
+
+    config_path = target["path"]
+    verbose(f"Checking if config file exists at: {config_path}")
+    if not config_path.exists():
+        verbose("Config file not found, returning default empty config.")
+        return ClientConfig(mcpServers={})
+
+    try:
+        verbose("Reading config file content.")
+        raw_content = config_path.read_text(encoding="utf-8")
+        raw_config = json.loads(raw_content)
+        verbose(f"Config loaded successfully: {json.dumps(raw_config, indent=2)}")
+
+        # Ensure mcpServers key exists, return as ClientConfig object
+        mcp_servers_data = raw_config.get("mcpServers", {})
+        # Basic validation/conversion if needed, assuming structure matches ConfiguredServer for now
+        configured_servers = {
+            name: ConfiguredServer(**server_data)
+            for name, server_data in mcp_servers_data.items()
+            if isinstance(server_data, dict) and "command" in server_data and "args" in server_data
+        }
+
+        # Include other top-level keys from the config file
+        other_config = {k: v for k, v in raw_config.items() if k != "mcpServers"}
+
+        return ClientConfig(mcpServers=configured_servers, **other_config)
+
+    except json.JSONDecodeError as e:
+        verbose(f"Error decoding JSON from {config_path}: {e}")
+        return ClientConfig(mcpServers={})
+    except Exception as e:
+        verbose(f"Error reading config file {config_path}: {e}")
+        return ClientConfig(mcpServers={})
+
+
+def _write_config_command(config: ClientConfig, target: ClientCommandTarget) -> None:
+    """Writes configuration using a command (e.g., for VS Code)."""
+    command = target["command"]
+    args: List[str] = []
+
+    # Convert ConfiguredServer back to dict for JSON stringify
+    for name, server in config.mcpServers.items():
+        server_dict = {"command": server.command, "args": server.args, "name": name}
+        args.extend(["--add-mcp", json.dumps(server_dict)])
+
+    full_command = [command] + args
+    verbose(f"Running command: {' '.join(full_command)}")
+
+    try:
+        # Use shell=True cautiously if command might not be directly executable
+        # Or better, ensure the command is in PATH
+        result = subprocess.run(full_command, capture_output=True, text=True, check=True, encoding='utf-8')
+        verbose(f"Executed command successfully. Output:\n{result.stdout}")
+        if result.stderr:
+            verbose(f"Command stderr:\n{result.stderr}")
+    except FileNotFoundError:
+        verbose(f"Error: Command '{command}' not found. Make sure it is installed and in your PATH.")
+        raise FileNotFoundError(f"Command '{command}' not found.")
+    except subprocess.CalledProcessError as e:
+        verbose(f"Error executing command. Return code: {e.returncode}")
+        verbose(f"Stdout:\n{e.stdout}")
+        verbose(f"Stderr:\n{e.stderr}")
+        raise RuntimeError(f"Command '{command}' failed: {e.stderr or e.stdout}")
+    except Exception as e:
+        verbose(f"An unexpected error occurred while running the command: {e}")
+        raise
+
+
+def _write_config_file(config: ClientConfig, target: ClientFileTarget) -> None:
+    """Writes configuration to a file, merging with existing content."""
+    config_path = target["path"]
+    config_dir = config_path.parent
+
+    verbose(f"Ensuring config directory exists: {config_dir}")
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    existing_config_data: Dict[str, Any] = {}
+    if config_path.exists():
+        try:
+            verbose("Reading existing config file for merging.")
+            existing_config_data = json.loads(config_path.read_text(encoding="utf-8"))
+            verbose(f"Existing config loaded: {json.dumps(existing_config_data, indent=2)}")
+        except json.JSONDecodeError as e:
+            verbose(f"Error reading existing config file {config_path} for merge: {e}. Will overwrite.")
+        except Exception as e:
+            verbose(f"Error reading existing config file {config_path}: {e}. Will overwrite.")
+
+    # Prepare the config to be written (convert dataclasses back to dicts)
+    config_to_write = {
+        **config.__dict__,  # Include other top-level keys if ClientConfig has them
+        "mcpServers": {
+            name: {"command": server.command, "args": server.args, "env": server.env}
+            for name, server in config.mcpServers.items()
+        }
+    }
+
+    # Merge configurations
+    verbose("Merging configurations.")
+    merged_config = {
+        **existing_config_data,
+        **config_to_write,
+        # Ensure mcpServers are merged correctly
+        "mcpServers": {
+            **(existing_config_data.get("mcpServers") or {}),
+            **(config_to_write.get("mcpServers") or {}),
+        }
+    }
+    verbose(f"Merged config: {json.dumps(merged_config, indent=2)}")
+
+    try:
+        verbose(f"Writing config to file: {config_path}")
+        config_path.write_text(json.dumps(merged_config, indent=2), encoding="utf-8")
+        verbose(f"Configuration successfully written to {config_path}")
+    except Exception as e:
+        verbose(f"Error writing config file {config_path}: {e}")
+        raise IOError(f"Failed to write configuration to {config_path}") from e
+
+
+def write_config(config: ClientConfig, client: Optional[str] = None) -> None:
+    """Writes the configuration for the specified client, either to a file or via command."""
+    client_name = (client or "claude").lower()
+    verbose(f"Writing config for client: {client_name}")
+    verbose(f"Config data: {config}")  # Dataclass repr is usually good
+
+    if not isinstance(config, ClientConfig) or not isinstance(config.mcpServers, dict):
+        verbose("Invalid config object provided.")
+        raise TypeError("Invalid ClientConfig object provided to write_config")
+
+    target = get_config_target(client_name)
+
+    if target["type"] == "command":
+        _write_config_command(config, target)
+    else:
+        # Prepare the configuration to be written
+        cleaned_config = {
+            **config.__dict__,
+            "mcpServers": {
+                name: server.__dict__ for name, server in config.mcpServers.items()
+            }
+        }
+        # Deserialize back into ConfiguredServer objects after writing
+        deserialized_config = ClientConfig(
+            **{
+                **cleaned_config,
+                "mcpServers": {
+                    name: ConfiguredServer(**server) for name, server in cleaned_config["mcpServers"].items()
+                }
+            }
+        )
+        _write_config_file(deserialized_config, target)

cli/main.py

@@ -0,0 +1,12 @@
+import click
+from .commands.install import install
+from .commands.run import run
+
+@click.group()
+@click.version_option(version="1.0.0", package_name="py-cli") # Corresponds to program.version("1.0.0")
+def cli():
+    """A custom CLI tool translated to Python."""
+    pass
+
+cli.add_command(install)
+cli.add_command(run)