nodepick-cli 0.1.1__py3-none-any.whl

nodepick_cli/__init__.py

@@ -0,0 +1,11 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("nodepick-cli")
+except Exception:
+    __version__ = "0.1.0"
+
+from .main import app
+
+__all__ = ["app", "__version__"]
+

nodepick_cli/auth/__init__.py

@@ -0,0 +1,3 @@
+from .login import app
+
+__all__ = ["app"]

nodepick_cli/auth/login.py

@@ -0,0 +1,112 @@
+import os
+import typer
+from typing import Optional
+from rich.console import Console
+import keyring
+import nodepick
+from ..core.config import get_api_key, get_base_url, load_config, save_config
+from ..core.exceptions import handle_error
+
+KEYRING_SERVICE = "nodepick-cli"
+KEYRING_API_KEY = "api_key"
+
+app = typer.Typer(name="auth", help="Manage API key authentication.")
+console = Console()
+
+
+def _get_api_key_with_source() -> tuple:
+    """Return (api_key, source) where source is a human-readable label."""
+    if os.getenv("NODEPICK_API_KEY"):
+        return os.getenv("NODEPICK_API_KEY"), "env var NODEPICK_API_KEY"
+    try:
+        kr_key = keyring.get_password(KEYRING_SERVICE, KEYRING_API_KEY)
+        if kr_key:
+            return kr_key, "OS keyring"
+    except Exception:
+        pass
+    return None, None
+
+
+def _keyring_get(key_name: str) -> Optional[str]:
+    try:
+        return keyring.get_password(KEYRING_SERVICE, key_name) or None
+    except Exception:
+        return None
+
+
+def _keyring_set(key_name: str, value: str) -> None:
+    keyring.set_password(KEYRING_SERVICE, key_name, value)
+
+
+def _keyring_delete(key_name: str) -> None:
+    try:
+        keyring.delete_password(KEYRING_SERVICE, key_name)
+    except Exception:
+        pass  # already absent
+
+
+@app.command("clear")
+def auth_clear():
+    """Remove the API key from the OS keyring."""
+    try:
+        _keyring_delete(KEYRING_API_KEY)
+        console.print("[bold green]API key cleared from OS keyring.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Failed to clear credentials")
+
+
+@app.command("configure")
+@app.command("save")
+def auth_configure(
+    api_key: Optional[str] = typer.Option(
+        None, "--api-key", "-k", help="Nodepick API key / bearer token"
+    ),
+    base_url: Optional[str] = typer.Option(
+        None, "--base-url", "-u", help="API base URL (default: https://api.nodepick.ai)"
+    ),
+):
+    """Configure API key (and optional base URL) securely in the OS keyring."""
+    try:
+        if not api_key:
+            api_key = typer.prompt("Nodepick API Key", hide_input=True)
+
+        resolved_url = (base_url or get_base_url()).rstrip("/")
+
+        _keyring_set(KEYRING_API_KEY, api_key)
+        # Save base_url to config file; only the API key lives in the keyring.
+        save_config({"base_url": resolved_url})
+
+        console.print(
+            "[bold green]Credentials configured.[/bold green] "
+            f"API key stored in OS keyring. Base URL: {resolved_url} (saved to config)"
+        )
+    except Exception as e:
+        handle_error(e, "Failed to configure credentials")
+
+
+@app.command("test")
+def auth_test():
+    """Test API access using the stored API key."""
+    key, source = _get_api_key_with_source()
+    url = get_base_url()
+    if not key:
+        console.print(
+            "[yellow]No API key found.[/yellow] "
+            "Run 'np auth configure' or set NODEPICK_API_KEY."
+        )
+        raise typer.Exit(1)
+
+    try:
+        client = nodepick.NodePickClient(api_key=key, base_url=url)
+        user_info = client.get_me()
+        user = user_info.get("user", {})
+        org  = user_info.get("org", {})
+        console.print(
+            f"[bold green]API access OK.[/bold green] "
+            f"User: [bold]{user.get('email', 'unknown')}[/bold] | "
+            f"Org: {org.get('name', 'N/A')} | "
+            f"URL: {url} | "
+            f"Key source: [dim]{source}[/dim]"
+        )
+    except Exception as e:
+        handle_error(e, "API access test failed")

