profile share working

Author: niechen

docs/custom-server-config-explained.md

@@ -0,0 +1,132 @@
+# Understanding CustomServerConfig in MCPM
+
+## What is CustomServerConfig?
+
+`CustomServerConfig` is a flexible server configuration type in MCPM that allows for arbitrary, non-standard server configurations. It's designed to support future extensibility and edge cases that don't fit into the standard STDIO or Remote server models.
+
+## Structure
+
+```python
+class CustomServerConfig(BaseServerConfig):
+    config: Dict[str, Any]
+```
+
+- Inherits from `BaseServerConfig` (provides `name` and `profile_tags`)
+- Has a single `config` field that can contain any dictionary structure
+
+## Purpose and Use Cases
+
+### 1. **Future-Proofing**
+CustomServerConfig allows MCPM to support new server types without changing the core schema. For example:
+- WebSocket-based MCP servers
+- Custom transport protocols
+- Proprietary server implementations
+
+### 2. **Client-Specific Configurations**
+Different MCP clients might have unique configuration requirements:
+```python
+# Example: A hypothetical WebSocket server
+CustomServerConfig(
+    name="websocket-server",
+    config={
+        "url": "wss://example.com/mcp",
+        "transport": "websocket",
+        "reconnect": True,
+        "ping_interval": 30
+    }
+)
+```
+
+### 3. **Built-in or Special Servers**
+In the Goose client integration, CustomServerConfig is used for "builtin" type servers:
+```python
+# From goose.py client manager
+elif isinstance(server_config, CustomServerConfig):
+    result = dict(server_config.config)
+    result["type"] = "builtin"
+```
+
+## How It Works in the FastMCP Proxy
+
+When the FastMCP proxy encounters a CustomServerConfig, it passes the entire `config` dictionary directly to FastMCP:
+
+```python
+elif isinstance(server, CustomServerConfig):
+    # CustomServerConfig - pass through the custom config
+    proxy_config["mcpServers"][server.name] = server.config
+```
+
+This allows FastMCP to handle any configuration format it supports, including:
+- Custom transports
+- Special authentication methods
+- Non-standard connection parameters
+
+## Example Usage Scenarios
+
+### 1. WebSocket Server
+```yaml
+name: realtime-data
+config:
+  url: wss://data.example.com/mcp
+  transport: websocket
+  auth_token: ${WEBSOCKET_TOKEN}
+  reconnect_delay: 5000
+```
+
+### 2. Plugin-Based Server
+```yaml
+name: plugin-server
+config:
+  type: plugin
+  module: mcp_plugins.analytics
+  class: AnalyticsServer
+  options:
+    cache_size: 1000
+    refresh_rate: 60
+```
+
+### 3. Embedded Server
+```yaml
+name: embedded-llm
+config:
+  type: embedded
+  model_path: /models/local-llm
+  gpu_layers: 32
+  context_size: 4096
+```
+
+## Current Implementation Status
+
+As of now, CustomServerConfig is:
+- ✅ Defined in the schema
+- ✅ Supported by the FastMCP proxy
+- ✅ Handled by client managers (like Goose)
+- ⚠️ Not yet used in practice by MCPM commands
+
+## Why It Exists
+
+1. **Extensibility**: Allows MCPM to support new server types without breaking changes
+2. **Flexibility**: Clients can define their own server configuration formats
+3. **Forward Compatibility**: Future MCP transport types can be supported
+4. **Special Cases**: Handles edge cases that don't fit STDIO or HTTP/SSE models
+
+## Integration with FastMCP
+
+FastMCP's proxy system is designed to handle arbitrary configurations. When it receives a CustomServerConfig, it:
+1. Extracts the `config` dictionary
+2. Passes it directly to FastMCP's configuration system
+3. FastMCP interprets the configuration based on its own rules
+
+This design allows MCPM to be transport-agnostic while still providing structured configuration for known transport types (STDIO and Remote).
+
+## Future Possibilities
+
+CustomServerConfig opens the door for:
+- gRPC-based MCP servers
+- Message queue-based servers (RabbitMQ, Kafka)
+- In-process servers (Python modules loaded directly)
+- Cloud-native integrations (Lambda, Cloud Functions)
+- Custom authentication schemes
+- Load-balanced server pools
+
+The key insight is that CustomServerConfig is MCPM's escape hatch for innovation - it ensures the tool can adapt to new MCP server types without requiring schema changes.

examples/proxy_transport_types.md

