nodepick-cli 0.1.3__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.3 → nodepick_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nodepick-cli
-Version: 0.1.3
+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.3 → 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.3 → nodepick_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nodepick-cli"
-version = "0.1.3"
+version = "0.1.4"
 description = "Official Python CLI for nodepick.ai"
 readme = "README.md"
 requires-python = ">=3.10"

{nodepick_cli-0.1.3 → 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.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.3 → nodepick_cli-0.1.4}/src/nodepick_cli/commands/network.py

@@ -2,7 +2,7 @@ import typer
 from typing import Optional
 from rich.console import Console
 from rich.table import Table
-import nodepick
+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
@@ -16,14 +16,13 @@ def _render_networks_table(networks):
         console.print("[yellow]No VPC networks found.[/yellow]")
         return
 
-    table = Table("ID", "Name", "Subnet", "Region", "NAT")
+    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 "-"),
-            "Enabled" if net.get("enableOutboundNat", True) else "Disabled",
         )
     console.print(table)
 
@@ -72,20 +71,20 @@ def network_list(
 
 @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)"),
+    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"),
-    enable_nat: bool = typer.Option(True, "--nat/--no-nat", help="Enable outbound NAT gateway"),
 ):
     """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,
-            enable_outbound_nat=enable_nat,
         )
         vpc_id = network.get("id")
         console.print(f"[bold green]VPC network created successfully![/bold green] ID: {vpc_id}")

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

@@ -83,104 +83,7 @@ def _render_nodes_table(nodes, client=None):
     console.print(table)
 
 
-def _render_compute_hosts_table(hosts):
-    if not hosts:
-        console.print("[yellow]No compute hosts found matching criteria.[/yellow]")
-        return
-
-    table = Table(
-        "Host ID",
-        "Region",
-        "Datacenter",
-        "RAM (GB)",
-        "Disk (GB)",
-        "CPU (Cores)",
-        "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")
-
-        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"
 
-        table.add_row(
-            str(host.get("id") or "N/A"),
-            str(host.get("region") or "N/A"),
-            str(host.get("datacenter") or "N/A"),
-            str(req_mem if req_mem is not None else "N/A"),
-            str(req_disk if req_disk is not None else "N/A"),
-            str(req_cpu if req_cpu is not None else "N/A"),
-            hourly_str,
-            monthly_str,
-        )
-    console.print(table)
-
-
-@app.command("find")
-def node_find(
-    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: str = typer.Option("active", "--status", help="Filter by host status (active, reserved, 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")
 
 
 @app.command("boot")
@@ -197,16 +100,41 @@ 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", min=1, help="Number of vCPUs (min: 1)"),
-    memory: int = typer.Option(1, "--memory", "-m", min=1, help="Memory size in GB (min: 1, default: 1)"),
-    storage_gb: Optional[int] = typer.Option(None, "--storage", min=10, help="Disk storage in GB (min: 10, 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()
+    if region:
+        validate_region(client, region)
     try:
         console.print("[cyan]Creating node...[/cyan]")
         node = client.node_create(
@@ -215,8 +143,10 @@ def node_create(
             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")

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

@@ -0,0 +1,83 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from typing import Optional
+import nodepick
+from nodepick_cli.core.config import get_api_key, get_base_url
+from nodepick_cli.core.formatters import OutputFormat, set_output_format, print_output
+from nodepick_cli.core.exceptions import handle_error
+
+console = Console()
+
+
+def get_client() -> nodepick.NodePickClient:
+    key = get_api_key()
+    url = get_base_url()
+    if not key:
+        console.print(
+            "[yellow]No API key found.[/yellow] "
+            "Run [bold]np auth configure[/bold] to store your API key."
+        )
+        raise typer.Exit(1)
+    return nodepick.NodePickClient(api_key=key, base_url=url)
+
+
+def validate_region(client, region: Optional[str]) -> None:
+    """Validate that region is among available regions if regions are returned by the API."""
+    if not region:
+        return
+    try:
+        raw_regions = client.get_available_regions()
+        if isinstance(raw_regions, list) and len(raw_regions) > 0:
+            supported = set()
+            for r in raw_regions:
+                if isinstance(r, dict):
+                    if r.get("id"):
+                        supported.add(str(r["id"]).lower())
+                    for dc in r.get("datacenters") or []:
+                        supported.add(str(dc).lower())
+            if supported and region.lower() not in supported:
+                sorted_ids = sorted(list({str(r.get("id")) for r in raw_regions if isinstance(r, dict) and r.get("id")}))
+                raise typer.BadParameter(
+                    f"Unsupported region '{region}'. Supported regions are: {', '.join(sorted_ids)}"
+                )
+    except typer.BadParameter:
+        raise
+    except Exception:
+        # Ignore network/mock failures during pre-validation; backend API will enforce
+        pass
+
+
+def _render_regions_table(regions):
+    if not regions:
+        console.print("[yellow]No regions found.[/yellow]")
+        return
+
+    table = Table("Region ID", "Name", "Datacenters", "Location")
+    for r in regions:
+        table.add_row(
+            str(r.get("id") or "N/A"),
+            str(r.get("name") or r.get("label") or "N/A"),
+            ", ".join(r.get("datacenters") or []) or "-",
+            str(r.get("location") or r.get("continent") or "-"),
+        )
+    console.print(table)
+
+
+def regions_command(
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="Filter regions by status ('active' or 'reservable')"),
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """List available compute regions."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        regions = client.get_available_regions(status=status)
+        print_output(regions, table_render_func=_render_regions_table)
+    except Exception as e:
+        handle_error(e, "Error listing regions")

