Remove outdated concepts from config system

- Remove active_client, active_target, and active_profile concepts
- Remove stashed_servers functionality
- Remove save_share_config and read_share_config methods
- Simplify ClientConfigManager to only essential methods
- Update client ls command to remove ACTIVE indicator
- Fix all tests to work without outdated concepts
- Update test fixtures to use config_path_override parameter

🤖 Generated with Claude Code

Co-Authored-By: Claude <[email protected]>

Author: niechen

src/mcpm/clients/client_config.py

@@ -3,16 +3,15 @@
 """
 
 import logging
-from typing import Any, Dict, List, Optional
+from typing import List
 
 from mcpm.utils.config import ConfigManager
-from mcpm.utils.scope import ScopeType, extract_from_scope
 
 logger = logging.getLogger(__name__)
 
 
 class ClientConfigManager:
-    """Manages client-specific configuration including active client and stashed servers"""
+    """Manages client-specific configuration"""
 
     def __init__(self):
         """Initialize the client config manager"""
@@ -23,43 +22,6 @@ def _refresh_config(self):
         """Refresh the local config cache from the config manager"""
         self._config = self.config_manager.get_config()
 
-    def get_active_client(self) -> str | None:
-        target = self.get_active_target()
-        if not target:
-            return
-        scope_type, scope = extract_from_scope(target)
-        if scope_type != ScopeType.CLIENT:
-            return
-        return scope
-
-    def set_active_target(self, target_name: str | None) -> bool:
-        """Set the active target
-
-        Args:
-            target_name: Name of target to set as active
-
-        Returns:
-            bool: Success or failure
-        """
-        # Set the active target
-        result = self.config_manager.set_config("active_target", target_name)
-        self._refresh_config()
-        return result
-
-    def get_active_target(self) -> str | None:
-        """Get the name of the currently active target or None if not set"""
-        self._refresh_config()
-        return self._config.get("active_target")
-
-    def get_active_profile(self) -> str | None:
-        target = self.get_active_target()
-        if not target:
-            return
-        scope_type, scope = extract_from_scope(target)
-        if scope_type != ScopeType.PROFILE:
-            return
-        return scope
-
     def get_supported_clients(self) -> List[str]:
         """Get a list of supported client names"""
         # Import here to avoid circular imports
@@ -80,145 +42,3 @@ def get_client_manager(self, client_name: str):
         from mcpm.clients.client_registry import ClientRegistry
 
         return ClientRegistry.get_client_manager(client_name)
-
-    def stash_server(self, scope_name: str, server_name: str, server_config: Any) -> bool:
-        """Store a disabled server configuration in the global config
-
-        Args:
-            scope_name: Name of the scope the server belongs to
-            server_name: Name of the server to stash
-            server_config: Server configuration to stash (ServerConfig object or dict)
-
-        Returns:
-            bool: Success or failure
-        """
-        # Refresh config to ensure we have the latest state
-        self._refresh_config()
-
-        # Ensure stashed_servers section exists
-        if "stashed_servers" not in self._config:
-            self._config["stashed_servers"] = {}
-
-        # Ensure client section exists
-        if scope_name not in self._config["stashed_servers"]:
-            self._config["stashed_servers"][scope_name] = {}
-
-        # Convert ServerConfig to dict if needed
-        try:
-            # If it's a ServerConfig object with to_dict method
-            if hasattr(server_config, "to_dict") and callable(server_config.to_dict):
-                server_dict = server_config.to_dict()
-            else:
-                # Assume it's already a dict or JSON serializable
-                server_dict = server_config
-
-            # Add the server configuration
-            stashed_servers = self._config.get("stashed_servers", {})
-            if scope_name not in stashed_servers:
-                stashed_servers[scope_name] = {}
-            stashed_servers[scope_name][server_name] = server_dict
-
-            # Use set_config to save the updated stashed_servers
-            result = self.config_manager.set_config("stashed_servers", stashed_servers)
-            self._refresh_config()
-            return result
-        except Exception as e:
-            logger.error(f"Failed to save stashed server: {e}")
-            return False
-
-    def pop_server(self, scope_name: str, server_name: str) -> Optional[Dict[str, Any]]:
-        """Retrieve a stashed server configuration from the global config
-
-        Args:
-            scope_name: Name of the scope the server belongs to
-            server_name: Name of the server to retrieve
-
-        Returns:
-            Dict: Server configuration or None if not found
-        """
-        # Refresh config to ensure we have the latest state
-        self._refresh_config()
-
-        # Check if stashed_servers section exists
-        stashed_servers = self._config.get("stashed_servers", {})
-        if not stashed_servers:
-            return None
-
-        # Check if scope section exists
-        if scope_name not in stashed_servers:
-            return None
-
-        # Check if server exists
-        if server_name not in stashed_servers[scope_name]:
-            return None
-
-        # Get the server configuration
-        server_config = stashed_servers[scope_name][server_name]
-
-        # Remove the server from stashed servers
-        del stashed_servers[scope_name][server_name]
-
-        # Clean up empty scope section if needed
-        if not stashed_servers[scope_name]:
-            del stashed_servers[scope_name]
-
-        # Clean up empty stashed_servers section if needed
-        if not stashed_servers:
-            # Set to None to remove the key completely
-            self.config_manager.set_config("stashed_servers", None)
-        else:
-            # Update with modified stashed_servers
-            self.config_manager.set_config("stashed_servers", stashed_servers)
-
-        # Refresh config after changes
-        self._refresh_config()
-
-        return server_config
-
-    def is_server_stashed(self, scope_name: str, server_name: str) -> bool:
-        """Check if a server is stashed in the global config
-
-        Args:
-            scope_name: Name of the scope the server belongs to
-            server_name: Name of the server to check
-
-        Returns:
-            bool: True if server is stashed, False otherwise
-        """
-        # Refresh config to ensure we have the latest state
-        self._refresh_config()
-
-        # Check if stashed_servers section exists
-        stashed_servers = self._config.get("stashed_servers", {})
-        if not stashed_servers:
-            return False
-
-        # Check if scope section exists
-        if scope_name not in stashed_servers:
-            return False
-
-        # Check if server exists
-        return server_name in stashed_servers[scope_name]
-
-    def get_stashed_servers(self, scope_name: str) -> Dict[str, Dict[str, Any]]:
-        """Get all stashed servers for a client
-
-        Args:
-            scope_name: Name of the scope to get stashed servers for
-
-        Returns:
-            Dict: Dictionary of server configurations by name
-        """
-        # Refresh config to ensure we have the latest state
-        self._refresh_config()
-
-        # Check if stashed_servers section exists
-        stashed_servers = self._config.get("stashed_servers", {})
-        if not stashed_servers:
-            return {}
-
-        # Check if scope section exists
-        if scope_name not in stashed_servers:
-            return {}
-
-        return stashed_servers[scope_name]

src/mcpm/clients/client_registry.py

@@ -113,30 +113,6 @@ def get_all_client_info(cls) -> Dict[str, Dict[str, str]]:
         """
         return {client_name: manager().get_client_info() for client_name, manager in cls._CLIENT_MANAGERS.items()}
 