@@ -0,0 +1,88 @@
+# FastMCP Proxy with Multiple Transport Types
+
+The MCPM FastMCP proxy now supports aggregating servers with different transport types (stdio, HTTP, SSE) into a single unified interface.
+
+## Supported Server Types
+
+### 1. STDIO Servers (Local Command-based)
+```yaml
+name: local-python-server
+command: python
+args: ["-m", "my_mcp_server"]
+env:
+  API_KEY: ${MY_API_KEY}
+```
+
+### 2. Remote HTTP/SSE Servers
+```yaml
+name: remote-api-server
+url: https://api.example.com/mcp
+headers:
+  Authorization: Bearer ${TOKEN}
+```
+
+### 3. Custom Server Configurations (Client-Specific)
+```yaml
+name: custom-websocket-server
+config:
+  url: wss://ws.example.com/mcp
+  transport: websocket
+  custom_field: value
+```
+
+**Note**: CustomServerConfig is used for parsing non-standard MCP configs from client configuration files (like Claude Desktop, Goose, etc.) and is **not processed by MCPM's proxy system**. These are client-specific configurations that don't go through the proxy.
+
+## Example: Mixed Profile
+
+You can create a profile that combines servers with different transports:
+
+```bash
+# Add a local stdio server
+mcpm add mcp-server-time --profile mixed-demo
+
+# Add a remote HTTP server (hypothetical)
+mcpm client add --global --server remote-weather --url https://weather-api.com/mcp
+
+# Run the profile - FastMCP proxy handles all transport types
+mcpm profile run mixed-demo
+
+# Or run in HTTP mode for sharing
+mcpm profile run --http mixed-demo
+```
+
+## How It Works
+
+1. **STDIO Servers**: The proxy runs the command directly with the specified arguments and environment
+2. **HTTP/SSE Servers**: The proxy connects to the remote URL, forwarding headers as needed
+3. **Custom Servers**: These are skipped by the proxy system (client-specific configurations)
+
+## Benefits
+
+- **Unified Interface**: Access all servers through a single endpoint
+- **Transport Bridging**: Expose HTTP-only servers via stdio or vice versa
+- **Authentication**: Add MCPM authentication layer to any server type
+- **Monitoring**: Track usage across all server types uniformly
+
+## FastMCP Proxy Configuration
+
+When MCPM creates the FastMCP proxy, it generates a configuration like:
+
+```json
+{
+  "mcpServers": {
+    "local-server": {
+      "command": ["python", "-m", "server"],
+      "env": {"KEY": "value"}
+    },
+    "remote-server": {
+      "url": "https://api.example.com/mcp",
+      "transport": "http",
+      "headers": {"Authorization": "Bearer token"}
+    }
+  }
+}
+```
+
+**Note**: CustomServerConfig entries are not included in the proxy configuration as they are client-specific and not processed by MCPM's proxy system.
+
+FastMCP handles the complexity of connecting to each supported server type and presents a unified MCP interface.

pyproject.toml

