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

cli/mock_servers.json

@@ -0,0 +1,186 @@
+{
+    "octagon": {
+        "qualifiedName": "octagon",
+        "displayName": "Octagon MCP Server (Mock)",
+        "remote": false,
+        "connections": [
+            {
+                "type": "stdio",
+                "stdioFunction": [
+                    "npx"
+                ],
+                "published": true,
+                "configSchema": {
+                    "args": [
+                        "-y",
+                        "octagon-mcp@latest"
+                    ],
+                    "env": {
+                        "OCTAGON_API_KEY": {
+                            "type": "string",
+                            "description": "OCTAGON_API_KEY"
+                        }
+                    },
+                    "required": [
+                        "OCTAGON_API_KEY"
+                    ]
+                }
+            }
+        ]
+    },
+    "mcp-gitlab": {
+        "qualifiedName": "@zereight/mcp-gitlab",
+        "displayName": "@zereight/mcp-gitlab",
+        "remote": false,
+        "connections": [
+            {
+                "type": "stdio",
+                "stdioFunction": [
+                    "npx"
+                ],
+                "published": true,
+                "configSchema": {
+                    "args": [
+                        "-y",
+                        "@zereight/mcp-gitlab"
+                    ],
+                    "env": {
+                        "GITLAB_PERSONAL_ACCESS_TOKEN": {
+                            "type": "string",
+                            "description": "GITLAB_PERSONAL_ACCESS_TOKEN"
+                        },
+                        "GITLAB_API_URL": {
+                            "type": "string",
+                            "description": "GITLAB_API_URL",
+                            "default": "GITLAB_API_URL"
+                        },
+                        "GITLAB_READ_ONLY_MODE": {
+                            "type": "string",
+                            "description": "GITLAB_READ_ONLY_MODE"
+                        }
+                    },
+                    "required": [
+                        "GITLAB_PERSONAL_ACCESS_TOKEN",
+                        "GITLAB_API_URL"
+                    ]
+                }
+            },
+            {
+                "type": "ws",
+                "deploymentUrl": "wss://example.com",
+                "published": true
+            }
+        ]
+    },
+    "mcp-twikit": {
+        "qualifiedName": "mcp-twikit",
+        "displayName": "mcp-twikit (Mock)",
+        "remote": false,
+        "connections": [
+            {
+                "type": "stdio",
+                "stdioFunction": [
+                    "uvx"
+                ],
+                "published": true,
+                "configSchema": {
+                    "args": [
+                        "--from",
+                        "git+https://github.com/adhikasp/mcp-twikit",
+                        "mcp-twikit"
+                    ],
+                    "env": {
+                        "TWITTER_USERNAME": {
+                            "type": "string",
+                            "description": "TWITTER_USERNAME",
+                            "default": "@example"
+                        },
+                        "TWITTER_EMAIL": {
+                            "type": "string",
+                            "description": "TWITTER_EMAIL",
+                            "default": "me@example.com"
+                        },
+                        "TWITTER_PASSWORD": {
+                            "type": "string",
+                            "description": "TWITTER_PASSWORD",
+                            "default": "secret"
+                        }
+                    },
+                    "required": [
+                        "TWITTER_USERNAME",
+                        "TWITTER_EMAIL",
+                        "TWITTER_PASSWORD"
+                    ]
+                }
+            }
+        ]
+    },
+    "@suekou/mcp-notion-server": {
+        "qualifiedName": "@suekou/mcp-notion-server",
+        "displayName": "mcp-notion (Mock)",
+        "remote": false,
+        "connections": [
+            {
+                "type": "stdio",
+                "stdioFunction": [
+                    "npx"
+                ],
+                "published": true,
+                "configSchema": {
+                    "args": [
+                        "-y",
+                        "@suekou/mcp-notion-server"
+                    ],
+                    "env": {
+                        "NOTION_API_TOKEN": {
+                            "type": "string",
+                            "description": "NOTION_API_TOKEN",
+                            "default": "your-integration-token"
+                        }
+                    },
+                    "required": [
+                        "NOTION_API_TOKEN"
+                    ]
+                }
+            }
+        ]
+    },
+    "@test/install-notion": {
+        "qualifiedName": "@suekou/mcp-notion-server",
+        "displayName": "mcp-notion (Mock)",
+        "remote": false,
+        "connections": [
+            {
+                "type": "stdio",
+                "stdioFunction": [
+                    "npx"
+                ],
+                "published": true,
+                "configSchema": {
+                    "args": [
+                        "-y",
+                        "@suekou/mcp-notion-server",
+                        "--from",
+                        "py-mcpdock-cli==1.0.12",
+                        "--index-url",
+                        "https://test.pypi.org/simple/",
+                        "--extra-index-url",
+                        "https://pypi.org/simple/",
+                        "mcpy",
+                        "run"
+                    ],
+                    "env": {
+                        "NOTION_API_TOKEN": {
+                            "type": "string",
+                            "description": "NOTION_API_TOKEN",
+                            "default": "your-integration-token"
+                        }
+                    },
+                    "required": [
+                        "NOTION_API_TOKEN"
+                    ]
+                }
+            }
+        ]
+    }
+}

