auto-coder 0.1.288__py3-none-any.whl → 0.1.290__py3-none-any.whl

autocoder/common/mcp_server.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel
 import sys
 from loguru import logger
 from autocoder.utils.llms import get_single_llm
+from autocoder.chat_auto_coder_lang import get_message_with_format
 
 @dataclass
 class McpRequest:
@@ -157,55 +158,135 @@ class McpServer:
                 print(f"We have already updated the server configuration in ~/.autocoder/mcp/settings.json.\n")
                 print(f"After installation, you can restart the auto-coder.chat using the server.\033[0m\n")
 
+    def _deep_merge_dicts(self, dict1, dict2):
+        """
+        深度合并两个字典，包括嵌套的字典
+        dict1是基础字典，dict2是优先字典（当有冲突时保留dict2的值）
+        """
+        result = dict1.copy()
+        for key, value in dict2.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                # 如果两个字典都包含相同的键，并且两个值都是字典，则递归合并
+                result[key] = self._deep_merge_dicts(result[key], value)
+            else:
+                # 否则，使用dict2的值覆盖或添加到结果
+                result[key] = value
+        return result
+
+    def _parse_command_line_args(self, server_name_or_config: str) -> tuple[str, dict]:
+        """Parse command-line style arguments into name and config"""
+        name = ""
+        config = {}
+        args = server_name_or_config.strip().split()
+        i = 0
+        while i < len(args):
+            if args[i] == "--name" and i + 1 < len(args):
+                name = args[i + 1]
+                i += 2
+            elif args[i] == "--command" and i + 1 < len(args):
+                config["command"] = args[i + 1]
+                i += 2
+            elif args[i] == "--args":
+                config["args"] = []
+                i += 1
+                while i < len(args) and not args[i].startswith("--"):
+                    config["args"].append(args[i])
+                    i += 1
+            elif args[i] == "--env":
+                config["env"] = {}
+                i += 1
+                while i < len(args) and not args[i].startswith("--"):
+                    if "=" in args[i]:
+                        key, value = args[i].split("=", 1)
+                        config["env"][key] = value
+                    i += 1
+            else:
+                i += 1                
+        
+        template_config = {}
+        
+        if name in MCP_BUILD_IN_SERVERS:
+            template_config = MCP_BUILD_IN_SERVERS[name]
+        else:
+            # 查找外部server
+            external_servers = get_mcp_external_servers()
+            for s in external_servers:
+                if s.name == name:
+                    if s.runtime == "python":
+                        self._install_python_package(name)
+                        template_config = {
+                            "command": "python",
+                            "args": [
+                                "-m", name.replace("-", "_")
+                            ],
+                        }
+                    elif s.runtime == "node":
+                        self._install_node_package(name)
+                        template_config = {
+                            "command": "npx",
+                            "args": [
+                                "-y",
+                                "-g",
+                                name
+                            ]
+                        }
+                    break  
+
+        # 深度合并两个配置，以用户配置为主
+        config = self._deep_merge_dicts(template_config, config)
+
+        if not config.get("args") and (name.startswith("@") or config.get("command") in ["npx", "npm"]):
+            config["args"] = ["-y", "-g", name]            
+        
+        ## 如果有模板，则无需再次安装，处理模板的时候会自动安装
+        if not template_config:    
+            # Install package if needed
+            if name.startswith("@") or config.get("command") in ["npx", "npm"]:            
+                self._install_node_package(name)
+            else:
+                self._install_python_package(name)
+            
+        return name, config
+        
+    def _parse_json_config(self, server_name_or_config: str) -> tuple[str, dict]:
+        """Parse JSON configuration into name and config"""
+        raw_config = json.loads(server_name_or_config)
+        # 用户给了一个完整的配置
+        if "mcpServers" in raw_config:
+            raw_config = raw_config["mcpServers"]
+
+        # 取第一个server 配置
+        config = list(raw_config.values())[0]
+        name = list(raw_config.keys())[0]
+        if name.startswith("@") or config["command"] in ["npx", "npm"]:
+            for item in config["args"]:
+                if name in item:
+                    self._install_node_package(item)                    
+        else:
+            self._install_python_package(name)
+            
+        return name, config
+            
+
     async def _install_server(self, request: McpInstallRequest, hub: McpHub) -> McpResponse:
         """Install an MCP server with module dependency check"""
         name = ""
         config = {}
         try:
             server_name_or_config = request.server_name_or_config
-            try:
-                raw_config = json.loads(server_name_or_config)
-                # 用户给了一个完整的配置
-                if "mcpServers" in raw_config:
-                    raw_config = raw_config["mcpServers"]
-
-                # 取第一个server 配置
-                config = list(raw_config.values())[0]
-                name = list(raw_config.keys())[0]
-                if name.startswith("@") or config["command"] in ["npx","npm"]:
-                    for item in config["args"]:
-                        if name in item:
-                            self._install_node_package(item)                    
-                else:
-                    self._install_python_package(name)
-            except json.JSONDecodeError:
-                name = server_name_or_config.strip()
-                if name not in MCP_BUILD_IN_SERVERS:
-                    # 查找外部server
-                    external_servers = get_mcp_external_servers()
-                    for s in external_servers:
-                        if s.name == name:
-                            if s.runtime == "python":
-                                self._install_python_package(name)
-                                config = {
-                                    "command": "python",
-                                    "args": [
-                                        "-m", name.replace("-", "_")
-                                    ],
-                                }
-                            elif s.runtime == "node":
-                                self._install_node_package(name)
-                                config = {
-                                    "command": "npx",
-                                    "args": [
-                                        "-y",
-                                        "-g",
-                                        name
-                                    ]
-                                }
-                            break
-                else:
-                    config = MCP_BUILD_IN_SERVERS[name]
+            
+            # Try different parsing methods
+            if server_name_or_config.strip().startswith("--"):
+                # Command-line style arguments
+                name, config = self._parse_command_line_args(server_name_or_config)
+            else:
+                try:
+                    # Try parsing as JSON
+                    name, config = self._parse_json_config(server_name_or_config)
+                except json.JSONDecodeError:
+                    logger.error(f"Failed to parse JSON config: {server_name_or_config}")
+                    pass
+            
             if not name:
                 raise ValueError(
                     "MCP server name is not available in MCP_BUILD_IN_SERVERS or external servers")
