feat: update commands to support profile work scope

Author: JoJoJoJoJoJoJo

README.md

@@ -52,13 +52,19 @@ mcpm client --list                       # List all supported MCP clients and th
 
 mcpm edit                                # View or edit the active MCP client's configuration file
 
-mcpm list                                # List all installed MCP servers
+mcpm ls                                  # List all installed MCP servers
 
-mcpm remove SERVER_NAME                  # Remove an installed MCP server
+mcpm rm SERVER_NAME                      # Remove an installed MCP server
 
 mcpm stash SERVER_NAME                   # Temporarily disable an MCP server for a client
 mcpm pop SERVER_NAME                     # Re-enable an MCP server for a client
 
+mcpm cp SOURCE TARGET                    # Copy an MCP server from one client/profile to another
+mcpm mv SOURCE TARGET                    # Move an MCP server from one client/profile to another
+
+mcpm activate PROFILE_NAME               # Activate a profile
+mcpm deactivate                          # Deactivate the active profile
+
 mcpm inspect SERVER_NAME                 # Launch the MCPM Inspector UI to examine servers
 ```
 

src/mcpm/cli.py

@@ -20,6 +20,7 @@
     remove,
     search,
     stash,
+    transfer,
 )
 
 console = Console()
@@ -126,12 +127,16 @@ def main(ctx, help_flag):
             "View or edit the active MCPM client's configuration file.",
         )
         commands_table.add_row("  [cyan]inspector[/]", "Launch the MCPM Inspector UI to examine servers.")
-        commands_table.add_row("  [cyan]list[/]", "List all installed MCP servers.")
+        commands_table.add_row("  [cyan]list/ls[/]", "List all installed MCP servers.")
         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]stash[/]", "Temporarily store a server configuration aside.")
         commands_table.add_row("  [cyan]pop[/]", "Restore a previously stashed server configuration.")
         commands_table.add_row("  [cyan]profile[/]", "Manage MCPM profiles.")
+        commands_table.add_row("  [cyan]mv[/]", "Move a server from one client/profile to another.")
+        commands_table.add_row("  [cyan]cp[/]", "Copy a server from one client/profile to another.")
+        commands_table.add_row("  [cyan]activate[/]", "Activate a profile.")
+        commands_table.add_row("  [cyan]deactivate[/]", "Deactivate a profile.")
         console.print(commands_table)
 
         # Additional helpful information
@@ -144,6 +149,7 @@ def main(ctx, help_flag):
 main.add_command(remove.remove)
 main.add_command(add.add)
 main.add_command(list.list)
+main.add_command(list.list, name="ls")
 main.add_command(edit.edit)
 
 main.add_command(stash.stash)
@@ -153,6 +159,10 @@ def main(ctx, help_flag):
 main.add_command(config.config)
 main.add_command(inspector.inspector, name="inspector")
 main.add_command(profile.profile, name="profile")
+main.add_command(transfer.move, name="mv")
+main.add_command(transfer.copy, name="cp")
+main.add_command(profile.activate)
+main.add_command(profile.deactivate)
 
 if __name__ == "__main__":
     main()

src/mcpm/clients/client_config.py

@@ -5,6 +5,7 @@
 import logging
 from typing import Any, Dict, List, Optional
 
+from mcpm.profile.profile_config import ProfileConfigManager
 from mcpm.utils.config import ConfigManager
 
 logger = logging.getLogger(__name__)
@@ -22,7 +23,7 @@ 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:
+    def get_active_client(self) -> str | None:
         """Get the name of the currently active client or None if not set"""
         self._refresh_config()
         return self._config.get("active_client")
@@ -56,6 +57,37 @@ def set_active_client(self, client_name: Optional[str]) -> bool:
         self._refresh_config()
         return result
 
+    def get_active_profile(self) -> str | None:
+        """Get the name of the currently active profile or None if not set"""
+        self._refresh_config()
+        return self._config.get("active_profile")
+
+    def set_active_profile(self, profile_name: Optional[str]) -> bool:
+        """Set the active profile
+
+        Args:
+            profile_name: Name of profile to set as active, or None to clear
+
+        Returns:
+            bool: Success or failure
+        """
+        # If None, remove the active profile
+        if profile_name is None:
+            result = self.config_manager.set_config("active_profile", None)
+            self._refresh_config()
+            return result
+
+        supported_profiles = ProfileConfigManager().list_profiles()
+
+        if profile_name not in supported_profiles:
+            logger.error(f"Unknown profile: {profile_name}")
+            return False
+
+        # Set the active profile
+        result = self.config_manager.set_config("active_profile", profile_name)
+        self._refresh_config()
+        return result
+
     def get_supported_clients(self) -> List[str]:
         """Get a list of supported client names"""
         # Import here to avoid circular imports
@@ -77,11 +109,11 @@ def get_client_manager(self, client_name: str):
 
         return ClientRegistry.get_client_manager(client_name)
 
-    def stash_server(self, client_name: str, server_name: str, server_config: Any) -> bool:
+    def stash_server(self, scope_name: str, server_name: str, server_config: Any) -> bool:
         """Store a disabled server configuration in the global config
 
         Args:
-            client_name: Name of the client the server belongs to
+            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)
 
@@ -96,8 +128,8 @@ def stash_server(self, client_name: str, server_name: str, server_config: Any) -
             self._config["stashed_servers"] = {}
 
         # Ensure client section exists
-        if client_name not in self._config["stashed_servers"]:
-            self._config["stashed_servers"][client_name] = {}
+        if scope_name not in self._config["stashed_servers"]:
+            self._config["stashed_servers"][scope_name] = {}
 
         # Convert ServerConfig to dict if needed
         try:
@@ -110,9 +142,9 @@ def stash_server(self, client_name: str, server_name: str, server_config: Any) -
 
             # Add the server configuration
             stashed_servers = self._config.get("stashed_servers", {})
-            if client_name not in stashed_servers:
-                stashed_servers[client_name] = {}
-            stashed_servers[client_name][server_name] = server_dict
+            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)
@@ -122,11 +154,11 @@ def stash_server(self, client_name: str, server_name: str, server_config: Any) -
             logger.error(f"Failed to save stashed server: {e}")
             return False
 
-    def pop_server(self, client_name: str, server_name: str) -> Optional[Dict[str, Any]]:
+    def pop_server(self, scope_name: str, server_name: str) -> Optional[Dict[str, Any]]:
         """Retrieve a stashed server configuration from the global config
 
         Args:
-            client_name: Name of the client the server belongs to
+            scope_name: Name of the scope the server belongs to
             server_name: Name of the server to retrieve
 
         Returns:
@@ -140,23 +172,23 @@ def pop_server(self, client_name: str, server_name: str) -> Optional[Dict[str, A
         if not stashed_servers:
             return None
 
-        # Check if client section exists
-        if client_name not in stashed_servers:
+        # 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[client_name]:
+        if server_name not in stashed_servers[scope_name]:
             return None
 
         # Get the server configuration
-        server_config = stashed_servers[client_name][server_name]
+        server_config = stashed_servers[scope_name][server_name]
 
         # Remove the server from stashed servers
-        del stashed_servers[client_name][server_name]
+        del stashed_servers[scope_name][server_name]
 
-        # Clean up empty client section if needed
-        if not stashed_servers[client_name]:
-            del stashed_servers[client_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:
@@ -171,11 +203,11 @@ def pop_server(self, client_name: str, server_name: str) -> Optional[Dict[str, A
 
         return server_config
 
-    def is_server_stashed(self, client_name: str, server_name: str) -> bool:
+    def is_server_stashed(self, scope_name: str, server_name: str) -> bool:
         """Check if a server is stashed in the global config
 
         Args:
-            client_name: Name of the client the server belongs to
+            scope_name: Name of the scope the server belongs to
             server_name: Name of the server to check
 
         Returns:
@@ -189,18 +221,18 @@ def is_server_stashed(self, client_name: str, server_name: str) -> bool:
         if not stashed_servers:
             return False
 
-        # Check if client section exists
-        if client_name not in stashed_servers:
+        # Check if scope section exists
+        if scope_name not in stashed_servers:
             return False
 
         # Check if server exists
-        return server_name in stashed_servers[client_name]
+        return server_name in stashed_servers[scope_name]
 
-    def get_stashed_servers(self, client_name: str) -> Dict[str, Dict[str, Any]]:
+    def get_stashed_servers(self, scope_name: str) -> Dict[str, Dict[str, Any]]:
         """Get all stashed servers for a client
 
         Args:
-            client_name: Name of the client to get stashed servers for
+            scope_name: Name of the scope to get stashed servers for
 
         Returns:
             Dict: Dictionary of server configurations by name
@@ -213,8 +245,8 @@ def get_stashed_servers(self, client_name: str) -> Dict[str, Dict[str, Any]]:
         if not stashed_servers:
             return {}
 
-        # Check if client section exists
-        if client_name not in stashed_servers:
+        # Check if scope section exists
+        if scope_name not in stashed_servers:
             return {}
 
-        return stashed_servers[client_name]
+        return stashed_servers[scope_name]

src/mcpm/clients/client_registry.py

@@ -17,6 +17,7 @@
 from mcpm.clients.managers.fiveire import FiveireManager
 from mcpm.clients.managers.goose import GooseClientManager
 from mcpm.clients.managers.windsurf import WindsurfManager
+from mcpm.utils.scope import CLIENT_PREFIX, PROFILE_PREFIX
 
 logger = logging.getLogger(__name__)
 
@@ -102,12 +103,12 @@ 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:
+    def get_active_client(cls) -> str | None:
         """
         Get the active client name from the config manager
 
         Returns:
-            str: Name of the active client
+            str | None: Name of the active client or None if not set
         """
         return cls._client_config_manager.get_active_client()
 
@@ -165,3 +166,42 @@ 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 name 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 set_active_profile(cls, profile_name: str | None) -> bool:
+        """
+        Set the active profile in the config manager
+
+        Args:
+            profile_name: Name of the profile or None to unset
+
+        Returns:
+            bool: Success or failure
+        """
+        return cls._client_config_manager.set_active_profile(profile_name)
+
+    @classmethod
+    def determine_active_scope(cls) -> str | None:
+        """
+        Determine the active scope (client or profile) based on config
+
+        Returns:
+            str | None: Name of the active client or profile, or None if not set
+        """
+        profile = cls.get_active_profile()
+        if profile:
+            return f"{PROFILE_PREFIX}{profile}"
+        client = cls.get_active_client()
+        if client:
+            return f"{CLIENT_PREFIX}{client}"
+        return None

src/mcpm/clients/managers/fiveire.py

@@ -116,8 +116,7 @@ def get_server(self, server_name: str) -> Optional[ServerConfig]:
             return None
 
         # Get the server config and convert to ServerConfig
-        client_config = servers[server_name]
-        return self.from_client_format(server_name, client_config)
+        return servers[server_name]
 
     def add_server(self, server_config: Union[ServerConfig, Dict[str, Any]], name: Optional[str] = None) -> bool:
         """Add or update a server in the client config

src/mcpm/commands/__init__.py

@@ -2,7 +2,20 @@
 MCPM commands package
 """
 
-__all__ = ["add", "client", "edit", "inspector", "list", "pop", "profile", "remove", "search", "stash"]
+__all__ = [
+    "add",
+    "client",
+    "edit",
+    "inspector",
+    "list",
+    "pop",
+    "profile",
+    "remove",
+    "search",
+    "stash",
+    "transfer",
+]
 
 # All command modules
-from . import add, client, edit, inspector, list, pop, profile, remove, search, stash
+from . import client, edit, inspector, list, profile, search
+from .server_operations import add, pop, remove, stash, transfer

src/mcpm/commands/edit.py

@@ -34,12 +34,15 @@ def edit():
     # Get the active client manager and related information
     client_manager = ClientRegistry.get_active_client_manager()
     client = ClientRegistry.get_active_client()
+    if client is None:
+        print_client_error()
+        return
     client_info = ClientRegistry.get_client_info(client)
     client_name = client_info.get("name", client)
 
     # Check if client is supported
     if client_manager is None:
-        print_client_error(client_name)
+        print_client_error()
         return
 
     # Get the client config file path
@@ -110,7 +113,7 @@ def edit():
                 if server_count > 0:
                     console.print("\n[bold]MCP Server Details:[/]")
                     for server_name, server_config in config_json.get("mcpServers", {}).items():
-                        print_server_config(server_name, server_config)
+                        print_server_config(client_manager.from_client_format(server_name, server_config))
 
             except json.JSONDecodeError:
                 console.print("[yellow]Warning: Config file contains invalid JSON[/]")