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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nodepick-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Official Python CLI for nodepick.ai
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.24.0

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nodepick-cli"
-version = "0.1.2"
+version = "0.1.3"
 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.3}/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.3/src/nodepick_cli/commands/network.py

@@ -0,0 +1,127 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+import nodepick
+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", "NAT")
+    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 "-"),
+            "Enabled" if net.get("enableOutboundNat", True) else "Disabled",
+        )
+    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="Alphanumeric name for the VPC network"),
+    region: str = typer.Option(..., "--region", "-r", help="Target geographic region (e.g. us-west-1)"),
+    description: Optional[str] = typer.Option(None, "--description", "-d", help="Optional description"),
+    enable_nat: bool = typer.Option(True, "--nat/--no-nat", help="Enable outbound NAT gateway"),
+):
+    """Create a new VPC network."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Creating VPC network '{name}'...[/cyan]")
+        network = client.vpc_create(
+            name=name,
+            region=region,
+            description=description,
+            enable_outbound_nat=enable_nat,
+        )
+        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")