hypercli-cli 1.0.9__tar.gz → 2026.3.10__tar.gz

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 1.0.9
+Version: 2026.3.10
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -9,7 +9,7 @@ Author-email: HyperCLI <support@hypercli.com>
 License: MIT
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: hypercli-sdk>=1.0.0
+Requires-Dist: hypercli-sdk>=2026.3.10
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=14.2.0
@@ -19,11 +19,11 @@ Provides-Extra: all
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'all'
 Requires-Dist: eth-account>=0.13.0; extra == 'all'
 Requires-Dist: faster-whisper>=1.1.0; extra == 'all'
-Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.3.10; extra == 'all'
 Requires-Dist: web3>=7.0.0; extra == 'all'
 Requires-Dist: x402[evm,httpx]>=2.0.0; extra == 'all'
 Provides-Extra: comfyui
-Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.3.10; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'
@@ -67,6 +67,11 @@ hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -g l4 -c "nvidia-smi"
 hyper jobs list
 hyper jobs logs <job_id>
 hyper jobs metrics <job_id>
+hyper jobs exec <job_id> "nvidia-smi"
+hyper jobs shell <job_id>
+
+# Dry-run launch validation
+hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -g l4 -c "nvidia-smi" --dry-run
 
 # Flows (recommended media path)
 hyper flow text-to-image "a cinematic portrait"
@@ -76,6 +81,8 @@ hyper flow text-to-image "a cinematic portrait" --x402
 hyper claw plans
 hyper claw subscribe 1aiu
 hyper claw config env
+hyper claw exec <agent_id> "ls -la"
+hyper claw shell <agent_id>
 ```
 
 ## Notes

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/README.md

@@ -28,6 +28,11 @@ hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -g l4 -c "nvidia-smi"
 hyper jobs list
 hyper jobs logs <job_id>
 hyper jobs metrics <job_id>
+hyper jobs exec <job_id> "nvidia-smi"
+hyper jobs shell <job_id>
+
+# Dry-run launch validation
+hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -g l4 -c "nvidia-smi" --dry-run
 
 # Flows (recommended media path)
 hyper flow text-to-image "a cinematic portrait"
@@ -37,6 +42,8 @@ hyper flow text-to-image "a cinematic portrait" --x402
 hyper claw plans
 hyper claw subscribe 1aiu
 hyper claw config env
+hyper claw exec <agent_id> "ls -la"
+hyper claw shell <agent_id>
 ```
 
 ## Notes

hypercli_cli-2026.3.10/hypercli_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "2026.3.10"

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/hypercli_cli/agents.py

@@ -107,6 +107,71 @@ def _get_pod_with_token(agent_id: str) -> ReefPod:
     return pod
 
 
+def _parse_env_vars(values: list[str] | None) -> dict | None:
+    """Parse repeated --env KEY=VALUE options into a dict."""
+    if not values:
+        return None
+    env: dict[str, str] = {}
+    for item in values:
+        if "=" not in item:
+            raise typer.BadParameter(f"Invalid --env '{item}'. Expected KEY=VALUE.")
+        key, value = item.split("=", 1)
+        if not key:
+            raise typer.BadParameter(f"Invalid --env '{item}'. KEY cannot be empty.")
+        env[key] = value
+    return env
+
+
+def _parse_ports(values: list[str] | None) -> list[dict] | None:
+    """Parse repeated --port PORT[:noauth] options."""
+    if not values:
+        return None
+    ports: list[dict] = []
+    for item in values:
+        if ":" in item:
+            port_text, suffix = item.split(":", 1)
+            if suffix != "noauth":
+                raise typer.BadParameter(
+                    f"Invalid --port '{item}'. Expected PORT or PORT:noauth."
+                )
+            auth = False
+        else:
+            port_text = item
+            auth = True
+
+        try:
+            port_num = int(port_text)
+        except ValueError as e:
+            raise typer.BadParameter(
+                f"Invalid --port '{item}'. PORT must be an integer."
+            ) from e
+
+        if port_num < 1 or port_num > 65535:
+            raise typer.BadParameter(
+                f"Invalid --port '{item}'. PORT must be between 1 and 65535."
+            )
+
+        ports.append({"port": port_num, "auth": auth})
+    return ports
+
+
+def _port_url(pod: ReefPod, port: dict) -> str:
+    if port.get("url"):
+        return str(port["url"])
+    hostname = pod.hostname or ""
+    prefix = port.get("prefix")
+    if hostname and prefix:
+        return f"https://{prefix}-{hostname}"
+    if hostname:
+        return f"https://{hostname}"
+    return ""
+
+
+def _port_summary(port: dict) -> str:
+    auth_text = "auth" if port.get("auth", True) else "noauth"
+    return f"{port.get('port', '?')} ({auth_text})"
+
+
 @app.command("budget")
 def budget():
     """Show your agent resource budget and usage."""
