Create client_manager

Author: niechen

src/mcpm/commands/add.py

@@ -12,53 +12,36 @@
 from rich.prompt import Confirm
 
 from mcpm.utils.repository import RepositoryManager
-from mcpm.clients.windsurf import WindsurfManager
-from mcpm.clients.claude_desktop import ClaudeDesktopManager 
-from mcpm.clients.cursor import CursorManager
 from mcpm.utils.server_config import ServerConfig
-from mcpm.utils.config import ConfigManager
+from mcpm.utils.client_manager import get_active_client, get_active_client_manager, get_active_client_info
 
 console = Console()
 repo_manager = RepositoryManager()
-config_manager = ConfigManager()
-
-# Map of client names to their manager classes
-CLIENT_MANAGERS = {
-    "windsurf": WindsurfManager,
-    "claude-desktop": ClaudeDesktopManager,
-    "cursor": CursorManager
-}
 
 @click.command()
 @click.argument("server_name")
-@click.option("--client", "-c", help="Client to add the server to (windsurf, claude-desktop, cursor)")
 @click.option("--force", is_flag=True, help="Force reinstall if server is already installed")
-def add(server_name, client=None, force=False):
+def add(server_name, force=False):
     """Add an MCP server to a client configuration.
     
     Examples:
         mcpm add time
-        mcpm add github --client windsurf
         mcpm add everything --force
     """
-    # If no client is specified, use the active client
+    # Get the active client info
+    client = get_active_client()
     if not client:
-        client = config_manager.get_active_client()
-        if not client:
-            console.print("[bold red]Error:[/] No active client found.")
-            console.print("Please specify a client with --client option or set an active client with 'mcpm client set <client>'.")
-            return
-        console.print(f"[yellow]Using active client: {client}[/]")
+        console.print("[bold red]Error:[/] No active client found.")
+        console.print("Please set an active client with 'mcpm client set <client>'.")
+        return
+    console.print(f"[yellow]Using active client: {client}[/]")
 
-    # Verify client is valid
-    if client not in CLIENT_MANAGERS:
+    # Get client manager
+    client_manager = get_active_client_manager()
+    if client_manager is None:
         console.print(f"[bold red]Error:[/] Unsupported client '{client}'.")
-        console.print(f"Supported clients: {', '.join(CLIENT_MANAGERS.keys())}")
         return
 
-    # Initialize client manager
-    client_manager = CLIENT_MANAGERS[client]()
-    
     # Check if server already exists in client config
     existing_server = client_manager.get_server(server_name)
     if existing_server and not force:
@@ -87,8 +70,11 @@ def add(server_name, client=None, force=False):
         author_url = author_info.get("url", "")
         console.print(f"[dim]Author: {author_name} {author_url}[/]")
 
+    # Get client display name from the utility
+    _, client_display_name, _ = get_active_client_info()
+    
     # Confirm addition
-    if not force and not Confirm.ask(f"Add this server to {client}?"):
+    if not force and not Confirm.ask(f"Add this server to {client_display_name}?"):
         console.print("[yellow]Operation cancelled.[/]")
         return
 
@@ -343,9 +329,8 @@ def add(server_name, client=None, force=False):
     success = client_manager.add_server(server_config)
 
     if success:
-        # Update the central tracking of enabled servers for this client
-        config_manager.enable_server_for_client(server_name, client)
-        console.print(f"[bold green]Successfully added {display_name} v{version} to {client}![/]")
+        # Server has been successfully added to the client configuration
+        console.print(f"[bold green]Successfully added {display_name} v{version} to {client_display_name}![/]")
 
         # Display usage examples if available
         examples = server_metadata.get("examples", [])

src/mcpm/commands/edit.py

@@ -10,16 +10,9 @@
 from rich.panel import Panel
 from rich.prompt import Confirm
 