-    @classmethod
-    def get_active_client(cls) -> str | None:
-        """
-        Get the active client name from the config manager
-
-        Returns:
-            str | None: Name of the active client or None if not set
-        """
-        return cls._client_config_manager.get_active_client()
-
-    @classmethod
-    def get_active_client_manager(cls) -> 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 = cls.get_active_client()
-        if not active_client:
-            return None
-
-        return cls.get_client_manager(active_client)
-
     @classmethod
     def get_recommended_client(cls) -> str | None:
         """
@@ -164,36 +140,3 @@ def get_supported_clients(cls) -> List[str]:
             List[str]: List of supported client names
         """
         return list(cls._CLIENT_MANAGERS.keys())
-
-    @classmethod
-    def get_active_profile(cls) -> str | None:
-        """
-        Get the active profile from the config manager
-
-        Returns:
-            str | None: Name of the active profile, or None if not set
-        """
-        return cls._client_config_manager.get_active_profile()
-
-    @classmethod
-    def get_active_target(cls) -> str | None:
-        """
-        Get the active target (client or profile) from the config manager
-
-        Returns:
-            str | None: Name of the active client or profile, or None if not set
-        """
-        return cls._client_config_manager.get_active_target()
-
-    @classmethod
-    def set_active_target(cls, target: str | None) -> bool:
-        """
-        Set the active target (client or profile) in the config manager
-
-        Args:
-            target: Name of the client or profile
-
-        Returns:
-            bool: Success or failure
-        """
-        return cls._client_config_manager.set_active_target(target)