{nodepick_cli-0.1.3 → nodepick_cli-0.1.4}/src/nodepick_cli/main.py

@@ -1,6 +1,8 @@
 import typer
 from rich.console import Console
-from .commands.node import app as node_app, node_find
+from .commands.node import app as node_app
+from .commands.compute import compute_command
+from .commands.regions import regions_command
 from .commands.network import app as network_app
 from .commands.ssh import app as ssh_app
 from .commands.ai import app as ai_app
@@ -58,11 +60,16 @@ app.add_typer(network_app, name="network")
 app.add_typer(ssh_app, name="ssh")
 app.add_typer(ai_app, name="ai")
 
-# Shortcut: np find
+# Commands: np compute, np regions
 app.command(
-    "find",
+    "compute",
     help="Find and discover available compute hosts matching specific hardware and pricing criteria.",
-)(node_find)
+)(compute_command)
+
+app.command(
+    "regions",
+    help="List available compute regions.",
+)(regions_command)
 
 if __name__ == "__main__":
     app()

{nodepick_cli-0.1.3 → nodepick_cli-0.1.4}/test_cli.py

@@ -32,6 +32,17 @@ class TestCliCommands(unittest.TestCase):
         self.assertEqual(result.exit_code, 0)
         self.assertIn("Manage Compute Nodes", result.output)
 
+        res_create = runner.invoke(app, ["node", "create", "--help"], env={"COLUMNS": "160"})
+        self.assertEqual(res_create.exit_code, 0)
+        self.assertIn("-s", res_create.output)
+        self.assertIn("--storage", res_create.output)
+        self.assertIn("Target region or datacenter (e.g. us-west-1, fmt1)", res_create.output)
+        self.assertIn("Number of vCPUs (min: 1) [default: 1]", res_create.output)
+        self.assertIn("Memory size in GB (min: 1) [default: 1]", res_create.output)
+        self.assertIn("Disk storage in GB (min: 10) [default: 10]", res_create.output)
+        self.assertNotIn("[x>=1]", res_create.output)
+        self.assertNotIn("[x>=10]", res_create.output)
+
     def test_node_get_help(self):
         result = runner.invoke(app, ["node", "get", "--help"])
         self.assertEqual(result.exit_code, 0)
