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

cli/utils/config.py

@@ -1,7 +1,11 @@
 import json
+import os
+from cli.utils.logger import verbose
 import questionary
-from rich import print as rprint
+from rich import print as verbose
 from typing import Any, Dict, List, Optional, Set, Tuple, TypeVar
+from ..config.app_config import APP_ENV
+
 
 # Import proper types from registry module
 from ..types.registry import (
@@ -77,7 +81,7 @@ def format_config_values(
                 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}")
+                    verbose(f"Warning: Could not convert required value for {property_name}: {e}")
                     missing_required.append(f"{property_name} (invalid format)")
 
     if missing_required:
@@ -176,7 +180,7 @@ async def prompt_for_config_value(
         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]")
+            verbose("[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
@@ -189,14 +193,14 @@ async def prompt_for_config_value(
         )
         result = await q.ask_async()
         if result is None and is_required:
-            rprint("[bold red]Required field cannot be skipped.[/bold red]")
+            verbose("[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(
+                verbose(
                     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)
@@ -224,7 +228,7 @@ async def collect_config_values(
 
     required = set(schema.required if schema else [])
 
-    rprint("[bold blue]Please provide the following configuration values:[/bold blue]")
+    verbose("[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
@@ -238,7 +242,7 @@ async def collect_config_values(
         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]")
+            verbose(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)
@@ -248,7 +252,7 @@ async def collect_config_values(
     try:
         return format_config_values(connection, base_config)
     except ValueError as e:
-        rprint(f"[bold red]Configuration error:[/bold red] {e}")
+        verbose(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
@@ -389,14 +393,82 @@ def format_run_config_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:
+def build_dev_config(qualified_name: str,
+                     user_config: Dict[str, Any],
+                     api_key: Optional[str] = None,
+                     config_needed: bool = True):
+    """
+    Formats server config for development environment.
+
+    Creates a command that runs the Python module with the server name, config and API key,
+    with platform-specific handling for Windows vs Unix-like systems.
+
+    Args:
+        qualified_name: The package identifier 
+        user_config: User configuration values
+        api_key: Optional API key
+        config_needed: Whether config flag is needed
+    """
+    import sys
+    import os
+
+    # 检测是否为Windows系统
+    is_windows = sys.platform == "win32"
+
+    # 使用固定的CLI项目目录（开发环境）
+    cli_dir = os.path.abspath(os.path.join(os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.dirname(__file__))))))
+
+    if is_windows:
+        # Windows使用cmd作为命令解释器
+        command = "cmd"
+
+        # 构建完整的Windows命令行
+        # 使用 /c 选项指示执行完命令后退出cmd，& 为Windows命令连接符
+        cmd = f"cd /d {cli_dir} & python -m src run {qualified_name}"
+
+        # 添加配置（如果需要）
+        if config_needed and user_config:
+            # Windows中JSON字符串使用双引号包裹，需要转义
+            json_config = json.dumps(user_config).replace('"', '\\"')
+            cmd += f' --config "{json_config}"'
+
+        # 添加 API 密钥（如果有提供）
+        if api_key:
+            cmd += f" --api-key {api_key}"
+
+        # 构建参数列表
+        args = ["/c", cmd]
+    else:
+        # Unix/macOS使用sh作为命令解释器
+        command = "sh"
+
+        # 构建完整的shell命令
+        cmd = f"cd {cli_dir} && python3 -m src run {qualified_name}"
+
+        # 添加配置（如果需要）
+        if config_needed and user_config:
+            # 将配置对象转为JSON字符串，并用单引号包裹（适用于shell命令）
+            json_config = json.dumps(user_config)
+            cmd += f" --config '{json_config}'"
+
+        # 添加 API 密钥（如果有提供）
+        if api_key:
+            cmd += f" --api-key {api_key}"
+
+        # 构建参数列表
+        args = ["-c", cmd]
+
+    return command, args
+
+
+def build_prod_config(qualified_name: str,
+                      user_config: Dict[str, Any],
+                      api_key: Optional[str] = None,
+                      config_needed: bool = True):
     """
     Formats server config into a command structure with proxy command support.
+    Cross-platform compatible for both Windows and Unix-like systems.
 
     Args:
         qualified_name: The package identifier (被代理的命令标识)
@@ -405,10 +477,21 @@ def format_server_config(
         config_needed: Whether config flag is needed
 
     Returns:
-        ConfiguredServer instance with command and args and env
+        Tuple containing command and args
     """
-    # 固定使用 uv 命令，因为代理是用 Python 写的
-    command = "uv"  # 固定使用 uv 作为 Python 包管理器
+    import sys
+
+    # 检测是否为Windows系统
+    is_windows = sys.platform == "win32"
+
+    # 根据系统选择合适的包管理工具命令
+    if is_windows:
+        # Windows下更常用npx而非uvx
+        command = "npx"
+    else:
+        # Unix-like系统使用uvx
+        command = "uvx"
+
     proxy_package = "@mcpspace/proxy"  # 默认代理包
 
     # 构建参数列表
@@ -424,16 +507,32 @@ def format_server_config(
     args.append(qualified_name)
 
     # 添加配置（如果需要）
-    # if config_needed and user_config:
-    #     args.append("--config")
-    #     args.append(json.dumps(user_config))
+    if config_needed and user_config:
+        args.append("--config")
+        # 在Windows上，可能需要特别处理JSON字符串中的引号
+        json_config = json.dumps(user_config)
+        if is_windows:
+            json_config = json_config.replace('"', '\\"')
+        args.append(json_config)
 
     # 添加 API 密钥（如果有提供）
     if api_key:
         args.append("--api-key")
         args.append(api_key)
+    return command, args
+
 
-    # env = user_config.get("env", {})  # Extract 'env' from user_config if available
+def format_server_config(
+    qualified_name: str,
+    user_config: Dict[str, Any],
+    api_key: Optional[str] = None,
+    config_needed: bool = True,
+) -> ConfiguredServer:
+    command, args = None, None
+    if APP_ENV != 'dev':
+        command, args = build_prod_config(qualified_name, user_config, api_key, config_needed)
+    else:
+        command, args = build_dev_config(qualified_name, user_config, api_key, config_needed)
     return ConfiguredServer(
         command=command,
         args=args,

cli/utils/logger.py

@@ -60,10 +60,10 @@ if not cli_logger.handlers:
 
     # 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)
+    # ch_cli = logging.StreamHandler()
+    # ch_cli.setLevel(logging.DEBUG)
+    # ch_cli.setFormatter(CustomFormatter())
+    # cli_logger.addHandler(ch_cli)
 
 
 def verbose(message: str) -> None:

cli/utils/mcp_utils.py

@@ -0,0 +1,314 @@
+"""
+MCP 协议请求/响应处理工具模块
+
+该模块提供了处理 MCP 协议请求和响应的工具函数，包括：
+- 创建请求对象
+- 发送请求并处理超时
+- 处理服务器消息
+"""
+import json
+import anyio
+import traceback
+from typing import Dict, Any, Optional
+from logging import error
+import sys
+
+from ..utils.logger import verbose
+from mcp.types import ClientRequest, ServerRequest
+from pydantic import BaseModel
+
+# 定义一个通用的 Model，用于接收任何 JSON 响应
+
+
+class DictModel(BaseModel):
+    @classmethod
+    def model_validate(cls, value):
+        if isinstance(value, dict):
+            return value
+        return dict(value)
+
+
+def create_request_object(message: Dict[str, Any], method: str):
+    """
+    根据方法类型创建适当的请求对象
+
+    Args:
+        message: JSON-RPC 消息
+        method: 请求方法名
+
+    Returns:
+        MCP 请求对象
+    """
+    # 作为代理，我们不需要严格验证方法是否符合标准列表
+    # 直接创建ClientRequest对象，透明转发所有请求
+    msg = dict(message)
+    msg.pop("jsonrpc", None)  # 移除 jsonrpc 字段，SDK会自动添加
+    msg.pop("id", None)       # 移除 id 字段，我们会在响应中重新添加
+
+    try:
+        # 尝试创建 ClientRequest
+        return ClientRequest(**msg)
+    except Exception as e:
+        verbose('---------------------------------------')
+        verbose(msg)
+        verbose('---------------------------------------')
+        # 如果创建失败，记录详细错误信息并回退到 ServerRequest
+        verbose(f"[Runner] 创建 ClientRequest 失败，错误信息: {str(e)}，回退到 ServerRequest")
+        return ServerRequest(method=method, params=message.get("params", {}))
+
+
+async def send_request_with_timeout(session, req_obj, original_id, timeout_seconds=60):
+    """
+    发送请求并处理超时和错误情况
+
+    Args:
+        session: MCP 客户端会话
+        req_obj: 请求对象
+        original_id: 原始请求ID
+        timeout_seconds: 超时时间(秒)
+
+    Returns:
+        JSON-RPC 响应字符串
+    """
+    try:
+        # 初始化 resp 为 None，防止超时时未定义
+        resp = None
+        # 使用超时机制
+        with anyio.move_on_after(timeout_seconds):
+            # 记录请求信息
+            verbose(f"[Runner] 发送请求，原始ID={original_id}, 方法={req_obj.method if hasattr(req_obj, 'method') else '未知'}")
+
+            # 发送请求并等待响应
+            resp = await session.send_request(req_obj, DictModel)
+
+        if resp:
+            # 直接使用原始ID构造响应
+            return json.dumps({
+                "id": original_id,
+                "jsonrpc": "2.0",
+                "result": resp
+            })
+        else:
+            return json.dumps({
+                "id": original_id,
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32000,
+                    "message": "Request timed out or empty response"
+                }
+            })
+
+    except Exception as e:
+        # 处理请求错误
+        error_msg = str(e)
+        error_code = -32603
+
+        # 分类错误类型
+        if "timed out" in error_msg.lower():
+            error_code = -32001
+        elif "connection" in error_msg.lower():
+            error_code = -32002
+
+        return json.dumps({
+            "id": original_id,
+            "jsonrpc": "2.0",
+            "error": {
+                "code": error_code,
+                "message": f"Request failed: {error_msg}"
+            }
+        })
+
+
+async def process_client_request(message, session):
+    """
+    处理从客户端接收的请求并转发到服务器
+
+    Args:
+        message: 客户端请求消息
+        session: MCP 客户端会话
+
+    Returns:
+        响应字符串
+    """
+    original_id = message.get("id")
+    method = message.get("method")
+    params = message.get("params", {})
+
+    # 添加特殊处理，记录初始化请求的详细信息
+    if method == "initialize":
+        verbose(f"[Runner] 收到初始化请求 ID: {original_id}, 详细内容: {json.dumps(message)}")
+
+        # 对初始化请求使用SDK的initialize方法，而不是简单转发
+        try:
+            verbose("[Runner] 使用SDK的initialize方法处理初始化请求")
+            # 先创建正确的请求对象
+            req_obj = create_request_object(message, method)
+
+            # 发送实际的初始化请求到下游服务器
+            verbose("[Runner] 向下游服务器发送初始化请求")
+            init_result = await session.send_request(req_obj, DictModel)
+            verbose(
+                f"[Runner] 收到下游服务器初始化响应: {json.dumps(init_result)[:200] if isinstance(init_result, dict) else str(init_result)[:200]}...")
+
+            # 确保我们有一个有效的响应
+            if init_result is None:
+                verbose("[Runner] 收到空的初始化响应，创建默认响应")
+                init_result = {
+                    "protocolVersion": "2024-11-05",
+                    "serverInfo": {
+                        "name": "mcpy-proxy",
+                        "version": "1.0.0"
+                    }
+                }
+
+            # 构造完整的JSON-RPC响应
+            response = json.dumps({
+                "jsonrpc": "2.0",
+                "id": original_id,
+                "result": init_result
+            })
+
+            verbose(f"[Runner] 构造的初始化响应: {response[:200]}...")
+            return response
+        except Exception as e:
+            error(f"[Runner] 初始化请求处理失败: {str(e)}")
+            error(f"[Runner] 异常堆栈: {traceback.format_exc()}")
+            # 如果处理失败，回退到常规请求处理
+            verbose("[Runner] 回退到常规请求处理方式")
+
+    verbose(f"[stdin] Processing request with id: {original_id}, method: {method}")
+
+    # 常规请求处理：确定请求类型和构建请求对象
+    req_obj = create_request_object(message, method)
+
+    # 发送请求并处理响应
+    try:
+        verbose(f"[Runner] 向下游服务器发送请求，method: {method}, id: {original_id}")
+        result = await send_request_with_timeout(session, req_obj, original_id)
+
+        if method == "initialize":
+            verbose(f"[Runner] 收到初始化响应: {result}")
+
+        return result
+    except Exception as e:
+        error(f"[Runner] 请求处理异常 ({method}): {str(e)}")
+        raise
+
+
+async def handle_single_server_message(data):
+    """
+    处理单个从服务器接收的消息并输出到标准输出
+
+    Args:
+        data: 服务器消息数据
+    """
+    try:
+        # 记录接收到的原始数据类型，帮助调试
+        verbose(f"[server_raw] Received data type: {type(data)}")
+
+        # 尝试获取原始数据的字符串表示用于调试
+        raw_data_str = str(data)
+        if len(raw_data_str) > 500:
+            raw_data_str = raw_data_str[:500] + "..."
+        verbose(f"[server_raw] 原始数据: {raw_data_str}")
+
+        # 根据数据类型进行处理
+        if hasattr(data, "model_dump"):
+            content = data.model_dump()
+            verbose(f"[server_raw] Processed pydantic v2 model: {type(data)}")
+        elif hasattr(data, "dict"):
+            content = data.dict()
+            verbose(f"[server_raw] Processed pydantic v1 model: {type(data)}")
+        elif isinstance(data, dict):
+            content = data
+            verbose(f"[server_raw] Processed dict with {len(data)} keys")
+        else:
+            # 尝试转换为字符串，然后解析为JSON
+            try:
+                content = json.loads(str(data))
+                verbose(f"[server_raw] Converted to JSON: {type(data)}")
+            except:
+                content = {"data": str(data)}
+                verbose(f"[server_raw] Used raw string for unknown type: {type(data)}")
+
+        # 检查是否是初始化响应
+        is_init_response = False
+        if isinstance(content, dict):
+            if "result" in content and isinstance(content["result"], dict):
+                result = content["result"]
+                if "protocolVersion" in result or "serverInfo" in result:
+                    is_init_response = True
+                    verbose(f"[server] 检测到初始化响应: {json.dumps(content)[:200]}...")
+
+                # 特别检查是否包含tools字段，这对于VSCode非常重要
+                if "tools" in result:
+                    verbose(f"[server] 检测到tools字段，工具数量: {len(result['tools'])}")
+
+        # 检查数据是否已经是标准的 JSON-RPC 消息
+        if isinstance(content, dict):
+            if "jsonrpc" in content and ("id" in content or "method" in content):
+                # 已经是标准格式，直接输出
+                output = json.dumps(content)
+                verbose(f"[server] Standard JSON-RPC message detected, id: {content.get('id')}")
+
+            elif "result" in content and not "jsonrpc" in content:
+                # 是结果但缺少 jsonrpc 字段，构造标准响应
+                output = json.dumps({
+                    "jsonrpc": "2.0",
+                    "id": 1,  # 默认ID，应该不会被用到
+                    "result": content["result"] if "result" in content else content
+                })
+                verbose(f"[server] Fixed response format by adding jsonrpc")
+
+            else:
+                # 其他类型的消息，包装为通知
+                output = json.dumps(content)
+                verbose("[server] Passing through data as-is")
+        else:
+            # 非字典类型，直接序列化
+            output = json.dumps(content)
+
+        # 写入 stdout 并立即刷新，确保 VS Code 能收到
+        sys.stdout.write(output + "\n")
+        sys.stdout.flush()
+        verbose(f"[server] Response sent to stdout: {output}")
+
+    except Exception as e:
+        error(f"[server] Error processing server message: {e}")
+        error(f"[server] 异常堆栈: {traceback.format_exc()}")
+        # 尝试发送错误响应
+        try:
+            error_resp = json.dumps({
+                "jsonrpc": "2.0",
+                "id": 1,  # 使用默认ID
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                }
+            })
+            sys.stdout.write(error_resp + "\n")
+            sys.stdout.flush()
+            verbose(f"[server] Sent error response due to: {e}")
+        except:
+            error("[server] Failed to send error response")
+
+
+async def initialize_session(session):
+    """
+    初始化 MCP 协议会话，转发上游客户端的初始化请求到下游服务器
+
+    Args:
+        session: MCP 客户端会话
+
+    Returns:
+        初始化是否成功
+    """
+    try:
+        # 关键点: 作为代理，我们不应该主动调用 session.initialize()
+        # 上游客户端会发送初始化请求，我们应该在 handle_stdin 函数中处理
+        verbose("[Runner] MCP 代理准备就绪，等待上游客户端的初始化请求...")
+        return True
+    except Exception as init_error:
+        error_msg = f"代理初始化失败: {str(init_error)}"
+        error(f"[Runner] {error_msg}")
+        return False