@@ -141,16 +206,28 @@ def create(
     size: str = typer.Option(None, "--size", "-s", help="Size preset: small, medium, large"),
     cpu: int = typer.Option(None, "--cpu", help="Custom CPU in cores"),
     memory: int = typer.Option(None, "--memory", help="Custom memory in GB"),
+    env: list[str] = typer.Option(None, "--env", "-e", help="Environment variable (KEY=VALUE). Repeatable."),
+    port: list[str] = typer.Option(None, "--port", help="Expose port as PORT or PORT:noauth. Repeatable."),
     no_start: bool = typer.Option(False, "--no-start", help="Create without starting"),
     wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for pod to be running"),
 ):
     """Create a new OpenClaw agent pod."""
     agents = _get_agents_client()
+    env_dict = _parse_env_vars(env)
+    ports_list = _parse_ports(port)
 
     console.print("\n[bold]Creating agent pod...[/bold]")
 
     try:
-        pod = agents.create(name=name, size=size, cpu=cpu, memory=memory, start=not no_start)
+        pod = agents.create(
+            name=name,
+            size=size,
+            cpu=cpu,
+            memory=memory,
+            env=env_dict,
+            ports=ports_list,
+            start=not no_start,
+        )
     except Exception as e:
         console.print(f"[red]❌ Create failed: {e}[/red]")
         raise typer.Exit(1)