@@ -338,8 +349,9 @@ class TestCliCommands(unittest.TestCase):
             self.assertIn("vpc-1", result.output)
             self.assertIn("prod-net", result.output)
             self.assertIn("10.0.1.0/24", result.output)
-            # Verify AZ column is not present
+            # Verify AZ and NAT columns are not present
             self.assertNotIn(" AZ ", result.output)
+            self.assertNotIn(" NAT ", result.output)
 
     def test_network_create(self):
         from unittest.mock import patch, MagicMock
@@ -354,7 +366,15 @@ class TestCliCommands(unittest.TestCase):
                 name="devnet",
                 region="fmt1",
                 description=None,
-                enable_outbound_nat=True,
+            )
+
+            # Verify VPC name with dashes (e.g. dev-vpc)
+            result_dash = runner.invoke(app, ["network", "create", "dev-vpc", "--region", "fmt1"])
+            self.assertEqual(result_dash.exit_code, 0)
+            mock_client.vpc_create.assert_called_with(
+                name="dev-vpc",
+                region="fmt1",
+                description=None,
             )
 
             # Verify --az option is no longer supported
@@ -362,6 +382,11 @@ class TestCliCommands(unittest.TestCase):
             self.assertNotEqual(result_az.exit_code, 0)
             self.assertIn("No such option: --az", result_az.output)
 
+            # Verify --nat option is no longer supported
+            result_nat = runner.invoke(app, ["network", "create", "devnet", "--region", "fmt1", "--nat"])
+            self.assertNotEqual(result_nat.exit_code, 0)
+            self.assertIn("No such option: --nat", result_nat.output)
+
     def test_network_get(self):
         from unittest.mock import patch, MagicMock
         mock_client = MagicMock()
@@ -387,12 +412,13 @@ class TestCliCommands(unittest.TestCase):
             self.assertEqual(result.exit_code, 0)
             self.assertIn("VPC network vpc-123 deleted", result.output)
 
-    def test_node_find_command(self):
+    def test_compute_command(self):
         from unittest.mock import patch, MagicMock
         mock_client = MagicMock()
         mock_client.find_compute.return_value = [
             {
                 "id": "host-1",
+                "status": "active",
                 "region": "fmt1",
                 "datacenter": "facility-1",
                 "memory_gb": 32,
@@ -406,38 +432,66 @@ class TestCliCommands(unittest.TestCase):
                     "monthly": "10.95",
                     "currency": "USD"
                 }
+            },
+            {
+                "id": "host-2",
+                "status": "reservable",
+                "region": "fmt1",
+                "datacenter": "facility-2",
+                "memory_gb": 64,
+                "storage_gb": 1000,
+                "cpu": {"cores": 32},
+                "requested_cpu": 2,
+                "requested_memory_gb": 4,
+                "requested_storage_gb": 50,
+                "pricing": {
+                    "hourly": "0.0200",
+                    "monthly": "14.60",
+                    "currency": "USD"
+                }
             }
         ]
-        with patch("nodepick_cli.commands.node.get_client", return_value=mock_client):
-            # Test 'np node find'
-            result = runner.invoke(app, ["node", "find", "-c", "2", "-m", "4", "-s", "50", "-p", "50"], env={"COLUMNS": "160"})
+        with patch("nodepick_cli.commands.compute.get_client", return_value=mock_client):
+            # Test 'np compute'
+            result = runner.invoke(app, ["compute", "-c", "2", "-m", "4", "-s", "50", "-p", "50"], env={"COLUMNS": "160"})
             self.assertEqual(result.exit_code, 0)
             # Verify required columns are present in output:
-            # host id, region, datacenter, ram, disk, cpu, price-per-hour, price-per-month
+            # host id (full), status, region, datacenter, consolidated specs (RAM/Disk/CPU), price-per-hour, price-per-month
             self.assertIn("Host ID", result.output)
