feat: add client support for vscode (#147)

Author: JoJoJoJoJoJoJo

README.md

@@ -54,6 +54,7 @@ MCPM will support managing MCP servers for the following clients:
 - 🤖 Claude Desktop (Anthropic)
 - ⌨️ Cursor
 - 🏄 Windsurf
+- 🧩 Vscode
 - 📝 Cline
 - ➡️ Continue
 - 🦢 Goose

README.zh-CN.md

@@ -88,6 +88,7 @@ MCPM 将支持为以下客户端管理 MCP 服务器：
 - 🤖 Claude Desktop (Anthropic)
 - ⌨️ Cursor
 - 🏄 Windsurf
+- 🧩 Vscode
 - 📝 Cline
 - ➡️ Continue
 - 🦢 Goose

src/mcpm/clients/client_registry.py

@@ -17,6 +17,7 @@
 from mcpm.clients.managers.fiveire import FiveireManager
 from mcpm.clients.managers.goose import GooseClientManager
 from mcpm.clients.managers.trae import TraeManager
+from mcpm.clients.managers.vscode import VSCodeManager
 from mcpm.clients.managers.windsurf import WindsurfManager
 
 logger = logging.getLogger(__name__)
@@ -42,6 +43,7 @@ class ClientRegistry:
         "5ire": FiveireManager(),
         "roo-code": RooCodeManager(),
         "trae": TraeManager(),
+        "vscode": VSCodeManager(),
     }
 
     @classmethod

src/mcpm/clients/managers/fiveire.py

@@ -1,8 +1,7 @@
-import json
 import logging
 import os
 import re
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Optional
 
 from pydantic import TypeAdapter
 
@@ -18,8 +17,6 @@ class FiveireManager(JSONClientManager):
     display_name = "5ire"
     download_url = "https://5ire.app/"
 
-    configure_key_name = "servers"
-
     def __init__(self, config_path=None):
         """Initialize the 5ire client manager
 
@@ -40,124 +37,35 @@ def __init__(self, config_path=None):
                 # Linux
                 self.config_path = os.path.expanduser("~/.config/5ire/mcp.json")
 
+        self.server_name_key = {}
+
     def _get_empty_config(self) -> Dict[str, Any]:
         """Get an empty configuration structure for this client
 
         Returns:
             Dict containing the client configuration with at least {"servers": []}
         """
-        return {self.configure_key_name: []}
-
-    def _load_config(self) -> Dict[str, Any]:
-        """Load client configuration file
-
-        Returns:
-            Dict containing the client configuration with at least {"servers": []}
-        """
-        # Create empty config with the correct structure
-        empty_config = self._get_empty_config()
-
-        if not os.path.exists(self.config_path):
-            logger.warning(f"Client config file not found at: {self.config_path}")
-            return empty_config
-
-        try:
-            with open(self.config_path, "r", encoding="utf-8") as f:
-                config = json.load(f)
-                # Ensure servers section exists
-                if self.configure_key_name not in config:
-                    config[self.configure_key_name] = []
-                return config
-        except json.JSONDecodeError:
-            logger.error(f"Error parsing client config file: {self.config_path}")
-
-            # Backup the corrupt file
-            if os.path.exists(self.config_path):
-                backup_path = f"{self.config_path}.bak"
-                try:
-                    os.rename(self.config_path, backup_path)
-                    logger.info(f"Backed up corrupt config file to: {backup_path}")
-                except Exception as e:
-                    logger.error(f"Failed to backup corrupt file: {str(e)}")
-
-            # Return empty config
-            return empty_config
-
-    def get_servers(self) -> Dict[str, Any]:
-        """Get all MCP servers configured for this client
-
-        Returns:
-            Dict of server configurations by name
-        """
-        config = self._load_config()
-        servers = {}
-
-        # Convert list of servers to dictionary by name
-        for server in config.get(self.configure_key_name, []):
-            if "name" in server:
-                servers[server["name"]] = server
-
-        return servers
-
-    def get_server(self, server_name: str) -> Optional[ServerConfig]:
-        """Get a server configuration
+        return {"mcpServers": {}}
 
