py-mcpdock-cli 1.0.13__tar.gz

py_mcpdock_cli-1.0.13/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/cli *.json

py_mcpdock_cli-1.0.13/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: py-mcpdock-cli
+Version: 1.0.13
+Summary: Python CLI for managing MCP servers
+Author-email: dw <qindongwoxin@gmail.com>
+Project-URL: Homepage, https://github.com/yourusername/py-mcpdock-cli
+Project-URL: Bug Tracker, https://github.com/yourusername/py-mcpdock-cli/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: questionary>=1.10.0
+Requires-Dist: rich>=12.0.0
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: mcp
+Requires-Dist: aiohttp>=3.8.0
+
+# MCP CLI Python Implementation
+
+This is a Python implementation of the Model Context Protocol (MCP) command-line tool.
+

py_mcpdock_cli-1.0.13/README.md

@@ -0,0 +1,4 @@
+# MCP CLI Python Implementation
+
+This is a Python implementation of the Model Context Protocol (MCP) command-line tool.
+

py_mcpdock_cli-1.0.13/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=42.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "py-mcpdock-cli"
+version = "1.0.13"
+authors = [
+    {name = "dw", email = "qindongwoxin@gmail.com"},
+]
+description = "Python CLI for managing MCP servers"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "click>=8.0.0",
+    "questionary>=1.10.0",
+    "rich>=12.0.0",
+    "asyncio>=3.4.3",
+    "python-dotenv>=1.0.0",
+    "mcp",
+    "aiohttp>=3.8.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+mcpy = "cli.main:cli"
+
+[project.urls]
+"Homepage" = "https://github.com/yourusername/py-mcpdock-cli"
+"Bug Tracker" = "https://github.com/yourusername/py-mcpdock-cli/issues"

py_mcpdock_cli-1.0.13/setup.cfg

@@ -0,0 +1,11 @@
+[pep8]
+max-line-length = 120
+
+[autopep8]
+aggressive = 1
+max-line-length = 120
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_mcpdock_cli-1.0.13/src/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

py_mcpdock_cli-1.0.13/src/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

py_mcpdock_cli-1.0.13/src/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')