Add windsurf support

Author: niechen

src/mcp/cli.py

@@ -14,7 +14,7 @@
     install,
     remove,
     list_servers,
-    config,
+    edit,
     status,
     toggle,
     server,
@@ -54,15 +54,16 @@ def main(ctx, help_flag):
             " ██║ ╚═╝ ██║╚██████╗██║                               ",
             " ╚═╝     ╚═╝ ╚═════╝╚═╝                               ",
             "",
-            f"The missing Model Context Protocol Manager v{__version__}",
-            "The USB Port Manager for AI Applications"
+            f"v{__version__}",
+            "Model Context Protocol Manager for all AI apps",
+            "Supports Claude Desktop, Windsurf, and more"
         ]
 
         # No need to convert to joined string since we're formatting directly in the panel
 
         # Create a panel with styled content
         panel = Panel(
-            f"[bold green]{logo[0]}\n{logo[1]}\n{logo[2]}\n{logo[3]}\n{logo[4]}\n{logo[5]}[/]\n\n[bold yellow]{logo[7]}[/]\n[italic blue]{logo[8]}[/]",
+            f"[bold green]{logo[0]}\n{logo[1]}\n{logo[2]}\n{logo[3]}\n{logo[4]}\n{logo[5]}[/]\n\n[bold yellow]{logo[7]}[/]\n[italic blue]{logo[8]}[/]\n[bold magenta]{logo[9]}[/]",
             border_style="bold cyan",
             expand=False,
             padding=(0, 2),
@@ -71,8 +72,20 @@ def main(ctx, help_flag):
         # Print the panel
         console.print(panel)
 
+        # Get information about installed clients
+        from mcp.utils.client_detector import detect_installed_clients
+        installed_clients = detect_installed_clients()
+        
         # Display active client information and main help
-        console.print(f"[bold magenta]Active client:[/] [yellow]{active_client}[/]")
+        client_status = "[green]✓[/]" if installed_clients.get(active_client, False) else "[yellow]⚠[/]"
+        console.print(f"[bold magenta]Active client:[/] [yellow]{active_client}[/] {client_status}")
+        
+        # Display all supported clients with their installation status
+        console.print("[bold]Supported clients:[/]")
+        for client, installed in installed_clients.items():
+            status = "[green]Installed[/]" if installed else "[gray]Not installed[/]"
+            active_marker = "[bold cyan]➤[/] " if client == active_client else "  "
+            console.print(f"{active_marker}{client}: {status}")
         console.print("")
 
         # Display usage info
@@ -91,7 +104,7 @@ def main(ctx, help_flag):
         console.print("[bold]Commands:[/]")
         commands_table = Table(show_header=False, box=None, padding=(0, 2, 0, 0))
         commands_table.add_row("  [cyan]client[/]", "Manage the active MCP client.")
-        commands_table.add_row("  [cyan]config[/]", "View or edit the active MCP client's configuration file.")
+        commands_table.add_row("  [cyan]edit[/]", "View or edit the active MCP client's configuration file.")
         commands_table.add_row("  [cyan]list[/]", "List all installed MCP servers.")
         commands_table.add_row("  [cyan]remove[/]", "Remove an installed MCP server.")
         commands_table.add_row("  [cyan]server[/]", "Manage MCP server processes.")
@@ -116,7 +129,7 @@ def main(ctx, help_flag):
 main.add_command(install.install)
 main.add_command(remove.remove)
 main.add_command(list_servers.list)
-main.add_command(config.config)
+main.add_command(edit.edit)
 main.add_command(status.status)
 main.add_command(toggle.toggle)
 main.add_command(server.server)

src/mcp/clients/__init__.py

@@ -1,3 +1,8 @@
 """
 Client integrations for MCP - manages client-specific configurations
 """
+
+from mcp.clients.claude_desktop import ClaudeDesktopManager
+from mcp.clients.windsurf import WindsurfManager
+
+__all__ = ['ClaudeDesktopManager', 'WindsurfManager']

src/mcp/clients/windsurf.py

@@ -0,0 +1,95 @@
+"""
+Windsurf integration utilities for MCP
+"""
+
+import os
+import json
+import logging
+from typing import Dict, Optional, Any
+import platform
+
+logger = logging.getLogger(__name__)
+
+# Windsurf config paths based on platform
+if platform.system() == "Darwin":  # macOS
+    WINDSURF_CONFIG_PATH = os.path.expanduser("~/.codeium/windsurf/mcp_config.json")
+elif platform.system() == "Windows":
+    WINDSURF_CONFIG_PATH = os.path.join(os.environ.get("LOCALAPPDATA", ""), "Codeium", "windsurf", "mcp_config.json")
+else:
+    # Linux
+    WINDSURF_CONFIG_PATH = os.path.expanduser("~/.codeium/windsurf/mcp_config.json")
+
+class WindsurfManager:
+    """Manages Windsurf MCP server configurations"""
+    
+    def __init__(self, config_path: str = WINDSURF_CONFIG_PATH):
+        self.config_path = config_path
+        self._config = None
+        
+    def _load_config(self) -> Dict[str, Any]:
+        """Load Windsurf configuration file"""
+        if not os.path.exists(self.config_path):
+            logger.warning(f"Windsurf config file not found at: {self.config_path}")
+            return {"mcpServers": {}}
+            
+        try:
+            with open(self.config_path, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            logger.error(f"Error parsing Windsurf config file: {self.config_path}")
+            return {"mcpServers": {}}
+    
+    def _save_config(self, config: Dict[str, Any]) -> bool:
+        """Save configuration to Windsurf config file"""
+        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 saving Windsurf config: {str(e)}")
+            return False
+    
+    def get_servers(self) -> Dict[str, Any]:
+        """Get all MCP servers configured in Windsurf"""
+        config = self._load_config()
+        return config.get("mcpServers", {})
+    
+    def get_server(self, server_name: str) -> Optional[Dict[str, Any]]:
+        """Get a specific MCP server configuration"""
+        servers = self.get_servers()
+        return servers.get(server_name)
+    
+    def add_server(self, server_name: str, server_config: Dict[str, Any]) -> bool:
+        """Add or update an MCP server in Windsurf config"""
+        config = self._load_config()
+        
+        # Initialize mcpServers if it doesn't exist
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+            
+        # Add or update the server
+        config["mcpServers"][server_name] = server_config
+        
+        return self._save_config(config)
+    
+    def remove_server(self, server_name: str) -> bool:
+        """Remove an MCP server from Windsurf config"""
+        config = self._load_config()
+        
+        if "mcpServers" not in config or server_name not in config["mcpServers"]:
+            logger.warning(f"Server not found in Windsurf config: {server_name}")
+            return False
+            
+        # Remove the server
+        del config["mcpServers"][server_name]
+        
+        return self._save_config(config)
+        
+    def is_windsurf_installed(self) -> bool:
+        """Check if Windsurf is installed"""
+        # Check for the presence of the Windsurf directory
+        windsurf_dir = os.path.dirname(self.config_path)
+        return os.path.isdir(windsurf_dir)

src/mcp/commands/edit.py

@@ -0,0 +1,192 @@
+"""
+Edit command for MCP (formerly config)
+"""
+
+import os
+import json
+import click
+import subprocess
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from mcp.clients.claude_desktop import ClaudeDesktopManager
+from mcp.clients.windsurf import WindsurfManager
+from mcp.utils.config import ConfigManager
+
+console = Console()
+config_manager = ConfigManager()
+claude_manager = ClaudeDesktopManager()
+windsurf_manager = WindsurfManager()
+
+@click.command()
+@click.option("--edit", is_flag=True, help="Open the active client's config in default editor")
+@click.option("--create", is_flag=True, help="Create a basic config file if it doesn't exist")
+def edit(edit, create):
+    """View or edit the active MCP client's configuration file.
+    
+    The edit command operates on the currently active MCP client (set via 'mcp client').
+    By default, this is Claude Desktop, but can be changed to other supported clients.
+    
+    Examples:
+        mcp edit           # Show current client's config file location and content
+        mcp edit --edit    # Open the config file in your default editor
+        mcp edit --create  # Create a basic config file if it doesn't exist
+    """
+    # Get the active client and its corresponding manager
+    active_client = config_manager.get_active_client()
+    
+    # Select appropriate client manager based on active client
+    if active_client == "claude-desktop":
+        client_manager = claude_manager
+        client_name = "Claude Desktop"
+        install_url = "https://claude.ai/download"
+        is_installed_method = client_manager.is_claude_desktop_installed
+    elif active_client == "windsurf":
+        client_manager = windsurf_manager
+        client_name = "Windsurf"
+        install_url = "https://codeium.com/windsurf/download"
+        is_installed_method = client_manager.is_windsurf_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>'")
+        return
+    
+    # Get the client config file path
+    config_path = client_manager.config_path
+    
+    # Check if the client is installed
+    if not is_installed_method():
+        console.print(f"[bold red]Error:[/] {client_name} installation not detected.")
+        console.print(f"Please download and install {client_name} from {install_url}")
+        return
+        
+    # Check if config file exists
+    config_exists = os.path.exists(config_path)
+        
+    # Display the config file information
+    console.print(f"[bold]{client_name} config file:[/] {config_path}")
+    console.print(f"[bold]Status:[/] {'[green]Exists[/]' if config_exists else '[yellow]Does not exist[/]'}\n")
+    
+    # Create config file if requested and it doesn't exist
+    if not config_exists and create:
+        console.print(f"[bold yellow]Creating new {client_name} config file...[/]")
+        
+        # Create a basic config template
+        basic_config = {
+            "mcpServers": {
+                "filesystem": {
+                    "command": "npx",
+                    "args": [
+                        "-y",
+                        "@modelcontextprotocol/server-filesystem",
+                        os.path.expanduser("~/Desktop"),
+                        os.path.expanduser("~/Downloads")
+                    ]
+                }
+            }
+        }
+        
+        # Create the directory if it doesn't exist
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+        
+        # Write the template to file
+        try:
+            with open(config_path, 'w') as f:
+                json.dump(basic_config, f, indent=2)
+            console.print("[green]Successfully created config file![/]\n")
+            config_exists = True
+        except Exception as e:
+            console.print(f"[bold red]Error creating config file:[/] {str(e)}")
+            return
+    
+    # Show the current configuration if it exists
+    if config_exists:
+        try:
+            with open(config_path, 'r') as f:
+                config_content = f.read()
+                
+            # Display the content
+            console.print("[bold]Current configuration:[/]")
+            panel = Panel(config_content, title=f"{client_name} Config", expand=False)
+            console.print(panel)
+            
+            # Count the configured servers
+            try:
+                config_json = json.loads(config_content)
+                server_count = len(config_json.get("mcpServers", {}))
+                console.print(f"[bold]Configured servers:[/] {server_count}")
+                
+                # Display detailed information for each server
+                if server_count > 0:
+                    console.print("\n[bold]MCP Server Details:[/]")
+                    for server_name, server_config in config_json.get("mcpServers", {}).items():
+                        console.print(f"\n[bold cyan]{server_name}[/]")
+                        console.print(f"  Command: [green]{server_config.get('command', 'N/A')}[/]")
+                        
+                        # Display arguments
+                        args = server_config.get('args', [])
+                        if args:
+                            console.print("  Arguments:")
+                            for i, arg in enumerate(args):
+                                console.print(f"    {i}: [yellow]{arg}[/]")
+                        
+                        # Display environment variables
+                        env_vars = server_config.get('env', {})
+                        if env_vars:
+                            console.print("  Environment Variables:")
+                            for key, value in env_vars.items():
+                                console.print(f"    [bold blue]{key}[/] = [green]\"{value}\"[/]")
+                        else:
+                            console.print("  Environment Variables: [italic]None[/]")
+                        
+                        # Add a separator line
+                        console.print("  " + "-" * 50)
+                
+            except json.JSONDecodeError:
+                console.print("[yellow]Warning: Config file contains invalid JSON[/]")
+                
+        except Exception as e:
+            console.print(f"[bold red]Error reading config file:[/] {str(e)}")
+    
+    # Prompt to edit if file exists, or if we need to create it
+    should_edit = edit
+    if not should_edit and config_exists:
+        should_edit = Confirm.ask("Would you like to open this file in your default editor?")
+    elif not config_exists and not create:
+        should_create = Confirm.ask("Config file doesn't exist. Would you like to create it?")
+        if should_create:
+            # Create a basic config template
+            basic_config = {
+                "mcpServers": {}
+            }
+            
+            # Create the directory if it doesn't exist
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            
+            # Write the template to file
+            try:
+                with open(config_path, 'w') as f:
+                    json.dump(basic_config, f, indent=2)
+                console.print("[green]Successfully created config file![/]")
+                should_edit = Confirm.ask("Would you like to open it in your default editor?")
+                config_exists = True
+            except Exception as e:
+                console.print(f"[bold red]Error creating config file:[/] {str(e)}")
+                return
+    
+    # Open in default editor if requested
+    if should_edit and config_exists:
+        try:
+            console.print("[bold green]Opening config file in your default editor...[/]")
+            
+            # Use appropriate command based on platform
+            if os.name == 'nt':  # Windows
+                os.startfile(config_path)
+            elif os.name == 'posix':  # macOS and Linux
+                subprocess.run(['open', config_path] if os.uname().sysname == 'Darwin' else ['xdg-open', config_path])
+                
+            console.print(f"[italic]After editing, {client_name} must be restarted for changes to take effect.[/]")
+        except Exception as e:
+            console.print(f"[bold red]Error opening editor:[/] {str(e)}")
+            console.print(f"You can manually edit the file at: {config_path}")