src/mcpm/commands/client.py

@@ -50,7 +50,6 @@ def list_clients(verbose):
     # Get the list of supported clients
     supported_clients = ClientRegistry.get_supported_clients()
     installed_clients = ClientRegistry.detect_installed_clients()
-    active_client = ClientRegistry.get_active_client()
 
     # Count installed clients
     installed_count = sum(1 for c in supported_clients if installed_clients.get(c, False))
@@ -75,13 +74,8 @@ def list_clients(verbose):
         client_info = ClientRegistry.get_client_info(client_name)
         display_name = client_info.get("name", client_name)
 
-        # Build client name with code and status indicators
-        name_parts = [f"{display_name} [dim]({client_name})[/]"]
-
-        if client_name == active_client:
-            name_parts.append("[bold green]ACTIVE[/]")
-
-        client_display = " ".join(name_parts)
+        # Build client name with code
+        client_display = f"{display_name} [dim]({client_name})[/]"
 
         # Get the client manager to check MCPM servers
         client_manager = ClientRegistry.get_client_manager(client_name)

src/mcpm/commands/config.py

@@ -43,23 +43,49 @@ def set():
     console.print(f"[green]Default node executable set to:[/] {node_executable}")
 
 
+@config.command()
+@click.help_option("-h", "--help")
+def ls():
+    """List all MCPM configuration settings.
+
+    Example:
+
+    \b
+        mcpm config ls
+    """
+    config_manager = ConfigManager()
+    current_config = config_manager.get_config()
+
+    if not current_config:
+        console.print("[yellow]No configuration settings found.[/]")
+        return
+
+    console.print("[bold green]Current configuration:[/]")
+    for key, value in current_config.items():
+        console.print(f"  [cyan]{key}:[/] {value}")
+
+
 @config.command()
 @click.argument("name", required=True)
 @click.help_option("-h", "--help")
-def get(name):
-    """Get MCPM configuration.
+def unset(name):
+    """Remove a configuration setting.
 
     Example:
 
     \b
-        mcpm config get node_executable
+        mcpm config unset node_executable
     """
     config_manager = ConfigManager()
     current_config = config_manager.get_config()
+
     if name not in current_config:
-        console.print(f"[red]Configuration '{name}' not set or not supported.[/]")
+        console.print(f"[red]Configuration '{name}' is not set.[/]")
         return
-    console.print(f"[green]{name}:[/] {current_config[name]}")
+
+    # Remove the configuration by setting it to None
+    config_manager.set_config(name, None)
+    console.print(f"[green]Configuration '{name}' has been removed.[/]")
 
 
 @config.command()

src/mcpm/utils/config.py

@@ -13,13 +13,10 @@
 DEFAULT_CONFIG_DIR = os.path.expanduser("~/.config/mcpm")
 DEFAULT_CONFIG_FILE = os.path.join(DEFAULT_CONFIG_DIR, "config.json")
 DEFAULT_AUTH_FILE = os.path.join(DEFAULT_CONFIG_DIR, "auth.json")
-# default router config
-DEFAULT_HOST = "localhost"
+# Default port for HTTP mode
 DEFAULT_PORT = 6276  # 6276 represents MCPM on a T9 keypad (6=M, 2=C, 7=P, 6=M)
-# default splitor pattern
+# Default share address
 DEFAULT_SHARE_ADDRESS = f"share.mcpm.sh:{DEFAULT_PORT}"
-MCPM_AUTH_HEADER = "X-MCPM-SECRET"
-MCPM_PROFILE_HEADER = "X-MCPM-PROFILE"
 
 NODE_EXECUTABLES = ["npx", "bunx", "pnpm dlx", "yarn dlx"]
 
@@ -124,9 +121,3 @@ def save_auth_config(self, api_key: str) -> bool:
         self._auth_config["api_key"] = api_key
         self._save_auth_config()
         return True
-
-    def save_share_config(self, share_url: str | None = None, share_pid: int | None = None):
-        return self.set_config("share", {"url": share_url, "pid": share_pid})
-
-    def read_share_config(self) -> Dict[str, Any]:
-        return self.get_config().get("share", {})