mcp-vector-search 0.12.6__py3-none-any.whl → 1.0.3__py3-none-any.whl

mcp_vector_search/cli/commands/uninstall.py

@@ -1,24 +1,29 @@
 """Uninstall commands for MCP Vector Search CLI.
 
-This module provides commands to remove MCP integrations from various platforms.
+This module provides commands to remove MCP integrations from various platforms
+using the py-mcp-installer library.
 
 Examples:
-    # Remove Claude Code integration
-    $ mcp-vector-search uninstall claude-code
+    # Remove from auto-detected platform
+    $ mcp-vector-search uninstall mcp
 
-    # Remove all integrations
-    $ mcp-vector-search uninstall --all
+    # Remove from specific platform
+    $ mcp-vector-search uninstall mcp --platform cursor
+
+    # Remove from all platforms
+    $ mcp-vector-search uninstall mcp --all
 
     # Use alias
-    $ mcp-vector-search remove claude-code
+    $ mcp-vector-search remove mcp
 """
 
-import json
-import shutil
 from pathlib import Path
 
 import typer
 from loguru import logger
+
+# Import from py-mcp-installer library
+from py_mcp_installer import MCPInstaller, Platform, PlatformDetector, PlatformInfo
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -29,7 +34,6 @@ from ..output import (
     print_error,
     print_info,
     print_success,
-    print_warning,
 )
 
 # Create console for rich output