+            self.assertIn("Status", result.output)
             self.assertIn("Region", result.output)
             self.assertIn("Datacenter", result.output)
-            self.assertIn("RAM (GB)", result.output)
-            self.assertIn("Disk (GB)", result.output)
-            self.assertIn("CPU (Cores)", result.output)
+            self.assertIn("RAM/Disk/CPU", result.output)
             self.assertIn("Price/hr ($)", result.output)
             self.assertIn("Price/mo ($)", result.output)
             self.assertIn("host-1", result.output)
+            self.assertIn("host-2", result.output)
+            self.assertIn("active", result.output)
+            self.assertIn("reservable", result.output)
             self.assertIn("fmt1", result.output)
             self.assertIn("facility-1", result.output)
             self.assertIn("$0.0150", result.output)
             self.assertIn("$10.95", result.output)
 
-            # Verify requested values (4, 50, 2) are displayed, NOT host capacity (32, 500, 16)
-            self.assertIn("4", result.output)
-            self.assertIn("50", result.output)
-            self.assertIn("2", result.output)
+            # Verify consolidated requested specs "4/50/2" (4 GB RAM, 50 GB Disk, 2 CPU cores)
+            self.assertIn("4/50/2", result.output)
 
-            # Test shortcut 'np find'
-            res_shortcut = runner.invoke(app, ["find", "-c", "2", "-m", "4", "-s", "50"], env={"COLUMNS": "160"})
-            self.assertEqual(res_shortcut.exit_code, 0)
-            self.assertIn("Host ID", res_shortcut.output)
-            self.assertIn("$0.0150", res_shortcut.output)
+            # Test filter with --status reservable
+            mock_client.find_compute.reset_mock()
+            res_reservable = runner.invoke(app, ["compute", "--status", "reservable"], env={"COLUMNS": "160"})
+            self.assertEqual(res_reservable.exit_code, 0)
+            mock_client.find_compute.assert_called_once()
+            self.assertEqual(mock_client.find_compute.call_args[1]["status"], "reservable")
+
+            # Verify 'np find' is no longer supported (renamed to 'np compute')
+            res_find = runner.invoke(app, ["find"])
+            self.assertNotEqual(res_find.exit_code, 0)
+            self.assertIn("No such command 'find'", res_find.output)
+
+            # Verify 'np node find' is no longer supported
+            res_node_find = runner.invoke(app, ["node", "find"])
+            self.assertNotEqual(res_node_find.exit_code, 0)
+            self.assertIn("No such command 'find'", res_node_find.output)
 
     def test_node_create_with_vpc_and_no_network_flag(self):
         from unittest.mock import patch, MagicMock
@@ -452,8 +506,10 @@ class TestCliCommands(unittest.TestCase):
                 memory=1,
                 cpu=1,
                 display_name="my-node",
-                storage_gb=None,
+                storage_gb=10,
                 vpc="devnet",
+                region=None,
+                host_id=None,
             )
 
             # 2. Create with custom --memory 2
@@ -464,25 +520,194 @@ class TestCliCommands(unittest.TestCase):
                 memory=2,
                 cpu=1,
                 display_name="my-node-2",
-                storage_gb=None,
+                storage_gb=10,
                 vpc=None,
+                region=None,
+                host_id=None,
             )
 