-from mcpm.clients.claude_desktop import ClaudeDesktopManager
-from mcpm.clients.windsurf import WindsurfManager
-from mcpm.clients.cursor import CursorManager
-from mcpm.utils.config import ConfigManager
+from mcpm.utils.client_manager import get_active_client_info
 
 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")
@@ -35,37 +28,21 @@ def edit(edit, create):
         mcpm edit --edit    # Open the config file in your default editor
         mcpm 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()
+    # Get the active client manager and related information
+    client_manager, client_name, install_url = get_active_client_info()
 
-    # 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
-    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}")
+    # Check if client is supported
+    if client_manager is None:
+        console.print("[bold red]Error:[/] Unsupported active client")
         console.print("Please switch to a supported client using 'mcpm 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():
+    if not client_manager.is_client_installed():
         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

src/mcpm/utils/client_manager.py

@@ -0,0 +1,106 @@
+"""
+Client manager utilities for MCPM
+"""
+
+from typing import Optional, Tuple
+
+from mcpm.clients.claude_desktop import ClaudeDesktopManager
+from mcpm.clients.windsurf import WindsurfManager
+from mcpm.clients.cursor import CursorManager
+from mcpm.clients.base import BaseClientManager
+from mcpm.utils.config import ConfigManager
+
+# Create client manager instances
+claude_manager = ClaudeDesktopManager()
+windsurf_manager = WindsurfManager()
+cursor_manager = CursorManager()
+
+# Create config manager instance
+config_manager = ConfigManager()
+
+# Client manager mapping
+CLIENT_MANAGERS = {
+    "claude-desktop": claude_manager,
+    "windsurf": windsurf_manager,
+    "cursor": cursor_manager
+}
+
+# Client display names
+CLIENT_DISPLAY_NAMES = {
+    "claude-desktop": "Claude Desktop",
+    "windsurf": "Windsurf",
+    "cursor": "Cursor"
+}
+
+# Client download URLs
+CLIENT_URLS = {
+    "claude-desktop": "https://claude.ai/download",
+    "windsurf": "https://codeium.com/windsurf/download",
+    "cursor": "https://cursor.sh/download"
+}
+
+def get_client_manager(client_name: str) -> Optional[BaseClientManager]:
+    """
+    Get the client manager for a given client name
+    
+    Args:
+        client_name: Name of the client
+        
+    Returns:
+        BaseClientManager: Client manager instance or None if not found
+    """
+    return CLIENT_MANAGERS.get(client_name)
+
+def get_client_info(client_name: str) -> Tuple[Optional[BaseClientManager], str, str]:
+    """
+    Get client manager and related information
+    
+    Args:
+        client_name: Name of the client
+        
+    Returns:
+        Tuple containing:
+            - BaseClientManager: Client manager instance or None if not found
+            - str: Display name of the client
+            - str: Download URL for the client
+    """
+    client_manager = get_client_manager(client_name)
+    display_name = CLIENT_DISPLAY_NAMES.get(client_name, client_name)
+    download_url = CLIENT_URLS.get(client_name, "")
+    
+    return client_manager, display_name, download_url
+
+
+def get_active_client() -> str:
+    """
+    Get the active client name from the config manager
+    
+    Returns:
+        str: Name of the active client
+    """
+    return config_manager.get_active_client()
+
+
+def get_active_client_manager() -> Optional[BaseClientManager]:
+    """
+    Get the client manager for the active client
+    
+    Returns:
+        BaseClientManager: Client manager instance for the active client, or None if not found
+    """
+    active_client = get_active_client()
+    return get_client_manager(active_client)
+
+
+def get_active_client_info() -> Tuple[Optional[BaseClientManager], str, str]:
+    """
+    Get the client manager and related information for the active client
+    
+    Returns:
+        Tuple containing:
+            - BaseClientManager: Client manager instance or None if not found
+            - str: Display name of the client
+            - str: Download URL for the client
+    """
+    active_client = get_active_client()
+    return get_client_info(active_client)