hypercli-cli 1.0.8__tar.gz → 2026.3.8__tar.gz

{hypercli_cli-1.0.8 → hypercli_cli-2026.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 1.0.8
+Version: 2026.3.8
 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.8
 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.8; 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.8; 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.8 → hypercli_cli-2026.3.8}/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.8/hypercli_cli/__init__.py

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

{hypercli_cli-1.0.8 → hypercli_cli-2026.3.8}/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.8 → hypercli_cli-2026.3.8}/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
@@ -9,7 +10,6 @@ from rich.table import Table
 
 from .onboard import onboard as _onboard_fn
 from .voice import app as voice_app
-from .stt import app as stt_app
 from .stt import transcribe as _stt_transcribe
 from .embed import app as embed_app
 
@@ -19,12 +19,11 @@ console = Console()
 # Register subcommands
 app.command("onboard")(_onboard_fn)
 app.add_typer(voice_app, name="voice")
-app.add_typer(stt_app, name="stt")
 app.add_typer(embed_app, name="embed")
 
 
 @app.command("transcribe")
-def transcribe_alias(
+def transcribe(
     audio_file: Path = typer.Argument(..., help="Audio file to transcribe (wav, mp3, ogg, m4a, etc.)"),
     model: str = typer.Option("turbo", "--model", "-m", help="Whisper model: tiny, base, small, medium, large-v3, turbo"),
     language: str = typer.Option(None, "--language", "-l", help="Language code (e.g. en, de, fr). Auto-detect if omitted."),
@@ -33,21 +32,13 @@ def transcribe_alias(
     json_output: bool = typer.Option(False, "--json", help="Output as JSON with timestamps"),
     output: Path = typer.Option(None, "--output", "-o", help="Write transcript to file"),
 ):
-    """Alias for `hyper claw stt transcribe` (local faster-whisper)."""
-    _stt_transcribe(audio_file, model, language, device, compute_type, json_output, output)
-
+    """Transcribe audio to text using faster-whisper (runs locally).
 
-@app.command("trascribe", hidden=True)
-def trascribe_alias(
-    audio_file: Path = typer.Argument(..., help="Audio file to transcribe (wav, mp3, ogg, m4a, etc.)"),
-    model: str = typer.Option("turbo", "--model", "-m", help="Whisper model: tiny, base, small, medium, large-v3, turbo"),
-    language: str = typer.Option(None, "--language", "-l", help="Language code (e.g. en, de, fr). Auto-detect if omitted."),
-    device: str = typer.Option("auto", "--device", "-d", help="Device: auto, cpu, cuda"),
-    compute_type: str = typer.Option("auto", "--compute", help="Compute type: auto, int8, float16, float32"),
-    json_output: bool = typer.Option(False, "--json", help="Output as JSON with timestamps"),
-    output: Path = typer.Option(None, "--output", "-o", help="Write transcript to file"),
-):
-    """Backward-compatible typo alias for transcribe."""
+    Examples:
+      hyper claw transcribe voice.ogg
+      hyper claw transcribe meeting.mp3 --model large-v3 --language en
+      hyper claw transcribe audio.wav --json -o transcript.json
+    """
     _stt_transcribe(audio_file, model, language, device, compute_type, json_output, output)
 
 # Check if wallet dependencies are available
@@ -356,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")
@@ -399,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")
@@ -556,6 +565,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")
@@ -617,17 +627,25 @@ 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)
     config.setdefault("agents", {}).setdefault("defaults", {})
     config["agents"]["defaults"]["memorySearch"] = {
-        "provider": "openai",
+        "provider": "hyperclaw-embed",
         "model": "qwen3-embedding-4b",
         "remote": {
             "baseUrl": "https://api.hyperclaw.app/v1/",
@@ -638,7 +656,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)
@@ -648,10 +667,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]")
 
 
@@ -676,25 +699,36 @@ 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)."""
+    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",
+                    "provider": "hyperclaw-embed",
                     "model": "qwen3-embedding-4b",
                     "remote": {
                         "baseUrl": f"{api_base}/v1/",
@@ -737,6 +771,28 @@ def _config_env(api_key: str, models: list[dict]) -> str:
     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"]
 
 

{hypercli_cli-1.0.8 → hypercli_cli-2026.3.8}/hypercli_cli/instances.py

@@ -231,6 +231,12 @@ def launch(
         if lb:
             ports_dict["lb"] = lb
 
+    raw_tcp_ports = []
+    if ports_dict:
+        raw_tcp_ports = sorted(
+            int(p.split("/")[0]) for p in ports_dict.keys() if p.endswith("/tcp")
+        )
+
     # Build registry auth if provided
     registry_auth = None
     if registry_user and registry_password:
@@ -302,6 +308,13 @@ def launch(
             console.print(f"  Price:      ${job.price_per_hour:.2f}/hr")
             if job.hostname:
                 console.print(f"  Hostname:   {job.hostname}")
+            if lb:
+                console.print(f"  HTTPS LB:   Traefik TLS on https://{job.hostname}")
+                console.print(f"  LB Target:  container port {lb}")
+                if lb_auth:
+                    console.print("  LB Auth:    enabled (Bearer token required)")
+            if raw_tcp_ports:
+                console.print(f"  TCP Ports:  raw TCP exposed: {', '.join(map(str, raw_tcp_ports))}")
             console.print(f"  Access Key: {x402_job.access_key}")
             console.print(f"  Status URL: {x402_job.status_url}")
             console.print(f"  Logs URL:   {x402_job.logs_url}")
@@ -336,6 +349,12 @@ def launch(
                 console.print(f"  Region:   {job.region}")
                 console.print(f"  Price:    ${job.price_per_hour:.2f}/hr")
                 console.print(f"  Runtime:  {job.runtime}s")
+                if lb:
+                    console.print(f"  HTTPS LB: Traefik TLS will be provisioned for container port {lb}")
+                    if lb_auth:
+                        console.print("  LB Auth:  enabled (Bearer token required)")
+                if raw_tcp_ports:
+                    console.print(f"  TCP:      raw TCP ports: {', '.join(map(str, raw_tcp_ports))}")
                 # Display cold boot status
                 import sys
                 if job.cold_boot:
@@ -350,6 +369,13 @@ def launch(
                 console.print(f"  Price:    ${job.price_per_hour:.2f}/hr")
                 if job.hostname:
                     console.print(f"  Hostname: {job.hostname}")
+                if lb and job.hostname:
+                    console.print(f"  HTTPS LB: Traefik TLS endpoint https://{job.hostname}")
+                    console.print(f"  LB Target: container port {lb}")
+                    if lb_auth:
+                        console.print("  LB Auth:  enabled (Bearer token required)")
+                if raw_tcp_ports:
+                    console.print(f"  TCP:      raw TCP ports: {', '.join(map(str, raw_tcp_ports))}")
                 # Display cold boot status for real launches too
                 if job.cold_boot:
                     console.print("[yellow]⏳ Cold boot — instance provisioning may take up to 15 minutes[/]")

{hypercli_cli-1.0.8 → hypercli_cli-2026.3.8}/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.8 → hypercli_cli-2026.3.8}/hypercli_cli/voice.py

@@ -14,8 +14,7 @@ console = Console()
 
 HYPERCLI_DIR = Path.home() / ".hypercli"
 CLAW_KEY_PATH = HYPERCLI_DIR / "claw-key.json"
-PROD_API_BASE = "https://api.hyperclaw.app"
-DEV_API_BASE = "https://dev-api.hyperclaw.app"
+DEFAULT_API_BASE = "https://api.hyperclaw.app"
 
 
 def _get_api_key(key: str | None) -> str:
@@ -35,15 +34,25 @@ def _get_api_key(key: str | None) -> str:
     raise typer.Exit(1)
 
 
+def _resolve_api_base(base_url: str | None) -> str:
+    """Resolve API base: --base-url > HYPERCLAW_API_BASE env > default."""
+    if base_url:
+        return base_url.rstrip("/")
+    env_base = os.environ.get("HYPERCLAW_API_BASE", "").strip()
+    if env_base:
+        return env_base.rstrip("/")
+    return DEFAULT_API_BASE
+
+
 def _post_voice(
     endpoint: str,
     payload: dict,
     api_key: str,
     output: Path,
-    dev: bool = False,
+    base_url: str | None = None,
 ):
     """POST to voice endpoint and save audio output."""
-    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    api_base = _resolve_api_base(base_url)
     url = f"{api_base}/voice/{endpoint}"
 
     console.print(f"[dim]→ POST {url}[/dim]")
@@ -83,10 +92,10 @@ def tts(
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
-    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hyperclaw.app)"),
 ):
     """Generate speech from text using a preset voice.