@@ -214,10 +295,13 @@ class McpServer:
             if not config:
                 raise ValueError(f"MCP server {name} config is not available")
 
-            await hub.add_server_config(name, config)
-            return McpResponse(result=f"Successfully installed MCP server: {request.server_name_or_config}")
+            is_success = await hub.add_server_config(name, config)
+            if is_success:
+                return McpResponse(result=get_message_with_format("mcp_install_success", result=request.server_name_or_config))
+            else:
+                return McpResponse(result="", error=get_message_with_format("mcp_install_error", error="Failed to establish connection"))
         except Exception as e:
-            return McpResponse(result="", error=f"Failed to install MCP server: {str(e)}")
+            return McpResponse(result="", error=get_message_with_format("mcp_install_error", error=str(e)))
 
     async def _process_request(self):
         hub = McpHub()
@@ -236,9 +320,11 @@ class McpServer:
                 elif isinstance(request, McpRemoveRequest):
                     try:
                         await hub.remove_server_config(request.server_name)
-                        await self._response_queue.put(McpResponse(result=f"Successfully removed MCP server: {request.server_name}"))
+                        await self._response_queue.put(McpResponse(
+                            result=get_message_with_format("mcp_remove_success", result=request.server_name)))
                     except Exception as e:
-                        await self._response_queue.put(McpResponse(result="", error=f"Failed to remove MCP server: {str(e)}"))
+                        await self._response_queue.put(McpResponse(
+                            result="", error=get_message_with_format("mcp_remove_error", error=str(e))))
 
                 elif isinstance(request, McpListRequest):
                     try:
@@ -253,20 +339,22 @@ class McpServer:
 
                         # Combine results
                         all_servers = builtin_servers + external_list
-                        result = "Available MCP servers:\n" + \
-                            "\n".join(all_servers)
+                        result =  "\n".join(all_servers)
 
                         await self._response_queue.put(McpResponse(result=result))
                     except Exception as e:
-                        await self._response_queue.put(McpResponse(result="", error=f"Failed to list servers: {str(e)}"))
+                        await self._response_queue.put(McpResponse(
+                            result="", error=get_message_with_format("mcp_list_builtin_error", error=str(e))))
 
                 elif isinstance(request, McpListRunningRequest):
                     try:
                         running_servers = "\n".join(
                             [f"- {server.name}" for server in hub.get_servers()])
-                        await self._response_queue.put(McpResponse(result=running_servers))
+                        result = running_servers if running_servers else ""
+                        await self._response_queue.put(McpResponse(result=result))
                     except Exception as e:
-                        await self._response_queue.put(McpResponse(result="", error=f"Failed to list running servers: {str(e)}"))
+                        await self._response_queue.put(McpResponse(
+                            result="", error=get_message_with_format("mcp_list_running_error", error=str(e))))
 
                 elif isinstance(request, McpRefreshRequest):
                     try:
@@ -274,23 +362,36 @@ class McpServer:
                             await hub.refresh_server_connection(request.name)
                         else:
                             await hub.initialize()
-                        await self._response_queue.put(McpResponse(result="Successfully refreshed MCP server connections"))
+                        await self._response_queue.put(McpResponse(
+                            result=get_message_with_format("mcp_refresh_success")))
                     except Exception as e:
-                        await self._response_queue.put(McpResponse(result="", error=f"Failed to refresh MCP servers: {str(e)}"))
+                        await self._response_queue.put(McpResponse(
+                            result="", error=get_message_with_format("mcp_refresh_error", error=str(e))))
 
                 else:
-                    llm = get_single_llm(request.model,product_mode=request.product_mode)
+                    if not request.query.strip():
+                        await self._response_queue.put(McpResponse(
+                            result="", error=get_message_with_format("mcp_query_empty")))
+                        continue
+                        
+                    llm = get_single_llm(request.model, product_mode=request.product_mode)
                     mcp_executor = McpExecutor(hub, llm)
                     conversations = [
                         {"role": "user", "content": request.query}]
                     _, results = await mcp_executor.run(conversations)
+                    
                     if not results:
-                        await self._response_queue.put(McpResponse(result="[No Result]", error="No results"))
-                    results_str = "\n\n".join(
-                        mcp_executor.format_mcp_result(result) for result in results)
-                    await self._response_queue.put(McpResponse(result=results_str))
+                        await self._response_queue.put(McpResponse(
+                            result=get_message_with_format("mcp_error_title"), 
+                            error="No results"))
+                    else:
+                        results_str = "\n\n".join(
+                            mcp_executor.format_mcp_result(result) for result in results)
+                        await self._response_queue.put(McpResponse(
+                            result=get_message_with_format("mcp_response_title") + "\n" + results_str))
             except Exception as e:
-                await self._response_queue.put(McpResponse(result="", error=str(e)))
+                await self._response_queue.put(McpResponse(
+                    result="", error=get_message_with_format("mcp_error_title") + ": " + str(e)))
 
     def send_request(self, request: McpRequest) -> McpResponse:
         async def _send():