@@ -41,25 +45,30 @@ uninstall_app = create_enhanced_typer(
 
 [bold cyan]Usage Patterns:[/bold cyan]
 
-  [green]1. Remove Specific Platform[/green]
-     Remove MCP integration from a platform:
-     [code]$ mcp-vector-search uninstall claude-code[/code]
-     [code]$ mcp-vector-search uninstall cursor[/code]
+  [green]1. Remove from Auto-Detected Platform[/green]
+     Remove MCP integration from highest confidence platform:
+     [code]$ mcp-vector-search uninstall mcp[/code]
 
-  [green]2. Remove All Integrations[/green]
+  [green]2. Remove from Specific Platform[/green]
+     Remove from a specific platform:
+     [code]$ mcp-vector-search uninstall mcp --platform cursor[/code]
+
+  [green]3. Remove from All Platforms[/green]
      Remove from all configured platforms:
-     [code]$ mcp-vector-search uninstall --all[/code]
+     [code]$ mcp-vector-search uninstall mcp --all[/code]
 
-  [green]3. List Current Installations[/green]
+  [green]4. List Current Installations[/green]
      See what's currently configured:
      [code]$ mcp-vector-search uninstall list[/code]
 
 [bold cyan]Supported Platforms:[/bold cyan]
-  • [green]claude-code[/green]     - Claude Code (project-scoped .mcp.json)
-  • [green]claude-desktop[/green]  - Claude Desktop (~/.claude/config.json)
-  • [green]cursor[/green]          - Cursor IDE (~/.cursor/mcp.json)
-  • [green]windsurf[/green]        - Windsurf IDE (~/.codeium/windsurf/mcp_config.json)
-  • [green]vscode[/green]          - VS Code (~/.vscode/mcp.json)
+  • [green]claude-code[/green]     - Claude Code
+  • [green]claude-desktop[/green]  - Claude Desktop
+  • [green]cursor[/green]          - Cursor IDE
+  • [green]auggie[/green]          - Auggie
+  • [green]codex[/green]           - Codex
+  • [green]windsurf[/green]        - Windsurf IDE
+  • [green]gemini-cli[/green]      - Gemini CLI
 
 [dim]💡 Alias: 'mcp-vector-search remove' works the same way[/dim]
 """,
@@ -69,149 +78,130 @@ uninstall_app = create_enhanced_typer(
 
 
 # ==============================================================================
-# Platform Configuration (shared with install.py)
+# Helper Functions
 # ==============================================================================
 
-SUPPORTED_PLATFORMS = {
-    "claude-code": {
-        "name": "Claude Code",
-        "config_path": ".mcp.json",
-        "scope": "project",
-    },
-    "claude-desktop": {
-        "name": "Claude Desktop",
-        "config_path": "~/Library/Application Support/Claude/claude_desktop_config.json",
-        "scope": "global",
-    },
-    "cursor": {
-        "name": "Cursor",
-        "config_path": "~/.cursor/mcp.json",
-        "scope": "global",
-    },
-    "windsurf": {
-        "name": "Windsurf",
-        "config_path": "~/.codeium/windsurf/mcp_config.json",
-        "scope": "global",
-    },
-    "vscode": {
-        "name": "VS Code",
-        "config_path": "~/.vscode/mcp.json",
-        "scope": "global",
-    },
-}
-
-
-def get_platform_config_path(platform: str, project_root: Path) -> Path:
-    """Get the configuration file path for a platform."""
-    if platform not in SUPPORTED_PLATFORMS:
-        raise ValueError(f"Unsupported platform: {platform}")
-
-    config_info = SUPPORTED_PLATFORMS[platform]
-    config_path_str = config_info["config_path"]
-
-    if config_info["scope"] == "project":
-        return project_root / config_path_str
-    else:
-        return Path(config_path_str).expanduser()
-
-
-def unconfigure_platform(
-    platform: str,
-    project_root: Path,
-    server_name: str = "mcp-vector-search",
-    backup: bool = True,
-) -> bool:
-    """Remove MCP integration from a platform's configuration.
 
-    Args:
-        platform: Platform name (e.g., "claude-code", "cursor")
-        project_root: Project root directory
-        server_name: Name of the MCP server to remove
-        backup: Whether to create a backup before modification
+def detect_all_platforms() -> list[PlatformInfo]:
+    """Detect all available platforms on the system.
 
     Returns:
-        True if removal was successful, False otherwise
+        List of detected platforms with confidence scores
     """
-    try:
-        config_path = get_platform_config_path(platform, project_root)
-
-        # Check if config file exists
-        if not config_path.exists():
-            print_warning(f"  ⚠️  No configuration file found for {platform}")
-            return False
-
-        # Create backup
-        if backup:
-            backup_path = config_path.with_suffix(config_path.suffix + ".backup")
-            shutil.copy2(config_path, backup_path)
+    detector = PlatformDetector()
+    detected_platforms = []
+
+    # Try to detect each platform
+    platform_detectors = {
+        Platform.CLAUDE_CODE: detector.detect_claude_code,
+        Platform.CLAUDE_DESKTOP: detector.detect_claude_desktop,
+        Platform.CURSOR: detector.detect_cursor,
+        Platform.AUGGIE: detector.detect_auggie,
+        Platform.CODEX: detector.detect_codex,
+        Platform.WINDSURF: detector.detect_windsurf,
+        Platform.GEMINI_CLI: detector.detect_gemini_cli,
+    }
+
+    for platform_enum, detector_func in platform_detectors.items():
+        try:
+            confidence, config_path = detector_func()
+            if confidence > 0.0 and config_path:
+                # Determine CLI availability
+                cli_available = False
+                from py_mcp_installer.utils import resolve_command_path
+
+                if platform_enum in (Platform.CLAUDE_CODE, Platform.CLAUDE_DESKTOP):
+                    cli_available = resolve_command_path("claude") is not None
+                elif platform_enum == Platform.CURSOR:
+                    cli_available = resolve_command_path("cursor") is not None
+
+                platform_info = PlatformInfo(
+                    platform=platform_enum,
+                    confidence=confidence,
+                    config_path=config_path,
+                    cli_available=cli_available,
+                )
+                detected_platforms.append(platform_info)
+        except Exception as e:
+            logger.debug(f"Failed to detect {platform_enum.value}: {e}")
+            continue
 
-        # Load config
-        with open(config_path) as f:
-            config = json.load(f)
+    return detected_platforms
 
-        # Check if server exists
-        if "mcpServers" not in config or server_name not in config["mcpServers"]:
-            print_warning(f"  ⚠️  Server '{server_name}' not found in {platform} config")
-            return False
 
-        # Remove server
-        del config["mcpServers"][server_name]
+def platform_name_to_enum(name: str) -> Platform | None:
+    """Convert platform name to enum.
 
-        # Clean up empty mcpServers section
-        if not config["mcpServers"]:
-            del config["mcpServers"]
+    Args:
+        name: Platform name (e.g., "cursor", "claude-code")
 
-        # Write updated config (or remove file if empty)
-        if config:
-            with open(config_path, "w") as f:
-                json.dump(config, f, indent=2)
-        else:
-            # If config is now empty, remove the file for project-scoped configs
-            if SUPPORTED_PLATFORMS[platform]["scope"] == "project":
-                config_path.unlink()
-                print_info(f"     Removed empty config file: {config_path}")
+    Returns:
+        Platform enum or None if not found
+    """
+    name_map = {
+        "claude-code": Platform.CLAUDE_CODE,
+        "claude-desktop": Platform.CLAUDE_DESKTOP,
+        "cursor": Platform.CURSOR,
+        "auggie": Platform.AUGGIE,
+        "codex": Platform.CODEX,
+        "windsurf": Platform.WINDSURF,
+        "gemini-cli": Platform.GEMINI_CLI,
+    }
+    return name_map.get(name.lower())
+
+
+def find_configured_platforms() -> list[PlatformInfo]:
+    """Find all platforms that have mcp-vector-search configured.
 
-        platform_name = SUPPORTED_PLATFORMS[platform]["name"]
-        print_success(f"  ✅ Removed {platform_name} integration")
+    Returns:
+        List of platforms with mcp-vector-search installed
+    """
+    detected = detect_all_platforms()
+    configured = []
 
-        return True
+    for platform_info in detected:
+        try:
+            installer = MCPInstaller(platform=platform_info.platform)
+            server = installer.get_server("mcp-vector-search")
+            if server:
+                configured.append(platform_info)
+        except Exception as e:
+            logger.debug(
+                f"Failed to check {platform_info.platform.value} configuration: {e}"
+            )
+            continue
 
-    except Exception as e:
-        logger.error(f"Failed to unconfigure {platform}: {e}")
-        print_error(f"  ❌ Failed to remove {platform} integration: {e}")
-        return False
+    return configured
 
 
-def find_configured_platforms(project_root: Path) -> dict[str, Path]:
-    """Find all platforms that have mcp-vector-search configured.
+def uninstall_from_platform(platform_info: PlatformInfo) -> bool:
+    """Uninstall from a specific platform.
 
     Args:
-        project_root: Project root directory
+        platform_info: Platform information
 
     Returns:
-        Dictionary mapping platform names to their config paths
+        True if uninstallation succeeded
     """
-    configured = {}
-
-    for platform in SUPPORTED_PLATFORMS:
-        try:
-            config_path = get_platform_config_path(platform, project_root)
-
-            if not config_path.exists():
-                continue
-
-            # Check if mcp-vector-search is in the config
-            with open(config_path) as f:
-                config = json.load(f)
+    try:
+        installer = MCPInstaller(platform=platform_info.platform)
 
-            if "mcp-vector-search" in config.get("mcpServers", {}):
-                configured[platform] = config_path
+        # Uninstall server
+        result = installer.uninstall_server("mcp-vector-search")
 
-        except Exception:
-            # Ignore errors for individual platforms
-            continue
+        if result.success:
+            print_success(f"  ✅ Removed from {platform_info.platform.value}")
+            return True
+        else:
+            print_error(
+                f"  ❌ Failed to remove from {platform_info.platform.value}: {result.message}"
+            )
+            return False
 
-    return configured
+    except Exception as e:
+        logger.exception(f"Uninstallation from {platform_info.platform.value} failed")
+        print_error(f"  ❌ Uninstallation failed: {e}")
+        return False
 
 
 # ==============================================================================
@@ -219,266 +209,195 @@ def find_configured_platforms(project_root: Path) -> dict[str, Path]:
 # ==============================================================================
 
 
-@uninstall_app.callback()
-def main(
+@uninstall_app.command(name="mcp")
+def uninstall_mcp(
     ctx: typer.Context,
+    platform: str | None = typer.Option(
+        None,
+        "--platform",
+        "-p",
+        help="Specific platform to uninstall from (e.g., cursor, claude-code)",
+    ),
     all_platforms: bool = typer.Option(
         False,
         "--all",
-        help="Remove from all configured platforms",
-    ),
-    no_backup: bool = typer.Option(
-        False,
-        "--no-backup",
-        help="Skip creating backup files",
+        "-a",
+        help="Uninstall from all configured platforms",
     ),
 ) -> None:
-    """🗑️  Remove MCP integrations from platforms.
+    """Remove MCP integration from platforms.
 
-    Use subcommands to remove from specific platforms, or use --all
-    to remove from all configured platforms.
+    By default, uninstalls from the highest confidence platform. Use --all to
+    remove from all configured platforms.
 
     [bold cyan]Examples:[/bold cyan]
 
+      [green]Remove from auto-detected platform:[/green]
+        $ mcp-vector-search uninstall mcp
+
       [green]Remove from specific platform:[/green]
-        $ mcp-vector-search uninstall claude-code
+        $ mcp-vector-search uninstall mcp --platform cursor
 
       [green]Remove from all platforms:[/green]
-        $ mcp-vector-search uninstall --all
+        $ mcp-vector-search uninstall mcp --all
 
-      [green]List configured platforms:[/green]
-        $ mcp-vector-search uninstall list
-
-    [dim]💡 Backup files are created automatically unless --no-backup is used[/dim]
+    [dim]💡 Use 'mcp-vector-search uninstall list' to see configured platforms[/dim]
     """
-    # Only run if --all flag is used and no subcommand
-    if not all_platforms or ctx.invoked_subcommand is not None:
-        return
-
     project_root = ctx.obj.get("project_root") or Path.cwd()
 
     console.print(
         Panel.fit(
-            "[bold yellow]Removing All MCP Integrations[/bold yellow]\n"
+            "[bold yellow]Removing MCP Integration[/bold yellow]\n"
             f"📁 Project: {project_root}",
             border_style="yellow",
         )
     )
 
-    # Find all configured platforms
-    configured = find_configured_platforms(project_root)
-
-    if not configured:
-        print_info("No MCP integrations found to remove")
-        return
-
-    # Show what will be removed
-    console.print("\n[bold]Found integrations:[/bold]")
-    for platform in configured:
-        platform_name = SUPPORTED_PLATFORMS[platform]["name"]
-        console.print(f"  • {platform_name}")
-
-    # Confirm removal
-    if not confirm_action("\nRemove all integrations?", default=False):
-        print_info("Cancelled")
-        raise typer.Exit(0)
-
-    # Remove from all platforms
-    console.print("\n[bold]Removing integrations...[/bold]")
-    results = {}
-
-    for platform in configured:
-        results[platform] = unconfigure_platform(
-            platform, project_root, backup=not no_backup
-        )
-
-    # Summary
-    successful = sum(1 for success in results.values() if success)
-    total = len(results)
-
-    console.print(
-        f"\n[bold green]✨ Removed {successful}/{total} integrations[/bold green]"
-    )
-
-    if successful < total:
-        print_warning("Some integrations could not be removed")
-        print_info("Check the output above for details")
+    try:
+        # Find configured platforms
+        print_info("🔍 Finding configured platforms...")
+        configured = find_configured_platforms()
+
+        if not configured:
+            print_info("No MCP integrations found to remove")
+            return
+
+        # Display configured platforms
+        table = Table(title="Configured MCP Platforms")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Config Path", style="green")
+        table.add_column("Confidence", style="yellow")
+
+        for p in configured:
+            table.add_row(
+                p.platform.value,
+                str(p.config_path) if p.config_path else "N/A",
+                f"{p.confidence:.2f}",
+            )
+
+        console.print(table)
+
+        # Filter platforms
+        target_platforms = configured
+
+        if platform:
+            # Uninstall from specific platform
+            platform_enum = platform_name_to_enum(platform)
+            if not platform_enum:
+                print_error(f"Unknown platform: {platform}")
+                print_info(
+                    "Supported: claude-code, claude-desktop, cursor, auggie, codex, windsurf, gemini-cli"
+                )
+                raise typer.Exit(1)
+
+            target_platforms = [p for p in configured if p.platform == platform_enum]
+
+            if not target_platforms:
+                print_error(
+                    f"Platform '{platform}' does not have mcp-vector-search configured"
+                )
+                raise typer.Exit(1)
+
+        elif not all_platforms:
+            # By default, uninstall from highest confidence platform only
+            if configured:
+                max_confidence_platform = max(configured, key=lambda p: p.confidence)
+                target_platforms = [max_confidence_platform]
+                print_info(
+                    f"Removing from highest confidence platform: {max_confidence_platform.platform.value}"
+                )
+                print_info("Use --all to remove from all configured platforms")
+
+        # Show what will be removed
+        console.print("\n[bold]Target platforms:[/bold]")
+        for p in target_platforms:
+            console.print(f"  • {p.platform.value}")
+
+        # Confirm removal if multiple platforms
+        if len(target_platforms) > 1:
+            if not confirm_action("\nRemove from all these platforms?", default=False):
+                print_info("Cancelled")
+                raise typer.Exit(0)
+
+        # Uninstall from each platform
+        console.print("\n[bold]Removing integrations...[/bold]")
+        successful = 0
+        failed = 0
+
+        for platform_info in target_platforms:
+            if uninstall_from_platform(platform_info):
+                successful += 1
+            else:
+                failed += 1
+
+        # Summary
+        console.print("\n[bold green]✨ Removal Summary[/bold green]")
+        console.print(f"  ✅ Successful: {successful}")
+        if failed > 0:
+            console.print(f"  ❌ Failed: {failed}")
+
+        console.print("\n[dim]💡 Restart your AI coding tool to apply changes[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.exception("MCP uninstallation failed")
+        print_error(f"Uninstallation failed: {e}")
+        raise typer.Exit(1)
 
 
 # ==============================================================================
-# Platform-Specific Uninstall Commands
+# List Configured Platforms Command
 # ==============================================================================
 
 
-@uninstall_app.command("claude-code")
-def uninstall_claude_code(
-    ctx: typer.Context,
-    no_backup: bool = typer.Option(False, "--no-backup", help="Skip backup creation"),
-) -> None:
-    """Remove Claude Code MCP integration (project-scoped)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold yellow]Removing Claude Code Integration[/bold yellow]\n"
-            "📁 Project-scoped configuration",
-            border_style="yellow",
-        )
-    )
-
-    success = unconfigure_platform("claude-code", project_root, backup=not no_backup)
-
-    if success:
-        console.print("\n[bold green]✅ Claude Code Integration Removed[/bold green]")
-        console.print("\n[dim]💡 Restart Claude Code to apply changes[/dim]")
-    else:
-        raise typer.Exit(1)
-
-
-@uninstall_app.command("cursor")
-def uninstall_cursor(
-    ctx: typer.Context,
-    no_backup: bool = typer.Option(False, "--no-backup"),
-) -> None:
-    """Remove Cursor IDE MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold yellow]Removing Cursor Integration[/bold yellow]\n"
-            "🌐 Global configuration",
-            border_style="yellow",
-        )
-    )
-
-    success = unconfigure_platform("cursor", project_root, backup=not no_backup)
-
-    if success:
-        console.print("\n[bold green]✅ Cursor Integration Removed[/bold green]")
-        console.print("\n[dim]💡 Restart Cursor to apply changes[/dim]")
-    else:
-        raise typer.Exit(1)
-
-
-@uninstall_app.command("windsurf")
-def uninstall_windsurf(
-    ctx: typer.Context,
-    no_backup: bool = typer.Option(False, "--no-backup"),
-) -> None:
-    """Remove Windsurf IDE MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold yellow]Removing Windsurf Integration[/bold yellow]\n"
-            "🌐 Global configuration",
-            border_style="yellow",
-        )
-    )
-
-    success = unconfigure_platform("windsurf", project_root, backup=not no_backup)
-
-    if success:
-        console.print("\n[bold green]✅ Windsurf Integration Removed[/bold green]")
-        console.print("\n[dim]💡 Restart Windsurf to apply changes[/dim]")
-    else:
-        raise typer.Exit(1)
-
-
-@uninstall_app.command("claude-desktop")
-def uninstall_claude_desktop(
-    ctx: typer.Context,
-    no_backup: bool = typer.Option(False, "--no-backup"),
-) -> None:
-    """Remove Claude Desktop MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold yellow]Removing Claude Desktop Integration[/bold yellow]\n"
-            "🌐 Global configuration",
-            border_style="yellow",
-        )
-    )
-
-    success = unconfigure_platform("claude-desktop", project_root, backup=not no_backup)
-
-    if success:
-        console.print(
-            "\n[bold green]✅ Claude Desktop Integration Removed[/bold green]"
-        )
-        console.print("\n[dim]💡 Restart Claude Desktop to apply changes[/dim]")
-    else:
-        raise typer.Exit(1)
-
-
-@uninstall_app.command("vscode")
-def uninstall_vscode(
-    ctx: typer.Context,
-    no_backup: bool = typer.Option(False, "--no-backup"),
-) -> None:
-    """Remove VS Code MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold yellow]Removing VS Code Integration[/bold yellow]\n"
-            "🌐 Global configuration",
-            border_style="yellow",
-        )
-    )
-
-    success = unconfigure_platform("vscode", project_root, backup=not no_backup)
-
-    if success:
-        console.print("\n[bold green]✅ VS Code Integration Removed[/bold green]")
-        console.print("\n[dim]💡 Restart VS Code to apply changes[/dim]")
-    else:
-        raise typer.Exit(1)
-
-
 @uninstall_app.command("list")
 def list_integrations(ctx: typer.Context) -> None:
     """List all currently configured MCP integrations."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
     console.print(
         Panel.fit(
             "[bold cyan]Configured MCP Integrations[/bold cyan]", border_style="cyan"
         )
     )
 