-        Args:
-            server_name: Name of the server
-
-        Returns:
-            ServerConfig object if found, None otherwise
-        """
+    def _update_server_name_key(self):
+        self.server_name_key = {}
         servers = self.get_servers()
+        for key, server_config in servers.items():
+            self.server_name_key[server_config.get("name", key)] = key
 
-        # Check if the server exists
-        if server_name not in servers:
-            logger.debug(f"Server {server_name} not found in {self.display_name} config")
-            return None
-
-        # Get the server config and convert to ServerConfig
-        return servers[server_name]
-
-    def add_server(self, server_config: Union[ServerConfig, Dict[str, Any]], name: Optional[str] = None) -> bool:
-        """Add or update a server in the client config
-
-        Args:
-            server_config: ServerConfig object or dictionary in client format
-            name: Required server name when using dictionary format
-
-        Returns:
-            bool: Success or failure
-        """
-        # Handle direct dictionary input
-        if isinstance(server_config, dict):
-            if name is None:
-                raise ValueError("Name must be provided when using dictionary format")
-            server_name = name
-            client_config = server_config  # Already in client format
-        # Handle ServerConfig objects
-        else:
-            server_name = server_config.name
-            client_config = self.to_client_format(server_config)
-            client_config["name"] = server_name  # Ensure name is in the config
-
-        # Update config
-        config = self._load_config()
-
-        # Check if server already exists and update it
-        server_exists = False
-        for i, server in enumerate(config.get(self.configure_key_name, [])):
-            if server.get("name") == server_name:
-                config[self.configure_key_name][i] = client_config
-                server_exists = True
-                break
-
-        # If server doesn't exist, add it
-        if not server_exists:
-            if self.configure_key_name not in config:
-                config[self.configure_key_name] = []
-            config[self.configure_key_name].append(client_config)
+    def get_server(self, server_name: str) -> Optional[ServerConfig]:
+        self._update_server_name_key()
+        key = self.server_name_key.get(server_name)
+        if key:
+            return super().get_server(key)
+        return None
 
-        return self._save_config(config)
+    def remove_server(self, server_name: str) -> bool:
+        self._update_server_name_key()
+        key = self.server_name_key.get(server_name)
+        if key:
+            return super().remove_server(key)
+        return False
 
     def to_client_format(self, server_config: ServerConfig) -> Dict[str, Any]:
         """Convert ServerConfig to client-specific format
@@ -179,8 +87,10 @@ def to_client_format(self, server_config: ServerConfig) -> Dict[str, Any]:
             non_empty_env = server_config.get_filtered_env_vars(os.environ)
             if non_empty_env:
                 result["env"] = non_empty_env
+            result["type"] = "local"
         else:
             result = server_config.to_dict()
+            result["type"] = "remote"
 
         # Base result containing essential information
         key_slug = re.sub(r"[^a-zA-Z0-9]", "", server_config.name)
@@ -214,39 +124,6 @@ def from_client_format(cls, server_name: str, client_config: Dict[str, Any]) ->
         server_data.update(client_config)
         return TypeAdapter(ServerConfig).validate_python(server_data)
 
-    def list_servers(self) -> List[str]:
-        """List all MCP servers in client config
-
-        Returns:
-            List of server names
-        """
-        return list(self.get_servers().keys())
-
-    def remove_server(self, server_name: str) -> bool:
-        """Remove an MCP server from client config
-
-        Args:
-            server_name: Name of the server to remove
-
-        Returns:
-            bool: Success or failure
-        """
-        config = self._load_config()
-
-        # Find and remove the server
-        server_found = False
-        for i, server in enumerate(config.get(self.configure_key_name, [])):
-            if server.get("name") == server_name:
-                config[self.configure_key_name].pop(i)
-                server_found = True
-                break
-
-        if not server_found:
-            logger.warning(f"Server {server_name} not found in {self.display_name} config")
-            return False
-
-        return self._save_config(config)
-
     def disable_server(self, server_name: str) -> bool:
         """Temporarily disable a server by setting isActive to False
 
@@ -258,18 +135,12 @@ def disable_server(self, server_name: str) -> bool:
         """
         config = self._load_config()
 
