change toggle to stash/pop and more clean up

Author: niechen

src/mcpm/cli.py

@@ -14,7 +14,8 @@
     remove,
     list,
     edit,
-    toggle,
+    stash,
+    pop,
     server,
     client,
     inspector,
@@ -111,7 +112,8 @@ def main(ctx, help_flag):
         commands_table.add_row("  [cyan]remove[/]", "Remove an installed MCP server.")
         commands_table.add_row("  [cyan]search[/]", "Search available MCP servers.")
         commands_table.add_row("  [cyan]server[/]", "Manage MCP server processes.")
-        commands_table.add_row("  [cyan]toggle[/]", "Toggle an MCP server on or off for a client.")
+        commands_table.add_row("  [cyan]stash[/]", "Temporarily store a server configuration aside.")
+        commands_table.add_row("  [cyan]pop[/]", "Restore a previously stashed server configuration.")
         console.print(commands_table)
 
 
@@ -127,7 +129,8 @@ def main(ctx, help_flag):
 main.add_command(list.list)
 main.add_command(edit.edit)
 
-main.add_command(toggle.toggle)
+main.add_command(stash.stash)
+main.add_command(pop.pop)
 main.add_command(server.server)
 main.add_command(client.client)
 main.add_command(inspector.inspector, name="inspector")

src/mcpm/clients/base.py

@@ -201,3 +201,39 @@ def is_client_installed(self) -> bool:
         # Default implementation - can be overridden by subclasses
         client_dir = os.path.dirname(self.config_path)
         return os.path.isdir(client_dir)
+        
+    def disable_server(self, server_name: str) -> bool:
+        """Temporarily disable (stash) a server without removing its configuration
+        
+        Args:
+            server_name: Name of the server to disable
+            
+        Returns:
+            bool: Success or failure
+        """
+        # To be implemented by subclasses
+        raise NotImplementedError("Subclasses must implement disable_server")
+    
+    def enable_server(self, server_name: str) -> bool:
+        """Re-enable (pop) a previously disabled server
+        
+        Args:
+            server_name: Name of the server to enable
+            
+        Returns:
+            bool: Success or failure
+        """
+        # To be implemented by subclasses
+        raise NotImplementedError("Subclasses must implement enable_server")
+    
+    def is_server_disabled(self, server_name: str) -> bool:
+        """Check if a server is currently disabled (stashed)
+        
+        Args:
+            server_name: Name of the server to check
+            
+        Returns:
+            bool: True if server is disabled, False otherwise
+        """
+        # To be implemented by subclasses
+        raise NotImplementedError("Subclasses must implement is_server_disabled")

src/mcpm/clients/claude_desktop.py

@@ -29,7 +29,10 @@ def __init__(self, config_path: str = CLAUDE_CONFIG_PATH):
 
     def _get_empty_config(self) -> Dict[str, Any]:
         """Get empty config structure for Claude Desktop"""
-        return {"mcpServers": {}}
+        return {
+            "mcpServers": {},
+            "disabledServers": {}
+        }
 
     def _add_server_config(self, server_name: str, server_config: Dict[str, Any]) -> bool:
         """Add or update an MCP server in Claude Desktop config using raw config dictionary
@@ -92,7 +95,7 @@ def _convert_to_client_format(self, server_config: ServerConfig) -> Dict[str, An
 
         # Add additional metadata fields for display in Claude Desktop
         # Fields that are None will be automatically excluded by JSON serialization
-        for field in ["name", "display_name", "description", "version", "status", "path", "install_date"]:
+        for field in ["name", "display_name", "description", "installation"]:
             value = getattr(server_config, field, None)
             if value is not None:
                 result[field] = value
@@ -122,8 +125,7 @@ def from_claude_desktop_format(cls, server_name: str, client_config: Dict[str, A
             server_data["env_vars"] = client_config["env"]
 
         # Add additional metadata fields if present
-        for field in ["display_name", "description", "version", "status", "path", "install_date", 
-                     "package", "installation_method", "installation_type"]:
+        for field in ["display_name", "description", "installation"]:
             if field in client_config:
                 server_data[field] = client_config[field]
 
@@ -141,6 +143,74 @@ def _convert_from_client_format(self, server_name: str, client_config: Dict[str,
         """
         return self.from_claude_desktop_format(server_name, client_config)
 
