Add cursor client

Author: niechen

README.md

@@ -70,6 +70,7 @@ mcp status                  # Show status of MCP servers in Claude Desktop
 - [ ] Server repository structure
 - [ ] Server management functionality
 - [ ] Additional client support
+- [ ] MCP profiles - collections of tools that can be added to any clients with a single command
 
 ## Development
 

src/mcp/cli.py

@@ -57,7 +57,7 @@ def main(ctx, help_flag):
             "",
             f"v{__version__}",
             "MCP Manager for all AI apps",
-            "Supports Claude Desktop, Windsurf, and more"
+            "Supports Claude Desktop, Windsurf, Cursor, and more"
         ]
 
         # No need to convert to joined string since we're formatting directly in the panel

src/mcp/clients/cursor.py

@@ -0,0 +1,108 @@
+"""
+Cursor client configuration for MCP
+"""
+
+import os
+import json
+import logging
+from typing import Dict, Any, List, Optional
+
+# Cursor stores MCP configuration in:
+# - Project config: .cursor/mcp.json in the project directory
+# - Global config: ~/.cursor/mcp.json in the home directory
+
+# Global config path for Cursor
+HOME_DIR = os.path.expanduser("~")
+CURSOR_CONFIG_PATH = os.path.join(HOME_DIR, ".cursor", "mcp.json")
+
+logger = logging.getLogger(__name__)
+
+# Get the project config path for Cursor
+def get_project_config_path(project_dir: str) -> str:
+    """
+    Get the project-specific MCP configuration path for Cursor
+    
+    Args:
+        project_dir (str): Project directory path
+        
+    Returns:
+        str: Path to the project-specific MCP configuration file
+    """
+    return os.path.join(project_dir, ".cursor", "mcp.json")
+
+
+class CursorManager:
+    """Manages Cursor client configuration for MCP"""
+    
+    def __init__(self):
+        self.config_path = CURSOR_CONFIG_PATH
+    
+    def is_cursor_installed(self) -> bool:
+        """Check if Cursor is installed"""
+        return os.path.isdir(os.path.dirname(self.config_path))
+    
+    def read_config(self) -> Optional[Dict[str, Any]]:
+        """Read the Cursor MCP configuration"""
+        if not os.path.exists(self.config_path):
+            return None
+            
+        try:
+            with open(self.config_path, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logger.error(f"Error parsing Cursor config file: {self.config_path}")
+            return None
+        except Exception as e:
+            logger.error(f"Error reading Cursor config file: {str(e)}")
+            return None
+    
+    def write_config(self, config: Dict[str, Any]) -> bool:
+        """Write the Cursor MCP configuration"""
+        try:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
+            
+            with open(self.config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            return True
+        except Exception as e:
+            logger.error(f"Error writing Cursor config file: {str(e)}")
+            return False
+    
+    def create_default_config(self) -> Dict[str, Any]:
+        """Create a default Cursor MCP configuration"""
+        return {
+            "mcpServers": {}
+        }
+    
+    def sync_mcp_servers(self, servers: List[Dict[str, Any]]) -> bool:
+        """Sync MCP servers to Cursor configuration"""
+        config = self.read_config() or self.create_default_config()
+        
+        # Update mcpServers section
+        for server in servers:
+            name = server.get("name")
+            if name:
+                config.setdefault("mcpServers", {})[name] = {
+                    "command": server.get("command", ""),
+                    "args": server.get("args", []),
+                }
+                
+                # Add environment variables if present
+                if "env" in server and server["env"]:
+                    config["mcpServers"][name]["env"] = server["env"]
+        
+        # Write updated config
+        return self.write_config(config)
+        
+    def get_servers(self) -> Dict[str, Any]:
+        """Get MCP servers from Cursor configuration
+        
+        Returns:
+            Dict[str, Any]: Dictionary mapping server names to their configurations
+        """
+        config = self.read_config()
+        if not config:
+            return {}
+            
+        return config.get("mcpServers", {})

src/mcp/commands/edit.py

@@ -12,12 +12,14 @@
 
 from mcp.clients.claude_desktop import ClaudeDesktopManager
 from mcp.clients.windsurf import WindsurfManager
+from mcp.clients.cursor import CursorManager
 from mcp.utils.config import ConfigManager
 
 console = Console()
 config_manager = ConfigManager()
 claude_manager = ClaudeDesktopManager()
 windsurf_manager = WindsurfManager()
+cursor_manager = CursorManager()
 
 @click.command()
 @click.option("--edit", is_flag=True, help="Open the active client's config in default editor")
@@ -47,6 +49,11 @@ def edit(edit, create):
         client_name = "Windsurf"
         install_url = "https://codeium.com/windsurf/download"
         is_installed_method = client_manager.is_windsurf_installed
+    elif active_client == "cursor":
+        client_manager = cursor_manager
+        client_name = "Cursor"
+        install_url = "https://cursor.sh/download"
+        is_installed_method = client_manager.is_cursor_installed
     else:
         console.print(f"[bold red]Error:[/] Unsupported active client: {active_client}")
         console.print("Please switch to a supported client using 'mcp client <client-name>'")

src/mcp/commands/list_servers.py

@@ -9,12 +9,14 @@
 
 from mcp.clients.claude_desktop import ClaudeDesktopManager
 from mcp.clients.windsurf import WindsurfManager
+from mcp.clients.cursor import CursorManager
 from mcp.utils.config import ConfigManager
 
 console = Console()
 config_manager = ConfigManager()
 claude_manager = ClaudeDesktopManager()
 windsurf_manager = WindsurfManager()
+cursor_manager = CursorManager()
 
 @click.command(name="list")
 @click.option("--available", is_flag=True, help="List all available MCP servers")
@@ -62,6 +64,9 @@ def list(available, outdated):
         elif active_client == "windsurf":
             client_manager = windsurf_manager
             client_name = "Windsurf"
+        elif active_client == "cursor":
+            client_manager = cursor_manager
+            client_name = "Cursor"
         else:
             console.print(f"[bold red]Error:[/] Unsupported active client: {active_client}")
             console.print("Please switch to a supported client using 'mcp client <client-name>'")
@@ -125,6 +130,9 @@ def list(available, outdated):
         elif active_client == "windsurf":
             client_manager = windsurf_manager
             client_name = "Windsurf"
+        elif active_client == "cursor":
+            client_manager = cursor_manager
+            client_name = "Cursor"
         else:
             console.print(f"[bold red]Error:[/] Unsupported active client: {active_client}")
             console.print("Please switch to a supported client using 'mcp client <client-name>'")

src/mcp/utils/client_detector.py

@@ -7,6 +7,7 @@
 
 from mcp.clients.claude_desktop import CLAUDE_CONFIG_PATH
 from mcp.clients.windsurf import WINDSURF_CONFIG_PATH
+from mcp.clients.cursor import CURSOR_CONFIG_PATH
 
 def detect_installed_clients() -> Dict[str, bool]:
     """
@@ -18,10 +19,12 @@ def detect_installed_clients() -> Dict[str, bool]:
     claude_installed = os.path.isdir(os.path.dirname(CLAUDE_CONFIG_PATH))
     windsurf_installed = os.path.isdir(os.path.dirname(WINDSURF_CONFIG_PATH))
 
+    cursor_installed = os.path.isdir(os.path.dirname(CURSOR_CONFIG_PATH))
+    
     return {
         "claude-desktop": claude_installed,
         "windsurf": windsurf_installed,
-        "cursor": False  # Not implemented yet
+        "cursor": cursor_installed
     }
 
 def get_client_config_paths() -> Dict[str, str]:
@@ -33,7 +36,8 @@ def get_client_config_paths() -> Dict[str, str]:
     """
     return {
         "claude-desktop": CLAUDE_CONFIG_PATH,
-        "windsurf": WINDSURF_CONFIG_PATH
+        "windsurf": WINDSURF_CONFIG_PATH,
+        "cursor": CURSOR_CONFIG_PATH
     }
 
 def get_client_display_info() -> Dict[str, Dict[str, str]]:
@@ -57,7 +61,7 @@ def get_client_display_info() -> Dict[str, Dict[str, str]]:
         "cursor": {
             "name": "Cursor",
             "download_url": "https://cursor.sh/download",
-            "config_file": "" # Not implemented yet
+            "config_file": CURSOR_CONFIG_PATH
         }
     }
 

src/mcp/utils/config.py

@@ -59,14 +59,17 @@ def _default_config(self) -> Dict[str, Any]:
             "clients": {
                 "claude-desktop": {
                     "enabled_servers": [],
+                    "disabled_servers": {},
                     "installed": installed_clients.get("claude-desktop", False)
                 },
                 "cursor": {
                     "enabled_servers": [],
+                    "disabled_servers": {},
                     "installed": installed_clients.get("cursor", False)
                 },
                 "windsurf": {
                     "enabled_servers": [],
+                    "disabled_servers": {},
                     "installed": installed_clients.get("windsurf", False)
                 }
             }
@@ -111,7 +114,11 @@ def unregister_server(self, server_name: str) -> None:
             self._save_config()
 
     def enable_server_for_client(self, server_name: str, client_name: str) -> bool:
-        """Enable a server for a specific client"""
+        """Enable a server for a specific client
+        
+        If the server was previously disabled for this client, its configuration
+        will be restored from the disabled_servers section.
+        """
         if server_name not in self._config.get("servers", {}):
             logger.error(f"Server not installed: {server_name}")
             return False
@@ -120,22 +127,90 @@ def enable_server_for_client(self, server_name: str, client_name: str) -> bool:
             logger.error(f"Unknown client: {client_name}")
             return False
 
-        enabled_servers = self._config["clients"][client_name].setdefault("enabled_servers", [])
+        client_config = self._config["clients"][client_name]
+        enabled_servers = client_config.setdefault("enabled_servers", [])
+        disabled_servers = client_config.setdefault("disabled_servers", {})
+        
+        # Check if we have the server in disabled servers and can restore its config
+        if server_name in disabled_servers:
+            # Find the appropriate client manager to update config
+            if client_name == "claude-desktop":
+                from mcp.clients.claude_desktop import ClaudeDesktopManager
+                client_manager = ClaudeDesktopManager()
+            elif client_name == "windsurf":
+                from mcp.clients.windsurf import WindsurfManager
+                client_manager = WindsurfManager()
+            elif client_name == "cursor":
+                from mcp.clients.cursor import CursorManager
+                client_manager = CursorManager()
+            else:
+                # Unknown client type, but we'll still track in our config
+                pass
+                
+            # If we have a client manager, update its config
+            if 'client_manager' in locals():
+                server_config = disabled_servers[server_name]
+                server_list = [server_config]
+                client_manager.sync_mcp_servers(server_list)
+                
+            # Remove from disabled list
+            del disabled_servers[server_name]
+        
         if server_name not in enabled_servers:
             enabled_servers.append(server_name)
             self._save_config()
 
         return True
 
     def disable_server_for_client(self, server_name: str, client_name: str) -> bool:
-        """Disable a server for a specific client"""
+        """Disable a server for a specific client
+        
+        This saves the server's configuration to the disabled_servers section
+        so it can be restored later if re-enabled.
+        """
         if client_name not in self._config.get("clients", {}):
             logger.error(f"Unknown client: {client_name}")
             return False
 
-        enabled_servers = self._config["clients"][client_name].get("enabled_servers", [])
+        client_config = self._config["clients"][client_name]
+        enabled_servers = client_config.get("enabled_servers", [])
+        disabled_servers = client_config.setdefault("disabled_servers", {})
+        
+        # Only proceed if the server is currently enabled
         if server_name in enabled_servers:
+            # Save the server configuration to disabled_servers
+            server_info = self._config.get("servers", {}).get(server_name, {})
+            if server_info:
+                disabled_servers[server_name] = server_info.copy()
+            
+            # Remove from enabled list
             enabled_servers.remove(server_name)
+            
+            # Find the appropriate client manager to update config
+            if client_name == "claude-desktop":
+                from mcp.clients.claude_desktop import ClaudeDesktopManager
+                client_manager = ClaudeDesktopManager()
+            elif client_name == "windsurf":
+                from mcp.clients.windsurf import WindsurfManager
+                client_manager = WindsurfManager()
+            elif client_name == "cursor":
+                from mcp.clients.cursor import CursorManager
+                client_manager = CursorManager()
+            else:
+                # Unknown client type, but we'll still track in our config
+                pass
+            
+            # If we have a client manager, update its config to remove the server
+            if 'client_manager' in locals():
+                # Get current client config
+                client_config = client_manager.read_config() or {}
+                
+                # For cursor, the structure is slightly different
+                if client_name == "cursor" and "mcpServers" in client_config:
+                    if server_name in client_config["mcpServers"]:
+                        del client_config["mcpServers"][server_name]
+                        client_manager.write_config(client_config)
+                
             self._save_config()
 
         return True