nodepick-cli 0.1.2__tar.gz → 0.1.4__tar.gz

nodepick_cli-0.1.4/CHANGELOG.md

@@ -0,0 +1,27 @@
+# CHANGELOG.md
+
+## [0.1.4] - 2026-10-08
+
+### Added
+- Added short option `-s` alias to `--storage` on `np node create`.
+- Added `--region` (`-r`) option to `np node create` to specify the deployment region.
+- Added `--host` option to `np node create` to deploy directly onto a specified compute Host ID.
+- Added region validation against supported active regions for `np node create` and `np network create`.
+- Added `np regions` command to list available compute regions.
+- Added `np compute` top-level command for compute discovery with real-time pricing and consolidated RAM/Disk/CPU specs.
+- Added `np --version` (`-v`) flag.
+- Added `np ai mcp configure <agent> [nodes...]` command to configure MCP servers on AI agents (Antigravity, OpenCode).
+
+### Changed
+- Changed authentication command from `np auth save` to `np auth configure`.
+- Replaced `np find` and `np node find` with top-level `np compute`.
+- Removed NAT configuration options from `np network` commands (outbound NAT enabled upstream by default).
+- Updated `--region` help message on `np node create` and `np network create` to "Target region or datacenter (e.g. us-west-1, fmt1)".
+- Cleaned option type formatting in `np node create` help output (removed redundant `[x>=...]` range tags).
+
+## [0.1.0] - 2026-07-31
+
+### Added
+- Created `np` CLI tool in `cli/` using Typer and Rich.
+- Added commands: `list`, `create`, `get`, `delete`, `shutdown`, `reboot`.
+

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nodepick-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Official Python CLI for nodepick.ai
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.24.0
@@ -65,8 +65,17 @@ Check the official [`Documentation`](https://docs.nodepick.ai/cli-reference/over
 ### Basic Usage
 
 ```bash
-# List all compute nodes (table view with SSH connect command)
+# Check version
 np --version
+
+# List available regions
+np regions
+
+# Deploy a compute node in a specific region
+np node create --name dev-node --region us-west-1
+
+# List compute nodes
+np node list
 ```
 
 ### Authentication

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/README.md

@@ -53,8 +53,17 @@ Check the official [`Documentation`](https://docs.nodepick.ai/cli-reference/over
 ### Basic Usage
 
 ```bash
-# List all compute nodes (table view with SSH connect command)
+# Check version
 np --version
+
+# List available regions
+np regions
+
+# Deploy a compute node in a specific region
+np node create --name dev-node --region us-west-1
+
+# List compute nodes
+np node list
 ```
 
 ### Authentication

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nodepick-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Official Python CLI for nodepick.ai"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -25,7 +25,7 @@ np = "nodepick_cli.main:app"
 packages = ["src/nodepick_cli"]
 
 [tool.uv.sources]
-nodepick = { path = "../sdk/python" }
+nodepick = { path = "../sdk/python", editable = true }
 
 
 

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/src/nodepick_cli/__init__.py

@@ -3,7 +3,7 @@ import importlib.metadata
 try:
     __version__ = importlib.metadata.version("nodepick-cli")
 except Exception:
-    __version__ = "0.1.0"
+    __version__ = "0.1.4"
 
 from .main import app
 

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/src/nodepick_cli/commands/ai.py

@@ -58,6 +58,57 @@ def configure_antigravity_mcp(servers: Dict[str, Any]) -> List[Path]:
     return updated_files
 
 
+def _delete_json_mcp_servers(file_path: Path, server_names: Optional[List[str]] = None) -> List[str]:
+    """Safely remove MCP servers from a JSON configuration file."""
+    if not file_path.exists():
+        return []
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+            if not content:
+                return []
+            data = json.loads(content)
+    except Exception:
+        return []
+
+    if not isinstance(data, dict) or "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+        return []
+
+    removed = []
+    if server_names:
+        for name in server_names:
+            if name in data["mcpServers"]:
+                del data["mcpServers"][name]
+                removed.append(name)
+    else:
+        removed = list(data["mcpServers"].keys())
+        data["mcpServers"] = {}
+
+    if removed:
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+
+    return removed
+
+
+def delete_antigravity_mcp(server_names: Optional[List[str]] = None) -> List[str]:
+    """Remove MCP servers for Google Antigravity across its standard configuration locations."""
+    home = Path.home()
+    target_files = [
+        home / ".gemini" / "config" / "mcp_config.json",
+        home / ".gemini" / "settings.json",
+        home / ".gemini" / "antigravity-cli" / "settings.json",
+    ]
+    all_removed = set()
+    for path in target_files:
+        try:
+            removed = _delete_json_mcp_servers(path, server_names)
+            all_removed.update(removed)
+        except Exception as e:
+            console.print(f"[dim yellow]Warning: Failed modifying {path}: {e}[/dim yellow]")
+    return list(all_removed)
+
+
 @mcp_app.command("configure")
 def mcp_configure(
     agent: str = typer.Argument(
@@ -67,8 +118,19 @@ def mcp_configure(
     nodes: Optional[List[str]] = typer.Argument(
         None, help="Node IDs or display names to configure MCP for (if omitted, configures all nodes)"
     ),
+    insecure: bool = typer.Option(
+        False,
+        "--insecure",
+        help="Disable HTTPS certificate verification for MCP server connections.",
+    ),
+    delete: bool = typer.Option(
+        False,
+        "--delete",
+        "-d",
+        help="Delete the MCP server configuration for the specified node(s) or agent.",
+    ),
 ):
-    """Configure MCP servers for an AI agent (e.g. antigravity) to connect to compute nodes."""
+    """Configure or delete MCP servers for an AI agent (e.g. antigravity) to connect to compute nodes."""
     agent_clean = agent.strip().lower()
     if agent_clean not in ("antigravity", "agy", "gemini"):
         console.print(
@@ -78,6 +140,42 @@ def mcp_configure(
         )
         raise typer.Exit(1)
 
+    if delete:
+        try:
+            names_to_delete = list(nodes) if nodes else None
+            if names_to_delete:
+                try:
+                    client = get_client()
+                    for n in list(names_to_delete):
+                        try:
+                            details = client.node_get_details(n)
+                            for key in ("display_name", "displayName", "name", "vm_uuid", "id"):
+                                val = details.get(key)
+                                if val and val not in names_to_delete:
+                                    names_to_delete.append(val)
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+
+            if agent_clean in ("antigravity", "agy", "gemini"):
+                removed = delete_antigravity_mcp(names_to_delete)
+                if removed:
+                    for r in sorted(removed):
+                        console.print(f"[bold green]✔[/bold green] Removed MCP server configuration '[bold]{r}[/bold]'")
+                    console.print(
+                        f"[bold green]Successfully removed {len(removed)} MCP server configuration(s) for {agent_clean}.[/bold green]"
+                    )
+                else:
+                    if nodes:
+                        console.print(f"[yellow]No matching MCP server configurations found to delete for: {', '.join(nodes)}[/yellow]")
+                    else:
+                        console.print(f"[yellow]No MCP server configurations found to delete for {agent_clean}.[/yellow]")
+            return
+        except Exception as e:
+            handle_error(e, "Error deleting MCP configuration")
+            return
+
     client = get_client()
 
     try:
@@ -131,15 +229,18 @@ def mcp_configure(
                 "type": "http",
                 "transport": "http",
                 "protocol": "streamable_http",
-                "insecure": True,
-                "insecureSkipVerify": True,
-                "rejectUnauthorized": False,
-                "verify": False,
-                "tls": {
+            }
+            if insecure:
+                server_config.update({
                     "insecure": True,
                     "insecureSkipVerify": True,
-                },
-            }
+                    "rejectUnauthorized": False,
+                    "verify": False,
+                    "tls": {
+                        "insecure": True,
+                        "insecureSkipVerify": True,
+                    },
+                })
             if mcp_api_key:
                 server_config["headers"] = {
                     "Authorization": f"Bearer {mcp_api_key}",

nodepick_cli-0.1.4/src/nodepick_cli/commands/compute.py

@@ -0,0 +1,117 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table, Column
+from .node import get_client
+from ..core.exceptions import handle_error
+from ..core.formatters import OutputFormat, set_output_format, print_output
+
+console = Console()
+
+
+def _render_compute_hosts_table(hosts):
+    if not hosts:
+        console.print("[yellow]No compute hosts found matching criteria.[/yellow]")
+        return
+
+    table = Table(
+        Column("Host ID", no_wrap=True),
+        "Status",
+        "Region",
+        "Datacenter",
+        "RAM/Disk/CPU",
+        "Price/hr ($)",
+        "Price/mo ($)",
+    )
+    for host in hosts:
+        # Show requested specs (RAM, CPU, and Disk) for which pricing was evaluated,
+        # rather than the compute host's total reported capacity.
+        req_cpu = host.get("requested_cpu")
+        if req_cpu is None:
+            cpu_info = host.get("cpu", {})
+            req_cpu = cpu_info.get("cores") if isinstance(cpu_info, dict) else cpu_info
+
+        req_mem = host.get("requested_memory_gb")
+        if req_mem is None:
+            req_mem = host.get("memory_gb")
+        elif isinstance(req_mem, (int, float)) and req_mem == int(req_mem):
+            req_mem = int(req_mem)
+
+        req_disk = host.get("requested_storage_gb")
+        if req_disk is None:
+            req_disk = host.get("storage_gb")
+
+        def _fmt(val):
+            if val is None:
+                return "?"
+            if isinstance(val, (int, float)):
+                return str(int(val)) if val == int(val) else str(val)
+            return str(val)
+
+        specs_str = f"{_fmt(req_mem)}/{_fmt(req_disk)}/{_fmt(req_cpu)}"
+
+        pricing = host.get("pricing") if isinstance(host.get("pricing"), dict) else {}
+        hourly = pricing.get("hourly") or pricing.get("hour") or host.get("estimated_hourly_cost_usd")
+        monthly = pricing.get("monthly") or host.get("estimated_monthly_cost_usd")
+
+        if hourly is not None:
+            try:
+                hourly_str = f"${float(hourly):.4f}"
+            except (ValueError, TypeError):
+                hourly_str = f"${hourly}"
+        else:
+            hourly_str = "N/A"
+
+        if monthly is not None:
+            try:
+                monthly_str = f"${float(monthly):.2f}"
+            except (ValueError, TypeError):
+                monthly_str = f"${monthly}"
+        else:
+            monthly_str = "N/A"
+
+        status_val = str(host.get("status") or "active")
+
+        table.add_row(
+            str(host.get("id") or "N/A"),
+            status_val,
+            str(host.get("region") or "N/A"),
+            str(host.get("datacenter") or "N/A"),
+            specs_str,
+            hourly_str,
+            monthly_str,
+        )
+    console.print(table)
+
+
+def compute_command(
+    cpu: Optional[int] = typer.Option(None, "--cpu", "-c", help="Minimum CPU cores"),
+    memory_gb: Optional[float] = typer.Option(None, "--memory", "-m", help="Minimum RAM in GB"),
+    storage_gb: Optional[int] = typer.Option(None, "--storage", "-s", help="Minimum storage in GB"),
+    max_price: Optional[float] = typer.Option(None, "--max-price", "-p", help="Maximum monthly price in USD"),
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Filter by target region"),
+    datacenter: Optional[str] = typer.Option(None, "--datacenter", help="Filter by datacenter facility code"),
+    status: Optional[str] = typer.Option(None, "--status", help="Filter by host status (active, reservable, all)"),
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """Find and discover available compute hosts matching specific hardware and pricing criteria."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        hosts = client.find_compute(
+            min_cpu=cpu,
+            min_memory_gb=memory_gb,
+            min_storage_gb=storage_gb,
+            max_price=max_price,
+            region=region,
+            datacenter=datacenter,
+            status=status,
+        )
+        print_output(hosts, table_render_func=_render_compute_hosts_table)
+    except Exception as e:
+        handle_error(e, "Error finding compute hosts")

nodepick_cli-0.1.4/src/nodepick_cli/commands/network.py

@@ -0,0 +1,126 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from ..commands.regions import validate_region
+from ..commands.node import get_client
+from ..core.exceptions import handle_error
+from ..core.formatters import OutputFormat, set_output_format, print_output
+
+app = typer.Typer(name="network", help="Manage VPC Networks.")
+console = Console()
+
+
+def _render_networks_table(networks):
+    if not networks:
+        console.print("[yellow]No VPC networks found.[/yellow]")
+        return
+
+    table = Table("ID", "Name", "Subnet", "Region")
+    for net in networks:
+        table.add_row(
+            str(net.get("id") or "N/A"),
+            str(net.get("name") or "N/A"),
+            str(net.get("subnet") or "N/A"),
+            str(net.get("region") or "-"),
+        )
+    console.print(table)
+
+
+def _render_network_details_table(network):
+    if not network:
+        console.print("[yellow]No VPC network details found.[/yellow]")
+        return
+
+    table = Table("Field", "Value")
+    fields = [
+        ("ID", network.get("id")),
+        ("Name", network.get("name")),
+        ("Description", network.get("description")),
+        ("Subnet", network.get("subnet")),
+        ("Gateway", network.get("gateway")),
+        ("Region", network.get("region")),
+        ("VNI", network.get("vni")),
+        ("Outbound NAT", "Enabled" if network.get("enableOutboundNat", True) else "Disabled"),
+        ("Created At", network.get("createdAt") or network.get("created_at")),
+    ]
+    for field, value in fields:
+        if value is not None:
+            table.add_row(field, str(value))
+    console.print(table)
+
+
+@app.command("list")
+def network_list(
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """List organization VPC networks."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        networks = client.vpc_list()
+        print_output(networks, table_render_func=_render_networks_table)
+    except Exception as e:
+        handle_error(e, "Error listing VPC networks")
+
+
+@app.command("create")
+def network_create(
+    name: str = typer.Argument(..., help="Name for the VPC network (alphanumeric, dashes, and underscores)"),
+    region: str = typer.Option(..., "--region", "-r", help="Target region or datacenter (e.g. us-west-1, fmt1)"),
+    description: Optional[str] = typer.Option(None, "--description", "-d", help="Optional description"),
+):
+    """Create a new VPC network."""
+    client = get_client()
+    if region:
+        validate_region(client, region)
+    try:
+        console.print(f"[cyan]Creating VPC network '{name}'...[/cyan]")
+        network = client.vpc_create(
+            name=name,
+            region=region,
+            description=description,
+        )
+        vpc_id = network.get("id")
+        console.print(f"[bold green]VPC network created successfully![/bold green] ID: {vpc_id}")
+    except Exception as e:
+        handle_error(e, "Error creating VPC network")
+
+
+@app.command("get")
+def network_get(
+    vpc_id: str = typer.Argument(..., help="VPC Network ID or name"),
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """Get details of a specific VPC network."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        network = client.vpc_get(vpc_id)
+        print_output(network, table_render_func=_render_network_details_table)
+    except Exception as e:
+        handle_error(e, "Error getting VPC network details")
+
+
+@app.command("delete")
+def network_delete(
+    vpc_id: str = typer.Argument(..., help="VPC Network ID or name to delete"),
+):
+    """Delete an organization VPC network."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Deleting VPC network {vpc_id}...[/cyan]")
+        res = client.vpc_delete(vpc_id)
+        console.print(f"[bold green]VPC network {vpc_id} deleted.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error deleting VPC network")

{nodepick_cli-0.1.2 → nodepick_cli-0.1.4}/src/nodepick_cli/commands/node.py

@@ -1,5 +1,6 @@
 import typer
-from typing import Optional
+import typer.core
+from typing import Optional, List, Dict, Any
 from rich.console import Console
 from rich.table import Table, Column
 import nodepick
@@ -8,8 +9,19 @@ from ..core.exceptions import handle_error
 from ..core.formatters import OutputFormat, set_output_format, get_output_format, print_output
 
 
+class NodeTyperGroup(typer.core.TyperGroup):
+    """Custom TyperGroup allowing both 'np node <action> <node_id>' and 'np node <node_id> <action>'."""
+    def parse_args(self, ctx, args):
+        actions = {
+            "attach-ip", "detach-ip",
+            "boot", "reboot", "shutdown", "delete", "get"
+        }
+        if len(args) >= 2 and args[1] in actions and args[0] not in self.commands:
+            args = [args[1], args[0]] + list(args[2:])
+        return super().parse_args(ctx, args)
 
-app = typer.Typer(name="node", help="Manage Compute Nodes.")
+
+app = typer.Typer(cls=NodeTyperGroup, name="node", help="Manage Compute Nodes.")
 console = Console()
 
 from click.core import ParameterSource
@@ -70,6 +82,10 @@ def _render_nodes_table(nodes, client=None):
         )
     console.print(table)
 
+
+
+
+
 @app.command("boot")
 def node_boot(
     node_id: str = typer.Argument(..., help="Node ID or display name to boot"),
@@ -84,32 +100,131 @@ def node_boot(
         handle_error(e, "Error booting node")
 
 
+from .regions import validate_region, _render_regions_table
+
+
+def _validate_cpu(val: int) -> int:
+    if val < 1:
+        raise typer.BadParameter("Number of vCPUs must be at least 1.")
+    return val
+
+
+def _validate_memory(val: int) -> int:
+    if val < 1:
+        raise typer.BadParameter("Memory size must be at least 1 GB.")
+    return val
+
+
+def _validate_storage(val: int) -> int:
+    if val < 10:
+        raise typer.BadParameter("Disk storage must be at least 10 GB.")
+    return val
+
+
 @app.command("create")
 def node_create(
     display_name: Optional[str] = typer.Option(None, "--name", "-n", help="Display name for the node"),
-    cpu: int = typer.Option(1, "--cpu", "-c", help="Number of vCPUs"),
-    memory_mb: int = typer.Option(512, "--memory", "-m", help="Memory size in MB"),
-    network_type: str = typer.Option("private", "--network", help="Network type (private/public)"),
-    storage_gb: Optional[int] = typer.Option(None, "--storage", help="Disk storage in GB (default: 10)"),
+    cpu: int = typer.Option(1, "--cpu", "-c", callback=_validate_cpu, help="Number of vCPUs (min: 1)"),
+    memory: int = typer.Option(1, "--memory", "-m", callback=_validate_memory, help="Memory size in GB (min: 1)"),
+    storage_gb: int = typer.Option(10, "--storage", "-s", callback=_validate_storage, help="Disk storage in GB (min: 10)"),
+    vpc: Optional[str] = typer.Option(None, "--vpc", help="VPC network ID or name to deploy node into"),
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Target region or datacenter (e.g. us-west-1, fmt1)"),
+    host_id: Optional[str] = typer.Option(None, "--host", "--host-id", "--system-id", help="Target Host ID to deploy onto"),
 ):
     """Deploy a new compute node."""
     client = get_client()
-    memory_bytes = memory_mb * 1024 * 1024
+    if region:
+        validate_region(client, region)
     try:
         console.print("[cyan]Creating node...[/cyan]")
         node = client.node_create(
-            memory=memory_bytes,
+            memory=memory,
             cpu=cpu,
-            network_type=network_type,
             display_name=display_name,
             storage_gb=storage_gb,
+            vpc=vpc,
+            region=region,
+            host_id=host_id,
         )
-        node_id = node.get("vm_uuid")
+        node_id = node.get("vm_uuid") or node.get("id")
         console.print(f"[bold green]Node created successfully![/bold green] ID: {node_id}")
     except Exception as e:
         handle_error(e, "Error creating node")
 
 
+@app.command("attach-ip")
+def node_attach_ip(
+    node_id: str = typer.Argument(..., help="Node ID or display name"),
+    ip: str = typer.Option(
+        "auto",
+        "--ip",
+        help="Public IP address to attach (IPv4 or IPv6), or 'auto' (IPv4) / 'auto-ipv6' (IPv6)",
+    ),
+):
+    """Attach a public IP address (IPv4 or IPv6) to a compute node."""
+    client = get_client()
+    target_ip = ip
+    if isinstance(target_ip, str):
+        cleaned = target_ip.strip().lower()
+        if cleaned in ("auto-ipv6", "ipv6", "v6", "6"):
+            target_ip = "auto-ipv6"
+        elif cleaned in ("auto-ipv4", "ipv4", "v4", "4"):
+            target_ip = "auto"
+
+    is_v6_target = target_ip == "auto-ipv6" or ":" in target_ip
+    ver_target = "IPv6" if is_v6_target else "IPv4"
+    try:
+        console.print(f"[cyan]Attaching public {ver_target} to node {node_id}...[/cyan]")
+        res = client.node_attach_ip(node_id, ip=target_ip)
+        assigned_ip = res.get("ip") or "assigned"
+        is_v6_res = res.get("ipVersion") == 6 or ":" in str(assigned_ip)
+        ver_res = "IPv6" if is_v6_res else "IPv4"
+        console.print(f"[bold green]Public {ver_res} attached to node {node_id}:[/bold green] [cyan]{assigned_ip}[/cyan]")
+    except Exception as e:
+        handle_error(e, f"Error attaching public {ver_target}")
+
+
+@app.command("detach-ip")
+def node_detach_ip(
+    node_id: str = typer.Argument(..., help="Node ID or display name"),
+    ip: Optional[str] = typer.Option(None, "--ip", help="Specific public IP address to detach (auto-detected if omitted)"),
+    ipv6: bool = typer.Option(False, "--ipv6", "-6", help="Detach public IPv6 address"),
+):
+    """Detach a public IP address (IPv4 or IPv6) from a compute node."""
+    client = get_client()
+    target_ip = ip
+    if not target_ip and ipv6:
+        try:
+            details = client.node_get_details(node_id)
+            connect = details.get("connect") or {}
+            candidate = connect.get("publicIpv6") or connect.get("ipv6")
+            if candidate:
+                target_ip = candidate
+        except Exception:
+            pass
+    elif not target_ip:
+        try:
+            details = client.node_get_details(node_id)
+            connect = details.get("connect") or {}
+            pub4 = connect.get("publicIp")
+            pub6 = connect.get("publicIpv6") or connect.get("ipv6")
+            if pub6 and not pub4:
+                target_ip = pub6
+            elif pub4:
+                target_ip = pub4
+        except Exception:
+            pass
+
+    is_v6 = (":" in target_ip) if target_ip else ipv6
+    ver_label = "IPv6" if is_v6 else "IPv4"
+    try:
+        console.print(f"[cyan]Detaching public {ver_label} from node {node_id}...[/cyan]")
+        res = client.node_detach_ip(node_id, ip=target_ip)
+        console.print(f"[bold green]Public {ver_label} detached from node {node_id}.[/bold green]")
+    except Exception as e:
+        handle_error(e, f"Error detaching public {ver_label}")
+
+
 @app.command("delete")
 def node_delete(
     node_id: str = typer.Argument(..., help="Node ID or display name to delete"),