-    configured = find_configured_platforms(project_root)
-
-    if not configured:
-        console.print("\n[yellow]No MCP integrations configured[/yellow]")
+    try:
+        configured = find_configured_platforms()
+
+        if not configured:
+            console.print("\n[yellow]No MCP integrations configured[/yellow]")
+            console.print(
+                "\n[dim]Use 'mcp-vector-search install mcp' to add integrations[/dim]"
+            )
+            return
+
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Config Path")
+        table.add_column("Confidence", style="yellow")
+        table.add_column("Removal Command", style="dim")
+
+        for platform_info in configured:
+            table.add_row(
+                platform_info.platform.value,
+                str(platform_info.config_path) if platform_info.config_path else "N/A",
+                f"{platform_info.confidence:.2f}",
+                f"mcp-vector-search uninstall mcp --platform {platform_info.platform.value}",
+            )
+
+        console.print(table)
+
+        console.print("\n[bold blue]Removal Options:[/bold blue]")
         console.print(
-            "\n[dim]Use 'mcp-vector-search install <platform>' to add integrations[/dim]"
+            "  • Remove specific: [code]mcp-vector-search uninstall mcp --platform <name>[/code]"
         )
-        return
-
-    table = Table(show_header=True, header_style="bold cyan")
-    table.add_column("Platform", style="cyan")
-    table.add_column("Name")
-    table.add_column("Config Location")
-    table.add_column("Removal Command", style="dim")
-
-    for platform, config_path in configured.items():
-        platform_info = SUPPORTED_PLATFORMS[platform]
-        table.add_row(
-            platform,
-            platform_info["name"],
-            str(config_path),
-            f"mcp-vector-search uninstall {platform}",
+        console.print(
+            "  • Remove all:      [code]mcp-vector-search uninstall mcp --all[/code]"
         )
 
-    console.print(table)
-
-    console.print("\n[bold blue]Removal Options:[/bold blue]")
-    console.print(
-        "  • Remove specific: [code]mcp-vector-search uninstall <platform>[/code]"
-    )
-    console.print("  • Remove all:      [code]mcp-vector-search uninstall --all[/code]")
+    except Exception as e:
+        logger.exception("Failed to list configured platforms")
+        print_error(f"Failed to list configured platforms: {e}")
+        raise typer.Exit(1)
 
 
 if __name__ == "__main__":