cli/registry.py

@@ -0,0 +1,136 @@
+"""
+Registry module for MCP servers.
+
+This module handles resolving package names to server metadata and fetching configuration.
+"""
+from typing import Dict, Any, Tuple, Optional
+import json
+import os
+
+from .utils.logger import verbose
+from .types.registry import (
+    RegistryServer, ConnectionDetails, ConfigSchema, ConfigSchemaProperty
+)
+
+
+MOCK_SERVERS_PATH = os.path.join(os.path.dirname(__file__), "mock_servers.json")
+
+
+def _load_mock_servers():
+    with open(MOCK_SERVERS_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _dict_to_registry_server(data):
+    # Helper to recursively convert dict to dataclasses
+    def _to_config_schema_property(prop):
+        return ConfigSchemaProperty(**prop)
+
+    def _to_config_schema(schema):
+        env = {k: _to_config_schema_property(v) for k, v in schema.get("env", {}).items()}
+        return ConfigSchema(env=env, required=schema.get("required", []), args=schema.get("args"))
+
+    def _to_connection_details(conn):
+        config_schema = None
+        if "configSchema" in conn and conn["configSchema"]:
+            config_schema = _to_config_schema(conn["configSchema"])
+        return ConnectionDetails(
+            type=conn["type"],
+            stdioFunction=conn.get("stdioFunction"),
+            deploymentUrl=conn.get("deploymentUrl"),
+            published=conn.get("published"),
+            configSchema=config_schema
+        )
+    return RegistryServer(
+        qualifiedName=data["qualifiedName"],
+        displayName=data["displayName"],
+        remote=data["remote"],
+        connections=[_to_connection_details(c) for c in data["connections"]]
+    )
+
+
+mock_servers_data = _load_mock_servers()
+
+
+async def resolve_package(package_name: str) -> RegistryServer:
+    """
+    Resolves a package name to server metadata.
+    """
+    verbose(f"Mock resolving package {package_name}")
+    data = mock_servers_data.get(package_name) or mock_servers_data.get("default")
+    return _dict_to_registry_server(data)
+
+
+async def fetch_connection(
+    package_name: str,
+    config: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Fetches server connection details for a package with given configuration.
+
+    This function uses the package name to resolve the server details and then
+    formats the connection configuration based on the schema and user provided config.
+
+    Args:
+        package_name: The name of the package to fetch connection details for
+        config: User-provided configuration values
+
+    Returns:
+        Dictionary containing command, args and env configuration for the connection
+    """
+    verbose(f"Fetching connection details for {package_name} with config: {config}")
+
+    # Get server metadata first
+    server_data = await resolve_package(package_name)
+
+    # Find stdio connection
+    stdio_connection = next((conn for conn in server_data.connections if conn.type == "stdio"), None)
+    if not stdio_connection:
+        verbose("No stdio connection found in server metadata")
+        return {}
+
+    # Get command type (npx, uv, etc.) from stdioFunction
+    command = "python"  # Default as fallback
+    if stdio_connection.stdioFunction and len(stdio_connection.stdioFunction) > 0:
+        command = stdio_connection.stdioFunction[0]
+
+    # Get args from the connection schema
+    args = []
+    if stdio_connection.configSchema and stdio_connection.configSchema.args:
+        args = stdio_connection.configSchema.args
+    else:
+        # Fallback default
+        args = ["-m", package_name]
+
+    # Return formatted connection config
+    connection_config = {
+        "command": command,
+        "args": args,
+        "env": config  # User-provided environment variables
+    }
+
+    verbose(f"Formatted connection config: {connection_config}")
+    return connection_config
+
+
+async def fetch_config_with_api_key(
+    package_name: str,
+    api_key: str
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    Fetches server and configuration information using an API key.
+
+    Args:
+        package_name: The name of the package to fetch configuration for
+        api_key: The API key to authenticate with
+
+    Returns:
+        A tuple containing (server_info, config_info)
+    """
+    verbose(f"Mock fetching config for {package_name} using API key")
+
+    # This is a placeholder implementation
+    # In a real implementation, this would make an API call
+    # to retrieve the server and configuration information
+
+    return {}, {}  # Empty dicts for now as placeholder

cli/runners/__init__.py

@@ -0,0 +1,21 @@
+"""
+Runners for different types of MCP servers.
+
+This package contains implementations for running different types of MCP servers:
+- stdio_runner: For running local servers via stdio communication
+- ws_runner: For connecting to remote WebSocket servers
+- command_runner: For running Python/Node packages using uv/npx
+"""
+from .stdio_runner import create_stdio_runner
+from .ws_runner import create_ws_runner
+from .stream_http_runner import create_stream_http_runner
+from .command_runner import create_uv_runner, create_npx_runner, run_package_with_command
+
+__all__ = [
+    'create_stdio_runner',
+    'create_ws_runner',
+    'create_uv_runner',
+    'create_npx_runner',
+    'create_stream_http_runner',
+    'run_package_with_command'
+]

cli/runners/command_runner.py

@@ -0,0 +1,172 @@
+"""
+Command Runners implementation for running Python or Node.js packages
+"""
+import json
+import asyncio
+import signal
+import sys
+import os
+from typing import Dict, Any, Optional, List
+
+from rich import print as rprint
+
+from ..utils.logger import verbose
+
+
+async def run_command_process(cmd: List[str], env: Optional[Dict[str, str]] = None) -> None:
+    """
+    Run a command as a subprocess and handle its output asynchronously
+
+    Args:
+        cmd: Command and arguments as a list
+        env: Optional environment variables
+    """
+    verbose(f"Running command: {' '.join(cmd)}")
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=env
+    )
+
+    # Setup signal handling for graceful shutdown
+    def handle_sigint(sig, frame):
+        rprint("[yellow]Received stop signal, terminating command...[/yellow]")
+        process.terminate()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, handle_sigint)
+
+    # Process output in real-time
+    async def read_stream(stream, prefix):
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            try:
+                decoded_line = line.decode('utf-8').rstrip()
+                if prefix == "stdout":
+                    rprint(f"[blue]{decoded_line}[/blue]")
+                else:
+                    rprint(f"[yellow]{decoded_line}[/yellow]")
+            except UnicodeDecodeError:
+                rprint(f"[red]Error decoding output from {prefix}[/red]")
+
+    # Create tasks for stdout and stderr
+    stdout_task = asyncio.create_task(read_stream(process.stdout, "stdout"))
+    stderr_task = asyncio.create_task(read_stream(process.stderr, "stderr"))
+
+    # Wait for process to complete
+    exit_code = await process.wait()
+
+    # Wait for output to be fully processed
+    await stdout_task
+    await stderr_task
+
+    if exit_code != 0:
+        rprint(f"[red]Command exited with code {exit_code}[/red]")
+    else:
+        rprint(f"[green]Command completed successfully[/green]")
+
+
+async def create_uv_runner(
+    package_name: str,
+    args: List[str],
+    config: Dict[str, Any],
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Creates a runner for executing Python packages with uv package manager
+
+    Args:
+        package_name: Name of the Python package to run
+        args: Additional arguments to pass to the package
+        config: Configuration options
+        api_key: Optional API key for authentication
+    """
+    verbose(f"Starting uv runner for package: {package_name}")
+    rprint(f"[blue]Running Python package with uv: {package_name}[/blue]")
+
+    # Prepare environment variables from config
+    env = os.environ.copy()
+    for key, value in config.items():
+        if isinstance(value, str):
+            env[f"MCP_{key.upper()}"] = value
+        else:
+            env[f"MCP_{key.upper()}"] = json.dumps(value)
+
+    if api_key:
+        env["MCP_API_KEY"] = api_key
+
+    # Build the uv command
+    cmd = ["uv", "run", "-m", package_name]
+    if args:
+        cmd.extend(args)
+
+    await run_command_process(cmd, env)
+
+
+async def create_npx_runner(
+    package_name: str,
+    args: List[str],
+    config: Dict[str, Any],
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Creates a runner for executing Node.js packages with npx
+
+    Args:
+        package_name: Name of the Node.js package to run
+        args: Additional arguments to pass to the package
+        config: Configuration options
+        api_key: Optional API key for authentication
+    """
+    verbose(f"Starting npx runner for package: {package_name}")
+    rprint(f"[blue]Running Node.js package with npx: {package_name}[/blue]")
+
+    # Prepare environment variables from config
+    env = os.environ.copy()
+    for key, value in config.items():
+        if isinstance(value, str):
+            env[f"MCP_{key.upper()}"] = value
+        else:
+            env[f"MCP_{key.upper()}"] = json.dumps(value)
+
+    if api_key:
+        env["MCP_API_KEY"] = api_key
+
+    # Build the npx command
+    cmd = ["npx", package_name]
+    if args:
+        cmd.extend(args)
+
+    await run_command_process(cmd, env)
+
+
+async def run_package_with_command(
+    command_type: str,
+    package_name: str,
+    args: List[str],
+    config: Dict[str, Any],
+    api_key: Optional[str] = None
+) -> None:
+    """
+    Run a package with the specified command runner (uv or npx)
+
+    Args:
+        command_type: Type of command runner to use ("uv" or "npx")
+        package_name: Name of the package to run
+        args: Additional arguments to pass to the package
+        config: Configuration options
+        api_key: Optional API key for authentication
+
+    Raises:
+        ValueError: If an unsupported command type is provided
+    """
+    if command_type.lower() == "uv":
+        await create_uv_runner(package_name, args, config, api_key)
+    elif command_type.lower() == "npx":
+        await create_npx_runner(package_name, args, config, api_key)
+    else:
+        raise ValueError(f"Unsupported command type: {command_type}")