py-mcpdock-cli 1.0.13__tar.gz → 1.0.18__tar.gz

{py_mcpdock_cli-1.0.13/src/py_mcpdock_cli.egg-info → py_mcpdock_cli-1.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-mcpdock-cli
-Version: 1.0.13
+Version: 1.0.18
 Summary: Python CLI for managing MCP servers
 Author-email: dw <qindongwoxin@gmail.com>
 Project-URL: Homepage, https://github.com/yourusername/py-mcpdock-cli
@@ -21,6 +21,8 @@ Requires-Dist: asyncio>=3.4.3
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: mcp
 Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: filelock>=3.18.0
 
 # MCP CLI Python Implementation
 

{py_mcpdock_cli-1.0.13 → py_mcpdock_cli-1.0.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py-mcpdock-cli"
-version = "1.0.13"
+version = "1.0.18"
 authors = [
     {name = "dw", email = "qindongwoxin@gmail.com"},
 ]
@@ -28,13 +28,15 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "mcp",
     "aiohttp>=3.8.0",
+    "psutil>=5.9.0",
+    "filelock>=3.18.0",
 ]
 
 [tool.setuptools.packages.find]
 where = ["src"]
 
 [project.scripts]
-mcpy = "cli.main:cli"
+mcpdock = "cli.main:cli"
 
 [project.urls]
 "Homepage" = "https://github.com/yourusername/py-mcpdock-cli"

{py_mcpdock_cli-1.0.13 → py_mcpdock_cli-1.0.18}/src/cli/commands/install.py

@@ -77,84 +77,81 @@ async def install_mcp_server(
     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
+    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
+        verbose(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
+        verbose(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")
@@ -164,19 +161,19 @@ async def install_mcp_server(
 @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}...")
+    verbose(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}")
+            verbose(f"Using provided config: {user_config}")
         except json.JSONDecodeError as e:
-            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            verbose(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)
+        verbose(f"Installation failed: {str(e)}", err=True)
         return 1

py_mcpdock_cli-1.0.18/src/cli/commands/query_pid.py

@@ -0,0 +1,36 @@
+from cli.utils.logger import verbose
+import click
+import json
+import sys
+from ..utils.run_query_pid_by_packagename import query_pid_by_packagename
+
+
+@click.command("query-pid")
+@click.argument("package_names", type=click.STRING, nargs=-1, required=True)
+@click.option("--json-output", is_flag=True, help="Output results in JSON format")
+def query_pid(package_names, json_output):
+    """
+    Check if the processes for the specified package names are running.
+
+    PACKAGE_NAMES: One or more package names to check.
+    Returns the running status for each package name. If the --json-output option is used, outputs the result in JSON format.
+    """
+    try:
+        # Get the running status for each package name
+        status_dict = query_pid_by_packagename(list(package_names))
+
+        if json_output:
+            # Output results in JSON format
+            print(json.dumps(status_dict))
+        else:
+            # Output results in plain text format
+            for package_name, is_running in status_dict.items():
+                status = "Running" if is_running else "Not running"
+                verbose(f"Package name '{package_name}': {status}")
+
+        # Check if any process is running
+        any_running = any(status_dict.values())
+        exit(0 if any_running else 1)
+    except Exception as e:
+        print(f"Error occurred while executing query-pid command: {e}", file=sys.stderr)
+        exit(1)  # Return 1 to indicate an error

{py_mcpdock_cli-1.0.13 → py_mcpdock_cli-1.0.18}/src/cli/commands/run.py

@@ -3,7 +3,7 @@ import json
 import asyncio
 from typing import Dict, Any, Optional
 
-from rich import print as rprint
+from rich import print as verbose
 from rich.console import Console
 
 from ..utils.logger import verbose
@@ -91,8 +91,8 @@ async def run_server(
         # 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]}")
+        verbose(f"[blue][Runner] Connecting to server:[/blue] {resolved_server.qualifiedName}")
+        verbose(f"Connection types: {[c.type for c in resolved_server.connections]}")
 
         # Assume analytics is disabled for now
         analytics_enabled = False
@@ -105,7 +105,7 @@ async def run_server(
             analytics_enabled
         )
     except Exception as e:
-        rprint(f"[red][Runner] Fatal error:[/red] {str(e)}")
+        verbose(f"[red][Runner] Fatal error:[/red] {str(e)}")
         raise
 
 
@@ -115,18 +115,18 @@ async def run_server(
 @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}...")
+    verbose(f"Attempting to run {mcp_server}...")
     server_config = None
 
     # Parse command line provided configuration
     if config_json:
         try:
+            verbose(config_json)
             server_config = json.loads(config_json)
-            click.echo(f"Using provided config: {server_config}")
+            verbose(f"Using provided config: {server_config}")
         except json.JSONDecodeError as e:
-            click.echo(f"Error: Invalid JSON provided for --config: {e}", err=True)
+            verbose(f"Error: Invalid JSON provided for --config: {e}")
             return 1
-
     # If no config provided, use empty dict
     if server_config is None:
         verbose("No config provided, running with empty config")
@@ -135,8 +135,6 @@ def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
     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
@@ -144,5 +142,5 @@ def run(mcp_server: str, config_json: Optional[str], api_key: Optional[str]):
         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)
+        verbose(f"Run failed: {str(e)}")
         return 1

py_mcpdock_cli-1.0.18/src/cli/main.py

@@ -0,0 +1,16 @@
+import click
+from .commands.install import install
+from .commands.run import run
+from .commands.query_pid import query_pid
+
+
+@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)
+cli.add_command(query_pid)

py_mcpdock_cli-1.0.18/src/cli/runners/stdio_runner.py

@@ -0,0 +1,286 @@
+"""
+STDIO Runner implementation for local MCP servers
+
+This module provides functionality for creating and managing a connection with an MCP server
+through standard input/output pipes.
+"""
+import json
+import asyncio
+from logging import error
+import mcp.types as types
+import signal
+import sys
+import os
+import anyio
+import threading
+from typing import Dict, Any, Optional, Awaitable
+from contextlib import AsyncExitStack
+
+from ..utils.logger import verbose
+from ..types.registry import RegistryServer
+from ..utils.runtime import get_runtime_environment
+from mcp import StdioServerParameters, ClientSession
+from mcp.client.stdio import stdio_client
+
+# 导入工具模块
+from ..utils.process_utils import find_server_process_by_command, save_pid_to_file
+from ..utils.mcp_utils import (
+    process_client_request,
+    handle_single_server_message,
+    initialize_session
+)
+
+
+async def create_stdio_runner(
+    server_details: RegistryServer,
+    config: Dict[str, Any],
+    api_key: Optional[str] = None,
+    analytics_enabled: bool = False
+) -> Awaitable[None]:
+    """创建并运行 STDIO 代理服务器"""
+    verbose(f"Starting STDIO proxy runner: {server_details.qualifiedName}")
+    is_shutting_down = False
+    exit_stack = AsyncExitStack()
+
+    def handle_error(error: Exception, context: str) -> Exception:
+        verbose(f"[Runner] {context}: {error}")
+        return error
+
+    async def cleanup() -> None:
+        nonlocal is_shutting_down
+        if is_shutting_down:
+            verbose("[Runner] Cleanup already in progress, skipping...")
+            return
+        verbose("[Runner] Starting cleanup...")
+        is_shutting_down = True
+        try:
+            # Remove PID by server name and client name
+            from ..utils.process_utils import remove_pid_by_server_name
+
+            # 尝试获取第三级进程作为客户端标识 - 与保存时使用相同的逻辑
+            client_name = "unknown_client"
+            try:
+                import psutil
+                current_process = psutil.Process()
+
+                # 收集完整的进程链
+                process_chain = []
+                process = current_process
+                while process:
+                    process_chain.append(process.name())
+                    process = process.parent()
+
+                # 打印完整进程链用于调试
+                verbose(f"[Runner] 清理时的完整进程链: {' -> '.join(reversed(process_chain))}")
+
+                # 尝试获取第四级进程（如果存在）
+                if len(process_chain) >= 3:
+                    client_name = process_chain[2]
+                    verbose(f"[Runner] 清理时使用第四级进程作为客户端: {client_name}")
+                else:
+                    # 如果进程链不够长，使用最后一个进程（顶层进程）
+                    client_name = process_chain[-1] if process_chain else "unknown_client"
+                    verbose(f"[Runner] 清理时进程链不够长，使用顶层进程作为客户端: {client_name}")
+            except Exception as e:
+                verbose(f"[Runner] 清理时获取客户端进程名称失败: {e}，使用默认值: {client_name}")
+
+            remove_pid_by_server_name(server_details.qualifiedName, client_name)
+            verbose(f"[Runner] 已从PID文件中移除服务器 '{server_details.qualifiedName}' 的客户端 '{client_name}' 记录")
+
+            await exit_stack.aclose()
+            verbose("[Runner] Resources closed successfully")
+        except Exception as error:
+            handle_error(error, "Error during cleanup")
+        verbose("[Runner] Cleanup completed")
+
+    async def handle_sigint():
+        verbose("[Runner] Received interrupt signal, shutting down...")
+        await cleanup()
+        # 立即打印一条确认消息，让用户知道CTRL+C已被捕获
+        verbose("\n[CTRL+C] 正在关闭服务，请稍候...")
+        # 可选：设置一个短暂的超时，然后强制退出
+        import threading
+        threading.Timer(2.0, lambda: os._exit(0)).start()
+
+    # 获取连接配置
+    stdio_connection = next((conn for conn in server_details.connections if conn.type == "stdio"), None)
+    if not stdio_connection:
+        raise ValueError("No STDIO connection found")
+
+    from ..registry import fetch_connection
+    formatted_config = config
+    verbose(f"Formatted config: {formatted_config}")
+    server_config = await fetch_connection(server_details.qualifiedName, formatted_config)
+
+    if not server_config or not isinstance(server_config, dict):
+        raise ValueError("Failed to get valid stdio server configuration")
+
+    command = server_config.get("command", "python")
+    args = server_config.get("args", ["-m", server_details.qualifiedName])
+    env_vars = server_config.get("env", {})
+    env = get_runtime_environment(env_vars)
+
+    verbose(f"Using environment: {json.dumps({k: '***' if k.lower().endswith('key') else v for k, v in env.items()})}")
+    verbose(f"Executing: {command} {' '.join(args)}")
+
+    try:
+        # 创建服务器进程
+        server_params = StdioServerParameters(
+            command=command,
+            args=args,
+            env=env,
+            encoding="utf-8"
+        )
+
+        verbose(f"Setting up stdio proxy client for {server_details.qualifiedName}")
+        async with stdio_client(server_params, errlog=sys.stderr) as (read_stream, write_stream):
+            verbose("Stdio proxy client connection established")
+
+            # 查找服务器进程ID - 优先使用父子进程关系
+            from ..utils.process_utils import find_server_process_by_command, save_pid_to_file, find_server_process_from_current
+
+            # 首先尝试通过父子进程关系查找
+            is_found_from_current, current_pid, cmd_str = find_server_process_from_current()
+            if is_found_from_current and current_pid:
+                verbose(f"[Runner] 通过父子进程关系找到服务器进程，PID: {current_pid}")
+                server_pid = current_pid
+            else:
+                # 如果父子进程关系查找失败，尝试通过命令行查找
+                server_pid = find_server_process_by_command(command, args)
+
+            if server_pid:
+                verbose(f"[Runner] 已找到MCP服务器进程，PID: {server_pid}")
+
+                # 将进程ID写入PID文件
+                # 尝试获取第四级进程作为客户端标识
+                client_name = "unknown_client"
+                try:
+                    import psutil
+                    current_process = psutil.Process()
+
+                    # 收集完整的进程链
+                    process_chain = []
+                    process = current_process
+                    while process:
+                        process_chain.append(process.name())
+                        process = process.parent()
+
+                    # 打印完整进程链用于调试
+                    verbose(f"[Runner] 完整进程链: {' -> '.join(reversed(process_chain))}")
+
+                    # 尝试获取第四级进程（如果存在）
+                    if len(process_chain) >= 3:
+                        client_name = process_chain[2]
+                        verbose(f"[Runner] 使用第三级进程作为客户端: {client_name}")
+                    else:
+                        # 如果进程链不够长，使用最后一个进程（顶层进程）
+                        client_name = process_chain[-1] if process_chain else "unknown_client"
+                        verbose(f"[Runner] 进程链不够长，使用顶层进程作为客户端: {client_name}")
+                except Exception as e:
+                    verbose(f"[Runner] 获取客户端进程名称失败: {e}，使用默认值: {client_name}")
+
+                verbose(f"[Runner] 使用 '{client_name}' 作为客户端标识")
+                pid_file_path = save_pid_to_file(server_pid, server_details.qualifiedName,
+                                                 client_name, command, args)
+                if pid_file_path:
+                    verbose(f"[Runner] 已将服务器PID信息安全地保存到: {pid_file_path}")
+            else:
+                verbose(f"[Runner] 未能找到MCP服务器进程，将无法获取其PID")
+
+            # 创建 MCP 客户端会话
+            from mcp import ClientSession
+            session = await exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
+
+            # 注册消息处理回调
+            def handle_server_message(msg):
+                verbose(f"[magenta][server][/magenta] {json.dumps(msg, ensure_ascii=False)}")
+            session.on_message = handle_server_message
+
+            # 初始化 MCP 协议
+            if not await initialize_session(session):
+                return
+
+            # 使用简单的同步阻塞循环处理输入和服务器消息
+            verbose("[Runner] 开始处理循环，使用同步阻塞模式")
+
+            # 打印启动消息
+            verbose("[cyan]MCP client running. Press Ctrl+C to stop.[/cyan]")
+
+            # 获取事件循环并在主任务中添加信号处理程序
+            loop = asyncio.get_event_loop()
+            loop.add_signal_handler(signal.SIGINT, lambda: asyncio.create_task(handle_sigint()))
+
+            # 循环处理客户端请求，直到关闭
+            while not is_shutting_down:
+                try:
+                    # 从标准输入读取一行 (同步阻塞)
+                    line = sys.stdin.readline()
+                    if not line:
+                        verbose("[Runner] 标准输入关闭，结束处理")
+                        break
+
+                    # 处理客户端请求
+                    message = json.loads(line)
+                    verbose(f"[stdin] Received message: {line.strip()}")
+
+                    method = message.get("method", "")
+                    # 根据消息类型处理
+                    if "id" in message:  # 这是请求，需要响应
+                        response = await process_client_request(message, session)
+                        sys.stdout.write(response + "\n")
+                        sys.stdout.flush()
+                        verbose(f"[stdin] Response sent for method: {method}")
+                    else:  # 这是通知，不需要响应
+                        # 创建通知对象并发送
+                        # notification_obj = create_request_object(message, method)
+                        # await session.send_notification(notification_obj)
+                        await session.send_notification(
+                            types.ClientNotification(
+                                types.InitializedNotification(method=method)
+                            )
+                        )
+                        verbose(f"[stdin] Notification sent for method: {method}")
+
+                    verbose(f"[stdin] Processed: {line.strip()}")
+
+                except json.JSONDecodeError as e:
+                    error(f"[stdin] JSON decode error: {e}")
+                except Exception as e:
+                    error(f"[stdin] Error processing input: {e}")
+                    # 如果是请求(有ID)，才需要发送错误响应
+                    try:
+                        if 'message' in locals() and isinstance(message, dict) and "id" in message:
+                            error_resp = json.dumps({
+                                "jsonrpc": "2.0",
+                                "id": message.get("id"),
+                                "error": {
+                                    "code": -32700,
+                                    "message": f"Parse error: {str(e)}"
+                                }
+                            })
+                            sys.stdout.write(error_resp + "\n")
+                            sys.stdout.flush()
+                            verbose(f"[stdin] Sent error response for parse error")
+                    except Exception as err:
+                        error(f"[stdin] Failed to send error response: {err}")
+
+                # 检查是否有服务器消息需要处理
+                # 注意：这部分仍需异步，因为我们需要非阻塞地检查服务器消息
+                try:
+                    # 使用超时机制非阻塞地检查服务器消息
+                    with anyio.fail_after(0.1):  # 设置很短的超时
+                        message = await read_stream.receive()
+                        await handle_single_server_message(message)
+                except TimeoutError:
+                    # 超时表示没有消息，继续处理客户端请求
+                    pass
+                except Exception as e:
+                    error(f"[Runner] 处理服务器消息异常: {e}")
+
+            verbose("[Runner] 处理循环结束")
+
+    except Exception as e:
+        verbose(f"[red]Error running stdio proxy: {e}[/red]")
+        raise
+    finally:
+        await cleanup()