nodepick_cli/commands/__init__.py

@@ -0,0 +1,8 @@
+from .node import app as node_app
+from .ssh import app as ssh_app
+from .ai import app as ai_app
+
+__all__ = ["node_app", "ssh_app", "ai_app"]
+
+
+

nodepick_cli/commands/ai.py

@@ -0,0 +1,168 @@
+import json
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+import typer
+from rich.console import Console
+from ..commands.node import get_client
+from ..core.exceptions import handle_error
+
+app = typer.Typer(name="ai", help="[BETA] Manage AI integrations and agent configurations.")
+mcp_app = typer.Typer(name="mcp", help="Manage Model Context Protocol (MCP) integrations.")
+app.add_typer(mcp_app, name="mcp")
+
+console = Console()
+
+SUPPORTED_AGENTS = ["antigravity"]
+
+
+def _update_json_mcp_servers(file_path: Path, servers: Dict[str, Any]) -> None:
+    """Safely merge MCP servers into a JSON configuration file."""
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    data = {}
+    if file_path.exists():
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+                if content:
+                    data = json.loads(content)
+        except Exception:
+            data = {}
+
+    if not isinstance(data, dict):
+        data = {}
+
+    if "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+        data["mcpServers"] = {}
+
+    data["mcpServers"].update(servers)
+
+    with open(file_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def configure_antigravity_mcp(servers: Dict[str, Any]) -> List[Path]:
+    """Configure 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",
+    ]
+    updated_files = []
+    for path in target_files:
+        try:
+            _update_json_mcp_servers(path, servers)
+            updated_files.append(path)
+        except Exception as e:
+            console.print(f"[dim yellow]Warning: Failed writing to {path}: {e}[/dim yellow]")
+    return updated_files
+
+
+@mcp_app.command("configure")
+def mcp_configure(
+    agent: str = typer.Argument(
+        ...,
+        help=f"AI Agent to configure (supported: {', '.join(SUPPORTED_AGENTS)})",
+    ),
+    nodes: Optional[List[str]] = typer.Argument(
+        None, help="Node IDs or display names to configure MCP for (if omitted, configures all nodes)"
+    ),
+):
+    """Configure 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(
+            f"[bold red]Unsupported agent '{agent}'.[/bold red] Supported agents: [bold]"
+            + ", ".join(SUPPORTED_AGENTS)
+            + "[/bold]"
+        )
+        raise typer.Exit(1)
+
+    client = get_client()
+
+    try:
+        if nodes:
+            target_nodes = list(nodes)
+        else:
+            all_nodes = client.node_list()
+            if not all_nodes:
+                console.print("[yellow]No compute nodes found to configure.[/yellow]")
+                return
+            target_nodes = [
+                node.get("vm_uuid") or node.get("id") or node.get("display_name")
+                for node in all_nodes
+            ]
+            target_nodes = [n for n in target_nodes if n]
+
+        servers_to_add: Dict[str, Any] = {}
+
+        for node_identifier in target_nodes:
+            try:
+                details = client.node_get_details(node_identifier)
+            except Exception as e:
+                handle_error(e, f"Failed to get details for node '{node_identifier}'")
+                continue
+
+            connect = details.get("connect") or {}
+            if not connect and "vm" in details and isinstance(details["vm"], dict):
+                connect = details["vm"].get("connect") or {}
+
+            mcp_url = connect.get("mcpUrl") or details.get("mcpUrl") or details.get("nmcpUrl")
+            mcp_api_key = connect.get("mcpApiKey") or details.get("mcpApiKey")
+
+            node_name = (
+                details.get("display_name")
+                or details.get("displayName")
+                or details.get("name")
+                or details.get("vm_uuid")
+                or details.get("id")
+                or node_identifier
+            )
+
+            if not mcp_url:
+                console.print(
+                    f"[yellow]Node '{node_name}' does not have an active MCP endpoint ('mcpUrl'). Skipping.[/yellow]"
+                )
+                continue
+
+            server_config: Dict[str, Any] = {
+                "serverUrl": mcp_url,
+                "url": mcp_url,
+                "type": "http",
+                "transport": "http",
+                "protocol": "streamable_http",
+                "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}",
+                    "X-API-Key": mcp_api_key,
+                }
+
+            servers_to_add[node_name] = server_config
+
+        if not servers_to_add:
+            console.print("[yellow]No active MCP servers found for the specified node(s).[/yellow]")
+            return
+
+        if agent_clean in ("antigravity", "agy", "gemini"):
+            configure_antigravity_mcp(servers_to_add)
+
+        for s_name, s_cfg in servers_to_add.items():
+            console.print(
+                f"[bold green]✔[/bold green] Configured MCP server '[bold]{s_name}[/bold]' -> [cyan]{s_cfg['url']}[/cyan]"
+            )
+
+        console.print(
+            f"[bold green]Successfully configured {len(servers_to_add)} MCP server(s) for {agent_clean}.[/bold green]"
+        )
+
+    except Exception as e:
+        handle_error(e, "Error configuring MCP servers")

nodepick_cli/commands/node.py

@@ -0,0 +1,235 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table, Column
+import nodepick
+from ..core.config import get_api_key, get_base_url
+from ..core.exceptions import handle_error
+from ..core.formatters import OutputFormat, set_output_format, get_output_format, print_output
+
+
+
+app = typer.Typer(name="node", help="Manage Compute Nodes.")
+console = Console()
+
+from click.core import ParameterSource
+
+@app.callback(invoke_without_command=True)
+def node_callback():
+    pass
+
+
+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 _extract_ssh_command(details) -> str:
+    ssh = ((details or {}).get("connect") or {}).get("ssh") or {}
+    cmd = ssh.get("command")
+    if cmd:
+        return cmd
+    host = ssh.get("sshHost")
+    port = ssh.get("sshPort")
+    username = ssh.get("username", "nodepick")
+    if host and port:
+        return f"ssh {username}@{host} -p {port}"
+    return "N/A"
+
+def _get_ssh_command(client, node) -> str:
+    node_id = node.get("vm_uuid") or node.get("vmUuid") or node.get("vmId") or node.get("id")
+    try:
+        details = client.node_get_details(node_id)
+        return _extract_ssh_command(details)
+    except Exception:
+        return "N/A"
+
+def _render_nodes_table(nodes, client=None):
+    if not nodes:
+        console.print("[yellow]No nodes found.[/yellow]")
+        return
+
+    table = Table("ID", "Name", "State", Column("SSH Connect", no_wrap=True))
+    for node in nodes:
+        node_id = node.get("vm_uuid") or node.get("vmUuid") or node.get("vmId") or node.get("id", "N/A")
+        name = node.get("display_name") or node.get("displayName") or "N/A"
+        vmm = node.get("vmm", {}) if isinstance(node.get("vmm"), dict) else {}
+        state = node.get("state") or vmm.get("state") or node.get("status", "unknown")
+        ssh_cmd = _get_ssh_command(client, node) if client else "N/A"
+        table.add_row(
+            str(node_id),
+            str(name),
+            str(state),
+            ssh_cmd,
+        )
+    console.print(table)
+
+@app.command("boot")
+def node_boot(
+    node_id: str = typer.Argument(..., help="Node ID or display name to boot"),
+):
+    """Boot a node."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Booting node {node_id}...[/cyan]")
+        res = client.node_boot(node_id)
+        console.print(f"[bold green]Node {node_id} boot request sent.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error booting node")
+
+
+@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)"),
+):
+    """Deploy a new compute node."""
+    client = get_client()
+    memory_bytes = memory_mb * 1024 * 1024
+    try:
+        console.print("[cyan]Creating node...[/cyan]")
+        node = client.node_create(
+            memory=memory_bytes,
+            cpu=cpu,
+            network_type=network_type,
+            display_name=display_name,
+            storage_gb=storage_gb,
+        )
+        node_id = node.get("vm_uuid")
+        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("delete")
+def node_delete(
+    node_id: str = typer.Argument(..., help="Node ID or display name to delete"),
+):
+    """Delete a compute node."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Deleting node {node_id}...[/cyan]")
+        res = client.node_delete(node_id)
+        console.print(f"[bold green]Node {node_id} deleted.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error deleting node")
+
+
+def _render_node_details_table(node):
+    if not node:
+        console.print("[yellow]No node details found.[/yellow]")
+        return
+
+    table = Table("Field", "Value")
+    fields = [
+        ("ID", node.get("vm_uuid") or node.get("id")),
+        ("Org ID", node.get("orgId") or node.get("org_id")),
+        ("User ID", node.get("created_by_id")),
+        ("Server ID", node.get("serverId") or node.get("server_id")),
+        ("Name", node.get("display_name")),
+        ("State", node.get("state")),
+        ("Status", node.get("status")),
+        ("SSH Connect", _extract_ssh_command(node)),
+        ("CPU Cores", node.get("cpu")),
+        (
+            "Memory (MB)",
+            round(node.get("memory_bytes") / (1024 * 1024))
+            if node.get("memory_bytes") is not None
+            else node.get("memory_mb"),
+        ),
+        (
+            "Storage (GB)",
+            round(node.get("storage_bytes") / (1024 * 1024 * 1024))
+            if node.get("storage_bytes") is not None
+            else node.get("storage_gb"),
+        ),
+        ("Region", node.get("region")),
+    ]
+    for field, value in fields:
+        if value is not None:
+            table.add_row(field, str(value))
+    console.print(table)
+
+
+@app.command("get")
+def node_get(
+    node_id: str = typer.Argument(..., help="Node ID or display name"),
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """Get details of a specific node."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        details = client.node_get_details(node_id)
+        print_output(details, table_render_func=_render_node_details_table)
+    except Exception as e:
+        handle_error(e, "Error getting node details")
+
+
+@app.command("list")
+def node_list(
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """List all compute nodes."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        nodes = client.node_list()
+        print_output(nodes, table_render_func=lambda data: _render_nodes_table(data, client))
+    except Exception as e:
+        handle_error(e, "Error listing nodes")
+
+
+@app.command("reboot")
+def node_reboot(
+    node_id: str = typer.Argument(..., help="Node ID or display name to reboot"),
+):
+    """Reboot a node."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Rebooting node {node_id}...[/cyan]")
+        res = client.node_reboot(node_id)
+        console.print(f"[bold green]Node {node_id} reboot request sent.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error rebooting node")
+
+
+@app.command("shutdown")
+def node_shutdown(
+    node_id: str = typer.Argument(..., help="Node ID or display name to shut down"),
+):
+    """Gracefully shut down a node."""
+    client = get_client()
+    try:
+        console.print(f"[cyan]Shutting down node {node_id}...[/cyan]")
+        res = client.node_shutdown(node_id)
+        console.print(f"[bold green]Node {node_id} shutdown request sent.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error shutting down node")
+
+
+
+
+
+
+
+

nodepick_cli/commands/ssh.py

@@ -0,0 +1,102 @@
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+import nodepick
+from ..core.config import get_api_key, get_base_url
+from ..core.exceptions import handle_error
+from ..core.formatters import OutputFormat, set_output_format, print_output
+
+
+app = typer.Typer(name="ssh", help="Manage developer SSH public keys.")
+console = Console()
+
+
+from click.core import ParameterSource
+
+@app.callback(invoke_without_command=True)
+def ssh_callback():
+    pass
+
+
+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 _render_ssh_keys_table(keys):
+    if not keys:
+        console.print("[yellow]No SSH keys found.[/yellow]")
+        return
+
+    table = Table("ID", "Name", "Fingerprint", "Created At")
+    for key in keys:
+        table.add_row(
+            str(key.get("id", "N/A")),
+            str(key.get("name", "N/A")),
+            str(key.get("fingerprint", "N/A")),
+            str(key.get("created_at", "N/A")),
+        )
+    console.print(table)
+
+
+@app.command("add")
+def add_ssh_key(
+    name: str = typer.Option(..., "--name", "-n", help="Friendly name for the SSH key"),
+    key_file: Optional[str] = typer.Option(None, "--file", "-f", help="Path to SSH public key file (e.g. ~/.ssh/id_ed25519.pub)"),
+    public_key: Optional[str] = typer.Option(None, "--key", help="Raw SSH public key string"),
+):
+    """Add an SSH public key for automatic injection into new compute nodes."""
+    client = get_client()
+    try:
+        ssh_str = public_key
+        if not ssh_str and key_file:
+            with open(key_file, "r", encoding="utf-8") as f:
+                ssh_str = f.read().strip()
+        if not ssh_str:
+            raise ValueError("Must provide either --file or --key")
+
+        res = client.key_create(name=name, public_key=ssh_str)
+        key_id = res.get("key", {}).get("id", "N/A")
+        console.print(f"[bold green]SSH Key registered successfully![/bold green] Key ID: {key_id}")
+    except Exception as e:
+        handle_error(e, "Error adding SSH key")
+
+
+@app.command("delete")
+def delete_ssh_key(
+    key_id: str = typer.Argument(..., help="Key ID to delete"),
+):
+    """Delete an SSH key."""
+    client = get_client()
+    try:
+        res = client.key_delete(key_id)
+        console.print(f"[bold green]SSH key {key_id} deleted.[/bold green]")
+    except Exception as e:
+        handle_error(e, "Error deleting SSH key")
+
+
+@app.command("list")
+def list_ssh_keys(
+    format: OutputFormat = typer.Option(
+        OutputFormat.TABLE,
+        "--format", "-f",
+        help="Output format (table or json).",
+        case_sensitive=False,
+    ),
+):
+    """List all SSH keys for the current user."""
+    set_output_format(format)
+    client = get_client()
+    try:
+        keys = client.key_list()
+        print_output(keys, table_render_func=_render_ssh_keys_table)
+    except Exception as e:
+        handle_error(e, "Error listing SSH keys")

nodepick_cli/core/__init__.py

@@ -0,0 +1,16 @@
+from .config import load_config, save_config, get_api_key, get_base_url
+from .exceptions import handle_error
+from .formatters import OutputFormat, set_output_format, get_output_format, print_output
+
+__all__ = [
+    "load_config",
+    "save_config",
+    "get_api_key",
+    "get_base_url",
+    "handle_error",
+    "OutputFormat",
+    "set_output_format",
+    "get_output_format",
+    "print_output",
+]
+

nodepick_cli/core/config.py

@@ -0,0 +1,74 @@
+import os
+import json
+import keyring
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+CONFIG_DIR = Path.home() / ".nodepick"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+KEYRING_SERVICE = "nodepick-cli"
+KEYRING_API_KEY  = "api_key"
+
+_base_url_override: Optional[str] = None
+
+
+def set_base_url_override(url: Optional[str]) -> None:
+    global _base_url_override
+    _base_url_override = url.rstrip("/") if url else None
+
+
+def get_config_dir() -> Path:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if CONFIG_FILE.exists():
+        os.chmod(CONFIG_FILE, 0o600)
+    return CONFIG_DIR
+
+
+def load_config() -> Dict[str, Any]:
+    if not CONFIG_FILE.exists():
+        return {}
+    os.chmod(CONFIG_FILE, 0o600)
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def save_config(data: Dict[str, Any]) -> None:
+    get_config_dir()
+    config = load_config()
+    config.update(data)
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def _keyring_get(key_name: str) -> Optional[str]:
+    try:
+        return keyring.get_password(KEYRING_SERVICE, key_name) or None
+    except Exception:
+        return None
+
+
+def get_api_key(override: Optional[str] = None) -> Optional[str]:
+    if override:
+        return override
+    # 1. Environment variable
+    env_key = os.getenv("NODEPICK_API_KEY")
+    if env_key:
+        return env_key
+    # 2. OS keyring (set via 'np auth configure')
+    return _keyring_get(KEYRING_API_KEY)
+
+
+def get_base_url() -> str:
+    if _base_url_override:
+        return _base_url_override
+    # 1. Environment variable
+    env_url = os.getenv("NODEPICK_BASE_URL")
+    if env_url:
+        return env_url.rstrip("/")
+    # 2. Config file
+    return load_config().get("base_url", "https://api.nodepick.ai").rstrip("/")

nodepick_cli/core/exceptions.py

@@ -0,0 +1,73 @@
+import typer
+import httpx
+from rich.console import Console
+
+from .formatters import get_output_format, OutputFormat
+
+console = Console()
+
+def handle_error(e: Exception, message: str = "An error occurred"):
+    if get_output_format() == OutputFormat.JSON:
+        err_obj = {"code": "error", "message": message}
+        if isinstance(e, httpx.HTTPStatusError):
+            try:
+                body = e.response.json()
+                if isinstance(body, dict):
+                    inner_err = body.get("error")
+                    if isinstance(inner_err, dict):
+                        err_code = inner_err.get("code") or body.get("code") or "error"
+                        err_msg = inner_err.get("message") or str(e)
+                        err_obj = {"code": err_code, "message": err_msg}
+                        if "details" in inner_err:
+                            err_obj["details"] = inner_err["details"]
+                    else:
+                        err_code = body.get("code") or inner_err or "error"
+                        err_msg = body.get("message") or inner_err or str(e)
+                        err_obj = {"code": err_code, "message": err_msg}
+                    if "details" in body and "details" not in err_obj:
+                        err_obj["details"] = body["details"]
+                else:
+                    err_obj = {"code": f"http_{e.response.status_code}", "message": str(e)}
+            except Exception:
+                err_obj = {"code": f"http_{e.response.status_code}", "message": str(e)}
+        else:
+            err_obj = {"code": "error", "message": str(e)}
+        console.print_json(data=err_obj)
+        raise typer.Exit(code=1)
+
+    if isinstance(e, httpx.HTTPStatusError):
+        status = e.response.status_code
+        err_msg = ""
+        try:
+            body = e.response.json()
+            if isinstance(body, dict):
+                inner_err = body.get("error")
+                if isinstance(inner_err, dict):
+                    err_msg = inner_err.get("message") or ""
+                elif isinstance(inner_err, str):
+                    err_msg = inner_err
+                else:
+                    err_msg = body.get("message") or ""
+                details = body.get("details") or (inner_err.get("details") if isinstance(inner_err, dict) else None)
+                if details and isinstance(details, dict):
+                    field_errs = details.get("fieldErrors")
+                    if field_errs:
+                        errs = [f"{k}: {', '.join(v)}" for k, v in field_errs.items() if v]
+                        if errs:
+                            err_msg += f" ({'; '.join(errs)})"
+        except Exception:
+            pass
+
+        if err_msg:
+            console.print(f"[bold red]{message}:[/bold red] {err_msg}")
+        elif status == 404:
+            console.print("[bold red]Node not found[/bold red]")
+        elif status == 400:
+            console.print("[bold red]Invalid request[/bold red]")
+        elif status in (401, 403):
+            console.print("[bold red]Authentication failed.[/bold red] Check your API key or run 'np auth configure'.")
+        else:
+            console.print(f"[bold red]{message}:[/bold red] {e}")
+    else:
+        console.print(f"[bold red]{message}:[/bold red] {e}")
+    raise typer.Exit(code=1)

nodepick_cli/core/formatters.py

@@ -0,0 +1,39 @@
+import json
+from enum import Enum
+from typing import Any
+from rich.console import Console
+
+console = Console()
+
+import sys
+
+class OutputFormat(str, Enum):
+    TABLE = "table"
+    JSON = "json"
+
+_current_format: OutputFormat = OutputFormat.TABLE
+
+def set_output_format(fmt: OutputFormat) -> None:
+    global _current_format
+    _current_format = fmt
+
+def get_output_format() -> OutputFormat:
+    return _current_format
+
+def print_output(data: Any, table_render_func=None) -> None:
+    """Print data according to active output format setting."""
+    if _current_format == OutputFormat.JSON:
+        if isinstance(data, (dict, list)):
+            console.print_json(data=data)
+        else:
+            console.print_json(data={"result": data})
+    else:
+        if table_render_func:
+            table_render_func(data)
+        elif isinstance(data, (dict, list)):
+            console.print_json(data=data)
+        else:
+            console.print(data)
+
+
+

nodepick_cli/main.py

@@ -0,0 +1,62 @@
+import typer
+from rich.console import Console
+from .commands.node import app as node_app
+from .commands.ssh import app as ssh_app
+from .commands.ai import app as ai_app
+from .auth.login import app as auth_app
+from . import __version__
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"nodepick CLI version {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="np",
+    help="Nodepick CLI - Manage compute nodes, SSH keys, and authentication.",
+    add_completion=False,
+)
+console = Console()
+
+from click.core import ParameterSource
+
+import sys
+import logging
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug", "-d",
+        help="Enable DEBUG logging output.",
+    ),
+):
+    if debug:
+        logger = logging.getLogger("nodepick")
+        logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(logging.DEBUG)
+        formatter = logging.Formatter("[%(asctime)s] %(levelname)s [%(name)s]: %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+# Register command sub-groups
+app.add_typer(auth_app, name="auth")
+app.add_typer(node_app, name="node")
+app.add_typer(ssh_app, name="ssh")
+app.add_typer(ai_app, name="ai")
+
+if __name__ == "__main__":
+    app()
+
+

nodepick_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.5
+Name: nodepick-cli
+Version: 0.1.1
+Summary: CLI tool for nodepick.ai Node orchestration
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: keyring>=25.0.0
+Requires-Dist: nodepick
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# nodepick.ai CLI (`np`)
+
+`np` is a command-line interface tool built with Python for managing Compute nodes.
+
+## Installation
+
+### Recommended Method using Shell Installer (`curl`)
+
+```bash
+# Install using auto-detection (uv -> pipx -> pip)
+curl -sSL https://raw.githubusercontent.com/nodepick/developer/main/cli/install.sh | bash
+
+# Install latest from Git repo
+curl -sSL https://raw.githubusercontent.com/nodepick/developer/main/cli/install.sh | bash -s -- --mode git
+```
+
+### Recommended Method using (`uv`)
+
+Using [`uv`](https://github.com/astral-sh/uv) is the recommended way to install and manage the `np` CLI tool globally in an isolated environment:
+
+```bash
+# Install published package from PyPI
+uv tool install nodepick-cli
+
+# Or install from inside the cli directory:
+uv tool install -e . --with ../sdk/python
+
+# Or re-install
+uv tool install -e . --with ../sdk/python --reinstall
+```
+
+### `pip` Method
+
+Installing published package from PyPI:
+
+```bash
+pip install nodepick-cli
+```
+
+When installing from a local git repository, first install the local `nodepick` SDK dependency before installing `nodepick-cli`:
+
+```bash
+# Install from the "cli" folder using pip:
+pip install -e ../sdk/python .
+```
+
+
+## Usage
+
+[`nodepick.ai Documentation`](https://docs.nodepick.ai/cli-reference/overview)
+
+
+### Basic Usage
+
+```bash
+# List all compute nodes (table view with SSH connect command)
+np --version
+```
+
+### Authentication
+
+```bash
+# Configure API key (and optional base URL) securely in OS keyring
+np auth configure
+
+# Test API authentication status & organization details
+np auth test
+
+# Clear stored API key from OS keyring
+np auth clear
+```
+
+### SSH Key Management
+
+```bash
+# Register an SSH public key from a file
+np ssh add -n "MBA 2026" --file ~/.ssh/id_ed25519.pub
+
+# Register an SSH public key directly
+np ssh add -n "Desktop" --key "ssh-ed25519 AAAAC3... user@host"
+
+# List registered SSH keys
+np ssh list
+
+# Delete an SSH key by ID
+np ssh delete <key_id>
+```
+
+### Compute Nodes
+
+```bash
+# List all compute nodes
+np node list
+
+# Create a new compute node
+np node create --name "my-sandbox" --cpu 2 --memory 2048
+
+# Get details & connection info for a node
+np node get <node_id>
+
+# Reboot a node
+np node reboot <node_id>
+
+# Shutdown a node
+np node shutdown <node_id>
+
+# Delete a node
+np node delete <node_id>
+```
+
+### [BETA] AI & Model Context Protocol (MCP)
+
+```bash
+# Configure Antigravity to connect to a specific node MCP server over HTTP Stream
+np ai mcp configure antigravity dev
+
+# Configure Antigravity to connect to multiple nodes
+np ai mcp configure antigravity dev prod
+
+# Configure Antigravity for all available compute nodes
+np ai mcp configure antigravity
+```

nodepick_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+nodepick_cli/__init__.py,sha256=1cnCOG00e0gyBfYwxDDkgcWh-piFvqHQ81M9jroSRu8,195
+nodepick_cli/main.py,sha256=T6wMOIIcTQ62Ewo26m99em3jFxmzEm2wBKW_bNLUFSE,1528
+nodepick_cli/auth/__init__.py,sha256=yLUKsSlfLejT3XJ_DgD3ZUnH56XAzFC9Bb9d2tXBrcU,42
+nodepick_cli/auth/login.py,sha256=crBas_lttZ6gxdfOit9wwHeLUe98QO8NTBUfRmR98ow,3513
+nodepick_cli/commands/__init__.py,sha256=--4wgPWi_foJaolSSQQEMEyOg7BQTyu9MZ3QNv-8-W0,144
+nodepick_cli/commands/ai.py,sha256=vdq9auztildQQpYJ4LTMgb8eZiSR_Bgnp0joQFS9CEk,5949
+nodepick_cli/commands/node.py,sha256=5JwrQEhYVFQvcBh803lKRm0Wif0etP1Ri9N5RT7u4u0,7631
+nodepick_cli/commands/ssh.py,sha256=EySyuOfZ39iLyLGSp0z1saHdwXwfzFkm6GC2VvHxxjw,3214
+nodepick_cli/core/__init__.py,sha256=3XPBu1_JhCi7yNnsWj-1E3OMV1cW0B4zq5iGzjernl0,401
+nodepick_cli/core/config.py,sha256=3N_kjKNpPcy_dwceX7jecE7O7aBdqipv21XRxD5bw0A,1919
+nodepick_cli/core/exceptions.py,sha256=Wy14t-7TEpCWXuSOPWVX_TEJEBxOb6cUiUMycbc4fNQ,3312
+nodepick_cli/core/formatters.py,sha256=Y7Y6Ap7VOeBE4V5TXyGVcnyPVOB6_LW2lINtZ_lX2hQ,954
+nodepick_cli-0.1.1.dist-info/METADATA,sha256=JxBhuwrZgAUl70EL8BpukdZaLsF3NUsXUMkQQXqHHOs,3002
+nodepick_cli-0.1.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+nodepick_cli-0.1.1.dist-info/entry_points.txt,sha256=XFvdXTif7jy-Au3ufj_aDI4vzqL0Xy_PXaYav8_qcjM,45
+nodepick_cli-0.1.1.dist-info/RECORD,,

nodepick_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nodepick_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+np = nodepick_cli.main:app