-            # 3. Verify --network option no longer exists
+            # 3. Create with --region fmt1 and -r us-west-1
+            mock_client.node_create.reset_mock()
+            result_reg = runner.invoke(app, ["node", "create", "--name", "my-node-reg", "--region", "fmt1"])
+            self.assertEqual(result_reg.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="my-node-reg",
+                storage_gb=10,
+                vpc=None,
+                region="fmt1",
+                host_id=None,
+            )
+
+            mock_client.node_create.reset_mock()
+            result_reg_short = runner.invoke(app, ["node", "create", "--name", "my-node-reg2", "-r", "us-west-1"])
+            self.assertEqual(result_reg_short.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="my-node-reg2",
+                storage_gb=10,
+                vpc=None,
+                region="us-west-1",
+                host_id=None,
+            )
+
+            # 4. Create with --storage and short -s
+            mock_client.node_create.reset_mock()
+            result_storage = runner.invoke(app, ["node", "create", "--name", "my-node-stor", "--storage", "25"])
+            self.assertEqual(result_storage.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="my-node-stor",
+                storage_gb=25,
+                vpc=None,
+                region=None,
+                host_id=None,
+            )
+
+            mock_client.node_create.reset_mock()
+            result_storage_short = runner.invoke(app, ["node", "create", "--name", "my-node-stor2", "-s", "30"])
+            self.assertEqual(result_storage_short.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="my-node-stor2",
+                storage_gb=30,
+                vpc=None,
+                region=None,
+                host_id=None,
+            )
+
+            mock_client.node_create.reset_mock()
+            result_combo = runner.invoke(app, ["node", "create", "-n", "combo-node", "-c", "2", "-m", "4", "-s", "50", "-r", "us-west-1"])
+            self.assertEqual(result_combo.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=4,
+                cpu=2,
+                display_name="combo-node",
+                storage_gb=50,
+                vpc=None,
+                region="us-west-1",
+                host_id=None,
+            )
+
+            # 5. Verify --network option no longer exists
             result_invalid = runner.invoke(app, ["node", "create", "--network", "public"])
             self.assertNotEqual(result_invalid.exit_code, 0)
             self.assertIn("No such option: --network", result_invalid.output)
 
-            # 4. Verify min constraints in CLI (cpu >= 1, memory >= 1 GB, storage >= 10 GB)
+            # 6. Verify min constraints in CLI (cpu >= 1, memory >= 1 GB, storage >= 10 GB)
             res_bad_cpu = runner.invoke(app, ["node", "create", "--cpu", "0"])
             self.assertNotEqual(res_bad_cpu.exit_code, 0)
 
+            res_bad_storage_short = runner.invoke(app, ["node", "create", "-s", "5"])
+            self.assertNotEqual(res_bad_storage_short.exit_code, 0)
+
+    def test_node_create_with_specific_host_id(self):
+        from unittest.mock import patch, MagicMock
+        mock_client = MagicMock()
+        mock_client.node_create.return_value = {"vm_uuid": "node-pinned-123"}
+        with patch("nodepick_cli.commands.node.get_client", return_value=mock_client):
+            # 1. Using --host
+            result = runner.invoke(app, ["node", "create", "--name", "pinned-node", "--host", "39e77410-ddf4-44aa-bbcc-1234567890ab"])
+            self.assertEqual(result.exit_code, 0)
+            self.assertIn("Node created successfully", result.output)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="pinned-node",
+                storage_gb=10,
+                vpc=None,
+                region=None,
+                host_id="39e77410-ddf4-44aa-bbcc-1234567890ab",
+            )
+
+            # 2. Using --host-id
+            mock_client.node_create.reset_mock()
+            result_host_id = runner.invoke(app, ["node", "create", "--name", "pinned-2", "--host-id", "custom-host-id"])
+            self.assertEqual(result_host_id.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="pinned-2",
+                storage_gb=10,
+                vpc=None,
+                region=None,
+                host_id="custom-host-id",
+            )
+
+            # 3. Using --system-id
+            mock_client.node_create.reset_mock()
+            result_sys_id = runner.invoke(app, ["node", "create", "--name", "pinned-3", "--system-id", "sys-host-id"])
+            self.assertEqual(result_sys_id.exit_code, 0)
+            mock_client.node_create.assert_called_once_with(
+                memory=1,
+                cpu=1,
+                display_name="pinned-3",
+                storage_gb=10,
+                vpc=None,
+                region=None,
+                host_id="sys-host-id",
+            )
+
             res_bad_mem = runner.invoke(app, ["node", "create", "--memory", "0"])
             self.assertNotEqual(res_bad_mem.exit_code, 0)
 
             res_bad_storage = runner.invoke(app, ["node", "create", "--storage", "5"])
             self.assertNotEqual(res_bad_storage.exit_code, 0)
 