@@ -25,6 +25,7 @@ dependencies = [
     "requests>=2.28.0",
     "pydantic>=2.5.1",
     "mcp>=1.8.0",
+    "fastmcp>=2.0.0",
     "ruamel-yaml>=0.18.10",
     "watchfiles>=1.0.4",
     "duckdb>=1.2.2",

src/mcpm/commands/profile/__init__.py

@@ -4,6 +4,7 @@
 
 from .create import create_profile
 from .edit import edit_profile
+from .inspect import inspect_profile
 from .list import list_profiles
 from .remove import remove_profile
 from .run import run
@@ -21,6 +22,7 @@ def profile():
 profile.add_command(list_profiles)
 profile.add_command(create_profile)
 profile.add_command(edit_profile)
+profile.add_command(inspect_profile)
 profile.add_command(share_profile)
 profile.add_command(remove_profile)
 profile.add_command(run)

src/mcpm/commands/profile/inspect.py

@@ -0,0 +1,131 @@
+"""Profile inspect command."""
+
+import shlex
+import subprocess
+import sys
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from mcpm.profile.profile_config import ProfileConfigManager
+from mcpm.utils.platform import NPX_CMD
+
+console = Console()
+profile_config_manager = ProfileConfigManager()
+
+
+def build_profile_inspector_command(profile_name):
+    """Build the inspector command using mcpm profile run."""
+    # Use mcpm profile run to start the FastMCP proxy - don't reinvent the wheel!
+    mcpm_profile_run_cmd = f"mcpm profile run {shlex.quote(profile_name)}"
+    
+    # Build inspector command that uses mcpm profile run
+    inspector_cmd = f"{NPX_CMD} @modelcontextprotocol/inspector {mcpm_profile_run_cmd}"
+    return inspector_cmd
+
+
+@click.command(name="inspect")
+@click.argument("profile_name")
+@click.help_option("-h", "--help")
+def inspect_profile(profile_name):
+    """Launch MCP Inspector to test and debug all servers in a profile.
+    
+    Creates a FastMCP proxy that aggregates all servers in the specified profile
+    and launches the MCP Inspector to interact with the combined capabilities.
+    
+    Examples:
+        mcpm profile inspect web-dev     # Inspect all servers in web-dev profile
+        mcpm profile inspect ai          # Inspect all servers in ai profile
+        mcpm profile inspect data        # Inspect all servers in data profile
+    """
+    # Validate profile name
+    if not profile_name or not profile_name.strip():
+        console.print("[red]Error: Profile name cannot be empty[/]")
+        sys.exit(1)
+    
+    profile_name = profile_name.strip()
+    
+    # Show header
+    console.print(
+        Panel.fit(
+            f"[bold green]MCPM Profile Inspector[/]\\nInspecting profile: [cyan]{profile_name}[/]", 
+            border_style="cyan"
+        )
+    )
+    
+    # Check if profile exists
+    try:
+        profile_servers = profile_config_manager.get_profile(profile_name)
+        if profile_servers is None:
+            console.print(f"[red]Error: Profile '[bold]{profile_name}[/]' not found[/]")
+            console.print()
+            console.print("[yellow]Available options:[/]")
+            console.print("  • Run 'mcpm profile ls' to see available profiles")
+            console.print("  • Run 'mcpm profile create {name}' to create a profile")
+            sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error accessing profile '{profile_name}': {e}[/]")
+        sys.exit(1)
+
+    if not profile_servers:
+        console.print(f"[yellow]Profile '[bold]{profile_name}[/]' has no servers configured[/]")
+        console.print()
+        console.print("[dim]Add servers to this profile with:[/]")
+        console.print(f"  mcpm profile edit {profile_name}")
+        sys.exit(1)
+
+    # Show profile info
+    server_count = len(profile_servers)
+    console.print(f"[dim]Profile contains {server_count} server(s):[/]")
+    for server_config in profile_servers:
+        console.print(f"  • [cyan]{server_config.name}[/]")
+    
+    console.print(f"\\n[bold]Starting Inspector for profile '[cyan]{profile_name}[/]'[/]")
+    console.print("The Inspector will show aggregated capabilities from all servers in the profile.")
+    console.print("The Inspector UI will open in your web browser.")
+    
+    # Build inspector command using mcpm profile run
+    inspector_cmd = build_profile_inspector_command(profile_name)
+    
+    try:
+        console.print("[cyan]Starting MCPM Profile Inspector...[/]")
+        console.print("The Inspector UI will open in your web browser.")
+        console.print("[yellow]Press Ctrl+C to stop the Inspector.[/]")
+        
+        # Split the command into components for subprocess
+        cmd_parts = shlex.split(inspector_cmd)
+        
+        try:
+            console.print(f"[dim]Executing: {inspector_cmd}[/]")
+            console.print("[bold green]Starting MCPM Profile Inspector...[/]")
+            console.print("[cyan]Press Ctrl+C to exit[/]")
+            sys.stdout.flush()
+            
+            # Execute the command with direct terminal access
+            returncode = subprocess.call(cmd_parts)
+            
+        except KeyboardInterrupt:
+            console.print("\\n[bold yellow]Inspector process terminated by keyboard interrupt.[/]")
+            returncode = 130
+        
+        # Check exit code
+        if returncode == 0:
+            console.print("[bold green]Inspector process completed successfully.[/]")
+        elif returncode in (130, -2):
+            console.print("[bold yellow]Inspector process was terminated.[/]")
+        else:
+            console.print(f"[bold red]Inspector process exited with code {returncode}[/]")
+            
+        sys.exit(returncode)
+        
+    except FileNotFoundError:
+        console.print("[bold red]Error:[/] Could not find npx. Please make sure Node.js is installed.")
+        console.print("Install Node.js from https://nodejs.org/")
+        sys.exit(1)
+    except PermissionError:
+        console.print("[bold red]Error:[/] Permission denied while trying to execute the command.")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error launching Profile Inspector:[/] {str(e)}")
+        sys.exit(1)