+    def disable_server(self, server_name: str) -> bool:
+        """Temporarily disable (stash) a server without removing its configuration
+        
+        Args:
+            server_name: Name of the server to disable
+            
+        Returns:
+            bool: Success or failure
+        """
+        config = self._load_config()
+        
+        # Check if the server exists in active servers
+        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
+        
+        # Initialize disabledServers if it doesn't exist
+        if "disabledServers" not in config:
+            config["disabledServers"] = {}
+        
+        # Store the server config in disabled servers
+        config["disabledServers"][server_name] = config["mcpServers"][server_name]
+        
+        # Remove from active servers
+        del config["mcpServers"][server_name]
+        
+        return self._save_config(config)
+    
+    def enable_server(self, server_name: str) -> bool:
+        """Re-enable (pop) a previously disabled server
+        
+        Args:
+            server_name: Name of the server to enable
+            
+        Returns:
+            bool: Success or failure
+        """
+        config = self._load_config()
+        
+        # Check if the server exists in disabled servers
+        if "disabledServers" not in config or server_name not in config["disabledServers"]:
+            logger.warning(f"Server '{server_name}' not found in disabled servers")
+            return False
+        
+        # Initialize mcpServers if it doesn't exist
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+        
+        # Move the server config from disabled to active
+        config["mcpServers"][server_name] = config["disabledServers"][server_name]
+        
+        # Remove from disabled servers
+        del config["disabledServers"][server_name]
+        
+        return self._save_config(config)
+    
+    def is_server_disabled(self, server_name: str) -> bool:
+        """Check if a server is currently disabled (stashed)
+        
+        Args:
+            server_name: Name of the server to check
+            
+        Returns:
+            bool: True if server is disabled, False otherwise
+        """
+        config = self._load_config()
+        return "disabledServers" in config and server_name in config["disabledServers"]
+    
     def remove_server(self, server_name: str) -> bool:
         """Remove an MCP server from Claude Desktop config
         

src/mcpm/clients/windsurf.py

@@ -123,10 +123,26 @@ def from_windsurf_format(cls, server_name: str, client_config: Dict[str, Any]) -
             server_data["env_vars"] = client_config["env"]
 
         # Add additional metadata fields if present
-        for field in ["display_name", "description", "version", "status", "path", "install_date", 
-                     "package", "installation_method", "installation_type"]:
+        for field in ["display_name", "description", "installation"]:
             if field in client_config:
                 server_data[field] = client_config[field]
+                
+        # For backward compatibility, if path, version, etc. are in the config
+        # but not in ServerConfig anymore, store the installation info
+        if "installation" not in server_data:
+            install_details = []
+            # Check for explicit installation fields
+            if "installation_method" in client_config:
+                install_details.append(client_config["installation_method"])
+            if "installation_type" in client_config:
+                install_details.append(client_config["installation_type"])
+                
+            # If no explicit installation info but has legacy fields,
+            # create a generic installation value
+            if not install_details and ("path" in client_config or "version" in client_config):
+                server_data["installation"] = "legacy:import"
+            elif install_details:
+                server_data["installation"] = ":".join(install_details)
 
         return ServerConfig.from_dict(server_data)
 

src/mcpm/commands/__init__.py

@@ -8,10 +8,11 @@
     "edit",
     "inspector",
     "list",
+    "pop",
     "remove",
     "search",
     "server",
-    "toggle"
+    "stash"
 ]
 
 # All command modules
@@ -20,7 +21,8 @@
 from . import edit
 from . import inspector
 from . import list
+from . import pop
 from . import remove
 from . import search
 from . import server
-from . import toggle
+from . import stash

src/mcpm/commands/add.py

@@ -4,7 +4,6 @@
 
 import os
 import json
-from datetime import datetime
 
 import click
 from rich.console import Console
@@ -94,8 +93,7 @@ def add(server_name, force=False):
 
     # If no installation information is available, create minimal default values
     # This allows us to add the server config without full installation details
-    method_key = "default"
-    install_type = "manual"
+    installation_method = "manual"  # Single consolidated concept
     install_command = "echo"
     install_args = [f"Server {server_name} added to configuration"]
     package_name = None
@@ -106,52 +104,56 @@ def add(server_name, force=False):
     selected_method = None  # Initialize selected_method to None to avoid UnboundLocalError
     if installations:
         # Find recommended installation method or default to the first one
-        method_key = "default"
+        method_id = "default"  # ID of the method in the config
 
         # First check for a recommended method
         for key, method in installations.items():
             if method.get("recommended", False):
                 selected_method = method
-                method_key = key
+                method_id = key
                 break
 
         # If no recommended method found, use the first one
         if not selected_method and installations:
-            method_key = next(iter(installations))
-            selected_method = installations[method_key]
+            method_id = next(iter(installations))
+            selected_method = installations[method_id]
 
         # If multiple methods are available and not forced, offer selection
         if len(installations) > 1 and not force:
             console.print("\n[bold]Available installation methods:[/]")
             methods_list = []
 
             for i, (key, method) in enumerate(installations.items(), 1):
-                install_type = method.get("type", "unknown")
-                description = method.get("description", f"{install_type} installation")
+                method_type = method.get("type", "unknown")
+                description = method.get("description", f"{method_type} installation")
                 recommended = " [green](recommended)[/]" if method.get("recommended", False) else ""
 
                 console.print(f"  {i}. [cyan]{key}[/]: {description}{recommended}")
                 methods_list.append(key)
 
             # Ask user to select a method
             try:
-                selection = click.prompt("\nSelect installation method", type=int, default=methods_list.index(method_key) + 1)
+                selection = click.prompt("\nSelect installation method", type=int, default=methods_list.index(method_id) + 1)
                 if 1 <= selection <= len(methods_list):
-                    method_key = methods_list[selection - 1]
-                    selected_method = installations[method_key]
+                    method_id = methods_list[selection - 1]
+                    selected_method = installations[method_id]
             except (ValueError, click.Abort):
                 console.print("[yellow]Using default installation method.[/]")
 
         # Extract installation details
         if selected_method:
-            install_type = selected_method.get("type", install_type)
+            # Use the method's type as the installation method if available, otherwise use the key
+            installation_method = selected_method.get("type")
+            if not installation_method or installation_method == "unknown":
+                installation_method = method_id
+                
             install_command = selected_method.get("command", install_command)
             install_args = selected_method.get("args", install_args)
             package_name = selected_method.get("package", package_name)
             env_vars = selected_method.get("env", env_vars)
             required_args = server_metadata.get("required_args", required_args)
 
-        console.print(f"\n[green]Using {install_type} installation method: [bold]{method_key}[/][/]")
+        console.print(f"\n[green]Using [bold]{installation_method}[/] installation method[/]")
 
     # Configure the server
     with Progress(
@@ -311,18 +313,13 @@ def add(server_name, force=False):
     # Create server configuration using ServerConfig
     server_config = ServerConfig(
         name=server_name,
-        path=server_dir,
         display_name=display_name,
         description=description,
-        version=version,
-        status="stopped",
         command=mcp_command,  # Use the actual MCP server command
         args=mcp_args,        # Use the actual MCP server arguments
         env_vars=processed_env,
-        install_date=datetime.now().strftime("%Y-%m-%d"),
-        package=package_name,
-        installation_method=method_key,
-        installation_type=install_type
+        # Use the simplified installation method
+        installation = installation_method
     )
 
     # Add the server to the client configuration

src/mcpm/commands/pop.py

@@ -0,0 +1,44 @@
+"""
+Pop command for MCPM - restores previously stashed server configuration
+"""
+
+import click
+from rich.console import Console
+
+from mcpm.utils.client_manager import get_active_client_info
+
+console = Console()
+
+@click.command()
+@click.argument("server_name")
+def pop(server_name):
+    """Restore a previously stashed server configuration.
+    
+    This command re-enables a previously stashed (disabled) server,
+    restoring it to active status.
+    
+    Examples:
+        mcpm pop memory
+    """
+    # Get the active client manager and related information
+    client_manager, client_name, client_id = get_active_client_info()
+    
+    # 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
+    
+    # Check if the server exists in the stashed configurations
+    if not client_manager.is_server_disabled(server_name):
+        console.print(f"[bold red]Error:[/] Server '{server_name}' not found in stashed configurations.")
+        return
+    
+    # Pop (re-enable) the server
+    success = client_manager.enable_server(server_name)
+    
+    if success:
+        console.print(f"[bold green]Restored[/] MCP server '{server_name}' for {client_name}")
+        console.print("Remember to restart the client for changes to take effect.")
+    else:
+        console.print(f"[bold red]Failed to restore[/] '{server_name}' for {client_name}.")