+    def test_node_create_unsupported_region(self):
+        from unittest.mock import patch, MagicMock
+        mock_client = MagicMock()
+        mock_client.get_available_regions.return_value = [
+            {"id": "us-west-1", "name": "US West", "datacenters": ["fmt1"], "status": "active"},
+            {"id": "us-east-1", "name": "US East", "datacenters": ["iad1"], "status": "active"},
+        ]
+        with patch("nodepick_cli.commands.node.get_client", return_value=mock_client):
+            result = runner.invoke(app, ["node", "create", "--region", "unsupported-region"])
+            self.assertNotEqual(result.exit_code, 0)
+            self.assertIn("Unsupported region 'unsupported-region'", result.output)
+            self.assertIn("Supported regions", result.output)
+            self.assertIn("us-east-1", result.output)
+
+    def test_network_create_unsupported_region(self):
+        from unittest.mock import patch, MagicMock
+        mock_client = MagicMock()
+        mock_client.get_available_regions.return_value = [
+            {"id": "us-west-1", "name": "US West", "datacenters": ["fmt1"], "status": "active"},
+        ]
+        with patch("nodepick_cli.commands.network.get_client", return_value=mock_client):
+            result = runner.invoke(app, ["network", "create", "test-vpc", "--region", "unsupported-region"])
+            self.assertNotEqual(result.exit_code, 0)
+            self.assertIn("Unsupported region 'unsupported-region'", result.output)
+
+    def test_top_level_regions_command(self):
+        from unittest.mock import patch, MagicMock
+        mock_client = MagicMock()
+        mock_client.get_available_regions.return_value = [
+            {
+                "id": "us-west-1",
+                "name": "US West (Silicon Valley)",
+                "datacenters": ["fmt1"],
+                "location": "Silicon Valley",
+            }
+        ]
+        with patch("nodepick_cli.commands.regions.get_client", return_value=mock_client):
+            # Test top-level np regions
+            res = runner.invoke(app, ["regions"])
+            self.assertEqual(res.exit_code, 0)
+            self.assertIn("us-west-1", res.output)
+            self.assertIn("fmt1", res.output)
+            self.assertIn("Silicon Valley", res.output)
+            self.assertNotIn("Status", res.output)
+
+        # Verify np node regions is no longer a command
+        res_node_regions = runner.invoke(app, ["node", "regions"])
+        self.assertNotEqual(res_node_regions.exit_code, 0)
+        self.assertIn("No such command", res_node_regions.output)
+
     def test_node_attach_and_detach_ip_ipv4(self):
         from unittest.mock import patch, MagicMock
         mock_client = MagicMock()

{nodepick_cli-0.1.3 → nodepick_cli-0.1.4}/uv.lock

@@ -514,7 +514,7 @@ wheels = [
 
 [[package]]
 name = "nodepick"
-version = "0.1.2"
+version = "0.1.4"
 source = { editable = "../sdk/python" }
 dependencies = [
     { name = "httpx" },
@@ -529,7 +529,7 @@ requires-dist = [
 
 [[package]]
 name = "nodepick-cli"
-version = "0.1.2"
+version = "0.1.4"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

nodepick_cli-0.1.3/CHANGELOG.md

@@ -1,17 +0,0 @@
-# CHANGELOG.md
-
-## [Unreleased]
-
-### Changed
-- Changed authentication command from `np auth save` to `np auth configure`.
-
-### Added
-- Added `np --version` (`-v`) flag.
-- Added `np ai mcp configure <agent> [nodes...]` command to configure MCP servers on AI agents (such as Antigravity) over HTTP Stream with self-signed certificate verification bypassed.
-
-## [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`.
-