@@ -163,6 +240,10 @@ def create(
     console.print(f"  State:    {pod.state}")
     console.print(f"  Desktop:  {pod.vnc_url}")
     console.print(f"  Shell:    {pod.shell_url}")
+    display_ports = pod.ports or ports_list or []
+    for p in display_ports:
+        auth_text = "auth" if p.get("auth", True) else "noauth"
+        console.print(f"  Port {p.get('port')}:  {_port_url(pod, p)} ({auth_text})")
 
     if wait:
         console.print("\n[dim]Waiting for pod to start...[/dim]")
@@ -210,6 +291,7 @@ def list_agents(
         console.print_json(json.dumps([{
             "id": p.id, "pod_name": p.pod_name, "state": p.state,
             "hostname": p.hostname, "vnc_url": p.vnc_url,
+            "ports": p.ports,
         } for p in pods], indent=2, default=str))
         return
 
@@ -224,20 +306,27 @@ def list_agents(
     table.add_column("Size")
     table.add_column("State")
     table.add_column("Desktop URL")
+    has_ports = any(pod.ports for pod in pods)
+    if has_ports:
+        table.add_column("Ports")
     table.add_column("Created")
 
     for pod in pods:
         style = {"running": "green", "pending": "yellow", "starting": "yellow"}.get(pod.state, "red")
         created = pod.created_at.strftime("%Y-%m-%d %H:%M") if pod.created_at else ""
         size_str = f"{pod.cpu}c/{pod.memory}G" if pod.cpu else ""
-        table.add_row(
+        row = [
             pod.id[:12],
             pod.name or pod.pod_name or "",
             size_str,
             f"[{style}]{pod.state}[/{style}]",
             pod.vnc_url or "",
-            created,
-        )
+        ]
+        if has_ports:
+            ports_text = ", ".join(_port_summary(p) for p in pod.ports) if pod.ports else ""
+            row.append(ports_text)
+        row.append(created)
+        table.add_row(*row)
         _save_pod_state(pod)
 
     console.print()

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/hypercli_cli/claw.py

@@ -1,6 +1,7 @@
 """HyperClaw inference commands"""
 import asyncio
 import json
+import os
 from pathlib import Path
 from datetime import datetime, timedelta
 import typer
@@ -346,29 +347,47 @@ def models(
     dev: bool = typer.Option(False, "--dev", help="Use dev API"),
     json_output: bool = typer.Option(False, "--json", help="Print raw JSON response"),
 ):
-    """List available HyperClaw models from the public /models endpoint."""
+    """List available HyperClaw models."""
     import httpx
 
     api_base = DEV_API_BASE if dev else PROD_API_BASE
-    url = f"{api_base}/models"
-
-    try:
-        response = httpx.get(url, timeout=15)
-        response.raise_for_status()
-        payload = response.json()
-    except Exception as e:
-        console.print(f"[red]❌ Failed to fetch models from {url}: {e}[/red]")
+    key = os.getenv("HYPERCLAW_API_KEY")
+    headers = {"Authorization": f"Bearer {key}"} if key else {}
+
+    # Prefer OpenAI-compatible endpoint, then fallback to legacy.
+    urls = [f"{api_base}/v1/models", f"{api_base}/models"]
+    payload = None
+    source_url = None
+    for url in urls:
+        try:
+            response = httpx.get(url, headers=headers, timeout=15)
+            if response.status_code >= 400:
+                continue
+            payload = response.json()
+            source_url = url
+            break
+        except Exception:
+            continue
+
+    if payload is None:
+        console.print(
+            f"[red]❌ Failed to fetch models from {urls[0]} or {urls[1]} "
+            "(set HYPERCLAW_API_KEY if endpoint requires auth)[/red]"
+        )
         raise typer.Exit(1)
 
-    models_data = payload.get("models")
-    if not isinstance(models_data, list):
-        console.print("[red]❌ Unexpected /models response shape (expected top-level models list)[/red]")
+    if isinstance(payload, dict) and isinstance(payload.get("data"), list):
+        models_data = payload.get("data", [])
+    elif isinstance(payload, dict) and isinstance(payload.get("models"), list):
+        models_data = payload.get("models", [])
+    else:
+        console.print("[red]❌ Unexpected models response shape[/red]")
         if json_output:
             console.print_json(json.dumps(payload))
         raise typer.Exit(1)
 
     if json_output:
-        console.print_json(json.dumps(payload))
+        console.print_json(json.dumps({"models": models_data}))
         return
 
     table = Table(title="HyperClaw Models")
@@ -389,7 +408,7 @@ def models(
     console.print()
     console.print(table)
     console.print()
-    console.print(f"Source: {url}")
+    console.print(f"Source: {source_url}")
 
 
 @app.command("login")
@@ -523,6 +542,11 @@ def login(
 OPENCLAW_CONFIG_PATH = Path.home() / ".openclaw" / "openclaw.json"
 
 
+def _resolve_api_base(base_url: str | None = None, dev: bool = False) -> str:
+    """Resolve API base from flag/env, then fall back to dev/prod defaults."""
+    return (base_url or os.environ.get("HYPERCLAW_API_BASE") or (DEV_API_BASE if dev else PROD_API_BASE)).rstrip("/")
+
+
 def fetch_models(api_key: str, api_base: str = PROD_API_BASE) -> list[dict]:
     """Fetch available models from LiteLLM /v1/models (served by HyperClaw)."""
     import httpx
@@ -546,6 +570,7 @@ def fetch_models(api_key: str, api_base: str = PROD_API_BASE) -> list[dict]:
                 "reasoning": MODEL_META.get(m["id"], {}).get("reasoning", False),
                 "input": ["text"],
                 "contextWindow": MODEL_META.get(m["id"], {}).get("contextWindow", 200000),
+                **({"mode": m["mode"]} if m.get("mode") else {}),
             }
             for m in data
             if m.get("id")
@@ -607,11 +632,19 @@ def openclaw_setup(
 
     # Patch models.providers.hyperclaw + embedding config
     config.setdefault("models", {}).setdefault("providers", {})
+    chat_models = [m for m in models if m.get("mode") != "embedding"]
+    embedding_models = [m for m in models if m.get("mode") == "embedding"]
     config["models"]["providers"]["hyperclaw"] = {
+        "baseUrl": "https://api.hyperclaw.app",
+        "apiKey": api_key,
+        "api": "anthropic-messages",
+        "models": chat_models,
+    }
+    config["models"]["providers"]["hyperclaw-embed"] = {
         "baseUrl": "https://api.hyperclaw.app/v1",
         "apiKey": api_key,
         "api": "openai-completions",
-        "models": models,
+        "models": embedding_models,
     }
 
     # Always set embedding provider (reuses same API key)
@@ -628,7 +661,8 @@ def openclaw_setup(
     # Optionally set default model
     if default:
         config["agents"]["defaults"].setdefault("model", {})
-        config["agents"]["defaults"]["model"]["primary"] = f"hyperclaw/{models[0]['id']}"
+        if chat_models:
+            config["agents"]["defaults"]["model"]["primary"] = f"hyperclaw/{chat_models[0]['id']}"
 
     # Write back
     OPENCLAW_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
@@ -638,10 +672,14 @@ def openclaw_setup(
 
     console.print(f"[green]✅ Patched {OPENCLAW_CONFIG_PATH}[/green]")
     console.print(f"   provider: hyperclaw  key: {api_key[:16]}...")
-    for m in models:
+    if embedding_models:
+        console.print("   embedding provider: hyperclaw-embed")
+    for m in chat_models:
         console.print(f"   model: hyperclaw/{m['id']}")
-    if default:
-        console.print(f"   default model: hyperclaw/{models[0]['id']}")
+    for m in embedding_models:
+        console.print(f"   model: hyperclaw-embed/{m['id']}")
+    if default and chat_models:
+        console.print(f"   default model: hyperclaw/{chat_models[0]['id']}")
     console.print("\nRun: [bold]openclaw gateway restart[/bold]")
 
 
@@ -666,22 +704,34 @@ def _resolve_api_key(key: str | None) -> str:
 
 def _config_openclaw(api_key: str, models: list[dict], api_base: str = PROD_API_BASE) -> dict:
     """OpenClaw openclaw.json provider snippet (LLM + embeddings)."""
+    api_base = api_base.rstrip("/")
+    chat_models = [m for m in models if m.get("mode") != "embedding"]
+    embedding_models = [m for m in models if m.get("mode") == "embedding"]
     return {
         "models": {
             "mode": "merge",
             "providers": {
                 "hyperclaw": {
+                    # OpenClaw/pi-ai appends /v1/messages for anthropic-messages.
+                    "baseUrl": api_base,
+                    "apiKey": api_key,
+                    "api": "anthropic-messages",
+                    "models": chat_models,
+                },
+                "hyperclaw-embed": {
+                    # Embeddings go through the OpenAI-compatible /v1 endpoints.
                     "baseUrl": f"{api_base}/v1",
                     "apiKey": api_key,
                     "api": "openai-completions",
-                    "models": models,
-                }
+                    "models": embedding_models,
+                },
             }
         },
         "agents": {
             "defaults": {
                 "models": {
-                    **{f"hyperclaw/{m['id']}": {"alias": m['id'].split('-')[0]} for m in models}
+                    **{f"hyperclaw/{m['id']}": {"alias": m['id'].split('-')[0]} for m in chat_models},
+                    **{f"hyperclaw-embed/{m['id']}": {"alias": m['id'].split('-')[0]} for m in embedding_models},
                 },
                 "memorySearch": {
                     "provider": "openai",
@@ -696,8 +746,9 @@ def _config_openclaw(api_key: str, models: list[dict], api_base: str = PROD_API_
     }
 
 
-def _config_opencode(api_key: str, models: list[dict]) -> dict:
+def _config_opencode(api_key: str, models: list[dict], api_base: str = PROD_API_BASE) -> dict:
     """OpenCode opencode.json provider snippet."""
+    api_base = api_base.rstrip("/")
     model_entries = {}
     for m in models:
         model_entries[m["id"]] = {"name": m["id"]}
@@ -708,7 +759,7 @@ def _config_opencode(api_key: str, models: list[dict]) -> dict:
                 "npm": "@ai-sdk/openai-compatible",
                 "name": "HyperCLI",
                 "options": {
-                    "baseURL": "https://api.hyperclaw.app/v1",
+                    "baseURL": f"{api_base}/v1",
                     "apiKey": api_key,
                 },
                 "models": model_entries,
@@ -717,16 +768,39 @@ def _config_opencode(api_key: str, models: list[dict]) -> dict:
     }
 
 
-def _config_env(api_key: str, models: list[dict]) -> str:
+def _config_env(api_key: str, models: list[dict], api_base: str = PROD_API_BASE) -> str:
     """Shell env vars for generic OpenAI-compatible tools."""
+    api_base = api_base.rstrip("/")
     lines = [
         f'export OPENAI_API_KEY="{api_key}"',
-        'export OPENAI_BASE_URL="https://api.hyperclaw.app/v1"',
+        f'export OPENAI_BASE_URL="{api_base}/v1"',
         f'# Available models: {", ".join(m["id"] for m in models)}',
     ]
     return "\n".join(lines)
 
 
+@app.command("exec")
+def exec_cmd(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+    command: str = typer.Argument(..., help="Command to execute"),
+    timeout: int = typer.Option(30, "--timeout", "-t", help="Command timeout (seconds)"),
+):
+    """Execute a command on a HyperClaw agent container."""
+    from . import agents
+
+    agents.exec_cmd(agent_id=agent_id, command=command, timeout=timeout)
+
+
+@app.command("shell")
+def shell_cmd(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+):
+    """Open an interactive shell on a HyperClaw agent container."""
+    from . import agents
+
+    agents.shell(agent_id=agent_id)
+
+
 FORMAT_CHOICES = ["openclaw", "opencode", "env"]
 
 
@@ -737,6 +811,7 @@ def config_cmd(
         help=f"Output format: {', '.join(FORMAT_CHOICES)}. Omit to show all.",
     ),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...). Falls back to ~/.hypercli/claw-key.json"),
+    base_url: str = typer.Option(None, "--base-url", help="HyperClaw API base URL. Falls back to HYPERCLAW_API_BASE, then --dev/prod defaults"),
     apply: bool = typer.Option(False, "--apply", help="Write config to the appropriate file (openclaw/opencode only)"),
     dev: bool = typer.Option(False, "--dev", help="Use dev API"),
 ):
@@ -746,11 +821,12 @@ def config_cmd(
       hyper claw config                          # Show all configs
       hyper claw config openclaw                 # OpenClaw snippet
       hyper claw config opencode --key sk-...    # OpenCode with explicit key
+      hyper claw config openclaw --base-url https://dev-api.hyperclaw.app
       hyper claw config openclaw --apply         # Write directly to openclaw.json
       hyper claw config env                      # Shell export lines
     """
     api_key = _resolve_api_key(key)
-    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    api_base = _resolve_api_base(base_url, dev)
 
     # Validate key & fetch models
     console.print(f"[dim]Validating key against {api_base}...[/dim]")
@@ -770,12 +846,12 @@ def config_cmd(
             snippet = _config_openclaw(api_key, models, api_base)
             _show_snippet("OpenClaw", "~/.openclaw/openclaw.json", snippet, apply, OPENCLAW_CONFIG_PATH)
         elif fmt == "opencode":
-            snippet = _config_opencode(api_key, models)
+            snippet = _config_opencode(api_key, models, api_base)
             target = Path.cwd() / "opencode.json"
             _show_snippet("OpenCode", "opencode.json", snippet, apply, target)
         elif fmt == "env":
             console.print("[bold]── Shell Environment ──[/bold]")
-            console.print(_config_env(api_key, models))
+            console.print(_config_env(api_key, models, api_base))
             console.print()
 
 

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/hypercli_cli/jobs.py

@@ -11,6 +11,17 @@ def get_client() -> HyperCLI:
     return HyperCLI()
 
 
+def _parse_tags(tag_args: list[str]) -> dict[str, str]:
+    tags: dict[str, str] = {}
+    for tag in tag_args:
+        key, sep, value = tag.partition("=")
+        if not sep or not key or not value:
+            console.print(f"[red]Error:[/red] Invalid tag '{tag}'. Expected KEY=VALUE.")
+            raise typer.Exit(1)
+        tags[key] = value
+    return tags
+
+
 def _resolve_job_id(client: HyperCLI, job_id: str) -> str:
     """Resolve a partial job ID prefix to a full UUID."""
     if len(job_id) == 36:
@@ -32,12 +43,14 @@ def _resolve_job_id(client: HyperCLI, job_id: str) -> str:
 @app.command("list")
 def list_jobs(
     state: Optional[str] = typer.Option(None, "--state", "-s", help="Filter by state"),
+    tag: list[str] = typer.Option([], "--tag", help="Filter by tag as KEY=VALUE", metavar="KEY=VALUE"),
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
 ):
     """List all jobs"""
     client = get_client()
+    tags = _parse_tags(tag) if tag else None
     with spinner("Fetching jobs..."):
-        jobs = client.jobs.list(state=state)
+        jobs = client.jobs.list(state=state, tags=tags)
 
     if fmt == "json":
         output(jobs, "json")
@@ -45,7 +58,11 @@ def list_jobs(
         if not jobs:
             console.print("[dim]No jobs found[/dim]")
             return
-        output(jobs, "table", ["job_id", "state", "gpu_type", "gpu_count", "region", "hostname"])
+        output(
+            jobs,
+            "table",
+            ["job_id", "state", "gpu_type", "gpu_count", "region", "time_left", "runtime", "hostname"],
+        )
 
 
 @app.command("get")

{hypercli_cli-1.0.9 → hypercli_cli-2026.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "1.0.9"
+version = "2026.3.10"
 description = "CLI for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,7 +13,7 @@ authors = [
     { name = "HyperCLI", email = "support@hypercli.com" }
 ]
 dependencies = [
-    "hypercli-sdk>=1.0.0",
+    "hypercli-sdk>=2026.3.10",
     "typer>=0.20.0",
     "rich>=14.2.0",
     "websocket-client>=1.6.0",
@@ -24,7 +24,7 @@ dependencies = [
 
 [project.optional-dependencies]
 comfyui = [
-    "hypercli-sdk[comfyui]>=1.0.0",
+    "hypercli-sdk[comfyui]>=2026.3.10",
 ]
 wallet = [
     "x402[httpx,evm]>=2.0.0",
@@ -37,7 +37,7 @@ stt = [
     "faster-whisper>=1.1.0",
 ]
 all = [
-    "hypercli-sdk[comfyui]>=1.0.0",
+    "hypercli-sdk[comfyui]>=2026.3.10",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-2026.3.10/tests/test_exec_shell_dryrun.py

@@ -0,0 +1,128 @@
+from types import SimpleNamespace
+
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+
+
+runner = CliRunner()
+FULL_JOB_ID = "123e4567-e89b-12d3-a456-426614174000"
+
+
+def test_jobs_exec_mock(monkeypatch):
+    class FakeJobs:
+        def exec(self, job_id, command, timeout=30):
+            assert job_id == FULL_JOB_ID
+            assert command == "echo hi"
+            assert timeout == 9
+            return SimpleNamespace(stdout="hi\n", stderr="", exit_code=0)
+
+    fake_client = SimpleNamespace(jobs=FakeJobs())
+
+    monkeypatch.setattr("hypercli_cli.jobs.get_client", lambda: fake_client)
+    monkeypatch.setattr("hypercli_cli.jobs._resolve_job_id", lambda client, job_id: job_id)
+
+    result = runner.invoke(app, ["jobs", "exec", FULL_JOB_ID, "echo hi", "--timeout", "9"])
+
+    assert result.exit_code == 0
+    assert "hi" in result.stdout
+
+
+def test_jobs_get_shows_command_and_env(monkeypatch):
+    class FakeJobs:
+        def list(self):
+            return [SimpleNamespace(job_id=FULL_JOB_ID)]
+
+        def get(self, job_id):
+            assert job_id == FULL_JOB_ID
+            return SimpleNamespace(
+                job_id=job_id,
+                state="terminated",
+                gpu_type="H200",
+                gpu_count=8,
+                region="oh",
+                docker_image="vllm/vllm-openai:glm5",
+                command="vllm serve zai-org/GLM-5-FP8 --host 0.0.0.0 --port 8000",
+                env_vars={"LD_LIBRARY_PATH": "/usr/local/nvidia/lib64:/usr/local/nvidia/lib:/usr/lib/x86_64-linux-gnu"},
+                runtime=3600,
+            )
+
+    fake_client = SimpleNamespace(jobs=FakeJobs())
+
+    monkeypatch.setattr("hypercli_cli.jobs.get_client", lambda: fake_client)
+
+    result = runner.invoke(app, ["jobs", "get", FULL_JOB_ID])
+
+    assert result.exit_code == 0
+    assert "vllm serve zai-org/GLM-5-FP8" in result.stdout
+    assert "LD_LIBRARY_PATH" in result.stdout
+
+
+def test_instances_launch_dry_run_mock(monkeypatch):
+    captured = {}
+
+    class FakeJobs:
+        def create(self, **kwargs):
+            captured.update(kwargs)
+            return SimpleNamespace(
+                job_id="job-dryrun",
+                state="validated",
+                gpu_type="l40s",
+                gpu_count=1,
+                region="oh",
+                price_per_hour=1.23,
+                runtime=300,
+                cold_boot=False,
+                hostname=None,
+            )
+
+    fake_client = SimpleNamespace(jobs=FakeJobs())
+    monkeypatch.setattr("hypercli_cli.instances.get_client", lambda: fake_client)
+
+    result = runner.invoke(
+        app,
+        [
+            "instances",
+            "launch",
+            "nvidia/cuda:12.0-base-ubuntu22.04",
+            "--dry-run",
+            "--command",
+            "echo hi",
+            "--output",
+            "json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert captured["dry_run"] is True
+    assert "job-dryrun" in result.stdout
+
+
+def test_claw_exec_alias(monkeypatch):
+    called = {}
+
+    def fake_exec_cmd(agent_id, command, timeout=30):
+        called["agent_id"] = agent_id
+        called["command"] = command
+        called["timeout"] = timeout
+
+    monkeypatch.setattr("hypercli_cli.agents.exec_cmd", fake_exec_cmd)
+
+    result = runner.invoke(app, ["claw", "exec", "agent-1", "echo ok", "--timeout", "7"])
+
+    assert result.exit_code == 0
+    assert called == {"agent_id": "agent-1", "command": "echo ok", "timeout": 7}
+
+
+def test_claw_shell_alias(monkeypatch):
+    called = {}
+
+    def fake_shell(agent_id):
+        called["agent_id"] = agent_id
+
+    monkeypatch.setattr("hypercli_cli.agents.shell", fake_shell)
+
+    result = runner.invoke(app, ["claw", "shell", "agent-xyz"])
+
+    assert result.exit_code == 0
+    assert called["agent_id"] == "agent-xyz"

hypercli_cli-2026.3.10/tests/test_jobs_list_tags.py

@@ -0,0 +1,39 @@
+from types import SimpleNamespace
+
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+
+
+runner = CliRunner()
+
+
+def test_jobs_list_passes_tags(monkeypatch):
+    captured = {}
+
+    class FakeJobs:
+        def list(self, state=None, tags=None):
+            captured["state"] = state
+            captured["tags"] = tags
+            return []
+
+    fake_client = SimpleNamespace(jobs=FakeJobs())
+    monkeypatch.setattr("hypercli_cli.jobs.get_client", lambda: fake_client)
+
+    result = runner.invoke(
+        app,
+        ["jobs", "list", "--state", "running", "--tag", "team=ml", "--tag", "env=prod"],
+    )
+
+    assert result.exit_code == 0
+    assert captured == {"state": "running", "tags": {"team": "ml", "env": "prod"}}
+
+
+def test_jobs_list_rejects_invalid_tag(monkeypatch):
+    fake_client = SimpleNamespace(jobs=SimpleNamespace(list=lambda state=None, tags=None: []))
+    monkeypatch.setattr("hypercli_cli.jobs.get_client", lambda: fake_client)
+
+    result = runner.invoke(app, ["jobs", "list", "--tag", "broken"])
+
+    assert result.exit_code == 1
+    assert "Expected KEY=VALUE" in result.stdout

hypercli_cli-1.0.9/hypercli_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.0.8"