-    
+
     Examples:
       hyper claw voice tts "Hello world"
       hyper claw voice tts "Bonjour" -v Etienne -l french -f opus -o hello.opus
@@ -100,7 +109,7 @@ def tts(
         "language": language,
         "response_format": format,
     }
-    _post_voice("tts", payload, api_key, output, dev)
+    _post_voice("tts", payload, api_key, output, base_url)
 
 
 @app.command("clone")
@@ -112,10 +121,10 @@ def clone(
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
-    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hyperclaw.app)"),
 ):
     """Clone a voice from reference audio.
-    
+
     Examples:
       hyper claw voice clone "Hello" --ref voice.wav
       hyper claw voice clone "Test" -r ref.wav -l english -f mp3 -o cloned.mp3
@@ -140,7 +149,7 @@ def clone(
         "x_vector_only": x_vector_only,
         "response_format": format,
     }
-    _post_voice("clone", payload, api_key, output, dev)
+    _post_voice("clone", payload, api_key, output, base_url)
 
 
 @app.command("design")
@@ -151,10 +160,10 @@ def design(
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
-    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hyperclaw.app)"),
 ):
     """Design a voice from a text description.
-    
+
     Examples:
       hyper claw voice design "Hello" --desc "deep male voice, British accent"
       hyper claw voice design "Test" -d "young woman, cheerful" -f mp3 -o designed.mp3
@@ -168,4 +177,4 @@ def design(
         "language": language,
         "response_format": format,
     }
-    _post_voice("design", payload, api_key, output, dev)
+    _post_voice("design", payload, api_key, output, base_url)

{hypercli_cli-1.0.8 → hypercli_cli-2026.3.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "1.0.8"
+version = "2026.3.8"
 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.8",
     "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.8",
 ]
 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.8",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-2026.3.8/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.8/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.8/hypercli_cli/__init__.py

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