-        # Find and disable the server
-        server_found = False
-        for i, server in enumerate(config.get(self.configure_key_name, [])):
-            if server.get("name") == server_name:
-                config[self.configure_key_name][i]["isActive"] = False
-                server_found = True
-                break
-
-        if not server_found:
-            logger.warning(f"Server {server_name} not found in {self.display_name} config")
+        if "mcpServers" not in config or server_name not in config["mcpServers"]:
+            logger.warning(f"Server '{server_name}' not found in active servers")
             return False
 
+        config["mcpServers"][server_name]["isActive"] = False
+
         return self._save_config(config)
 
     def enable_server(self, server_name: str) -> bool:
@@ -283,18 +154,12 @@ def enable_server(self, server_name: str) -> bool:
         """
         config = self._load_config()
 
-        # Find and enable the server
-        server_found = False
-        for i, server in enumerate(config.get(self.configure_key_name, [])):
-            if server.get("name") == server_name:
-                config[self.configure_key_name][i]["isActive"] = True
-                server_found = True
-                break
-
-        if not server_found:
-            logger.warning(f"Server {server_name} not found in {self.display_name} config")
+        if "mcpServers" not in config or server_name not in config["mcpServers"]:
+            logger.warning(f"Server '{server_name}' not found in active servers")
             return False
 
+        config["mcpServers"][server_name]["isActive"] = True
+
         return self._save_config(config)
 
     def is_server_disabled(self, server_name: str) -> bool:

src/mcpm/clients/managers/vscode.py

@@ -0,0 +1,98 @@
+import json
+import logging
+import os
+import traceback
+from typing import Any, Dict
+
+from mcpm.clients.base import JSONClientManager
+
+logger = logging.getLogger(__name__)
+
+
+class VSCodeManager(JSONClientManager):
+    """Manages VSCode MCP server configurations"""
+
+    # Client information
+    client_key = "vscode"
+    display_name = "VSCode"
+    download_url = "https://code.visualstudio.com/"
+    configure_key_name = "servers"
+
+    def __init__(self, config_path=None):
+        super().__init__()
+
+        if config_path:
+            self.config_path = config_path
+        else:
+            # Set config path based on detected platform
+            if self._system == "Windows":
+                self.config_path = os.path.join(os.environ.get("APPDATA", ""), "Code", "User", "settings.json")
+            elif self._system == "Darwin":
+                self.config_path = os.path.expanduser("~/Library/Application Support/Code/User/settings.json")
+            else:
+                # MacOS or Linux
+                self.config_path = os.path.expanduser("~/.config/Code/User/settings.json")
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load client configuration file
+
+        {
+            "mcp": {
+                "servers": {
+                    "server_name": {
+                        ...
+                    }
+                }
+            }
+        }
+
+        Returns:
+            Dict containing the client configuration with at least {"mcpServers": {}}
+        """
+        # Create empty config with the correct structure
+        empty_config = {"mcp": {self.configure_key_name: {}}}
+
+        if not os.path.exists(self.config_path):
+            logger.warning(f"Client config file not found at: {self.config_path}")
+            return empty_config
+
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+                if "mcp" not in config:
+                    config["mcp"] = {}
+                # Ensure mcpServers section exists
+                if self.configure_key_name not in config["mcp"]:
+                    config["mcp"][self.configure_key_name] = {}
+                return config["mcp"]
+        except json.JSONDecodeError:
+            logger.error(f"Error parsing client config file: {self.config_path}")
+
+        # Vscode config includes other information, so we makes no change on it
+        return empty_config
+
+    def _save_config(self, config: Dict[str, Any]) -> bool:
+        """Save configuration to client config file
+
+        Args:
+            config: Configuration to save
+
+        Returns:
+            bool: Success or failure
+        """
+        try:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
+            if not os.path.exists(self.config_path):
+                current_config = {}
+            else:
+                with open(self.config_path, "r", encoding="utf-8") as f:
+                    current_config = json.load(f)
+            current_config["mcp"] = config
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump(current_config, f, indent=2)
+            return True
+        except Exception as e:
+            logger.error(f"Error saving client config: {str(e)}")
+            traceback.print_exc()
+            return False