hypercli-cli 2026.3.18__tar.gz → 2026.3.25__tar.gz

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/.gitignore

@@ -28,6 +28,9 @@ coverage
 .DS_Store
 *.pem
 
+# IDE
+.idea/
+
 # Debug
 npm-debug.log*
 yarn-debug.log*

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 2026.3.18
+Version: 2026.3.25
 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>=2026.3.18
+Requires-Dist: hypercli-sdk>=2026.3.25
 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]>=2026.3.18; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.3.25; 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]>=2026.3.18; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.3.25; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

hypercli_cli-2026.3.25/hypercli_cli/__init__.py

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

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/agent.py

@@ -353,7 +353,7 @@ def models(
     import httpx
 
     api_base = DEV_API_BASE if dev else PROD_API_BASE
-    key = os.getenv("HYPERCLAW_API_KEY")
+    key = os.getenv("HYPER_API_KEY")
     headers = {"Authorization": f"Bearer {key}"} if key else {}
 
     # Prefer OpenAI-compatible endpoint, then fallback to legacy.
@@ -374,7 +374,7 @@ def models(
     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]"
+            "(set HYPER_API_KEY if endpoint requires auth)[/red]"
         )
         raise typer.Exit(1)
 
@@ -548,7 +548,7 @@ 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 os.environ.get("HYPER_API_BASE")
         or (DEV_INFERENCE_API_BASE if dev else PROD_INFERENCE_API_BASE)
     ).rstrip("/")
 
@@ -881,7 +881,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/agent-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"),
+    base_url: str = typer.Option(None, "--base-url", help="HyperClaw API base URL. Falls back to HYPER_API_BASE, then --dev/prod defaults"),
     placeholder_env: str = typer.Option(None, "--placeholder-env", help="Write ${ENV_VAR} placeholders into generated config instead of literal API keys"),
     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"),

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/agents.py

@@ -18,8 +18,6 @@ app = typer.Typer(help="Manage OpenClaw agent pods")
 console = Console()
 PROD_API_BASE = "https://api.hypercli.com"
 DEV_API_BASE = "https://api.dev.hypercli.com"
-PROD_AGENTS_WS_URL = "wss://api.agents.hypercli.com/ws"
-DEV_AGENTS_WS_URL = "wss://api.agents.dev.hypercli.com/ws"
 _GLOBAL_DEV = False
 _GLOBAL_AGENTS_WS_URL: str | None = None
 
@@ -49,7 +47,10 @@ def agents_root(
 
 def _get_agent_api_key() -> str:
     """Resolve HyperClaw API key from env or saved key file."""
-    key = os.environ.get("HYPERCLAW_API_KEY", "")
+    key = os.environ.get("HYPER_AGENTS_API_KEY", "").strip()
+    if key:
+        return key
+    key = os.environ.get("HYPER_API_KEY", "").strip()
     if key:
         return key
     if AGENT_KEY_PATH.exists():
@@ -59,7 +60,7 @@ def _get_agent_api_key() -> str:
         if key:
             return key
     console.print("[red]❌ No HyperClaw API key found.[/red]")
-    console.print("Set HYPERCLAW_API_KEY or subscribe: [bold]hyper agent subscribe 1aiu[/bold]")
+    console.print("Set HYPER_AGENTS_API_KEY or HYPER_API_KEY, or subscribe: [bold]hyper agent subscribe 1aiu[/bold]")
     raise typer.Exit(1)
 
 
@@ -67,12 +68,13 @@ def _get_deployments_client(agents_ws_url: str | None = None) -> Deployments:
     """Create a Deployments client using the HyperClaw API key."""
     from hypercli.http import HTTPClient
     api_key = _get_agent_api_key()
-    api_base = os.environ.get("HYPERCLI_API_URL") or (DEV_API_BASE if _GLOBAL_DEV else PROD_API_BASE)
+    api_base = (
+        os.environ.get("AGENTS_API_BASE_URL")
+        or os.environ.get("HYPER_API_BASE")
+        or os.environ.get("HYPERCLI_API_URL")
+        or (DEV_API_BASE if _GLOBAL_DEV else PROD_API_BASE)
+    )
     resolved_agents_ws_url = agents_ws_url or _GLOBAL_AGENTS_WS_URL or os.environ.get("AGENTS_WS_URL")
-    if _GLOBAL_DEV and not resolved_agents_ws_url:
-        resolved_agents_ws_url = DEV_AGENTS_WS_URL
-    if not _GLOBAL_DEV and not resolved_agents_ws_url and os.environ.get("HYPERCLI_API_URL", "").strip() == "":
-        resolved_agents_ws_url = PROD_AGENTS_WS_URL
     http = HTTPClient(api_base, api_key)
     return Deployments(http, api_key=api_key, api_base=api_base, agents_ws_url=resolved_agents_ws_url)
 
@@ -651,7 +653,10 @@ def cp(
             local_path = agents.cp_from(pod, src_path, dst_path)
             console.print(f"[green]✓[/green] Copied [bold]{src_agent_id[:12]}:{src_path}[/bold] to [bold]{local_path}[/bold]")
     except Exception as e:
-        console.print(f"[red]❌ Copy failed: {e}[/red]")
+        message = str(e)
+        if message.startswith("Path is a directory:"):
+            message = f"{message} Copy expects a file path, not a directory."
+        console.print(f"[red]❌ Copy failed: {message}[/red]")
         raise typer.Exit(1)
 
 
@@ -998,6 +1003,59 @@ def gateway_cron(
     _run_async(_run())
 
 
+@app.command("cron-add")
+def gateway_cron_add(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    job_json: str = typer.Argument(..., help='Cron job JSON, e.g. \'{"name":"backup","schedule":"0 * * * *","command":"echo hi"}\''),
+):
+    """Add a cron job to an agent's gateway."""
+    pod = _require_openclaw_agent(_get_pod_with_token(agent_id))
+    try:
+        job_data = json.loads(job_json)
+    except json.JSONDecodeError as e:
+        console.print(f"[red]Invalid JSON: {e}[/red]")
+        raise typer.Exit(1)
+
+    async def _run():
+        result = await pod.cron_add(job_data)
+        console.print(f"[green]Cron job added[/green]")
+        console.print_json(json.dumps(result, default=str))
+
+    _run_async(_run())
+
+
+@app.command("cron-remove")
+def gateway_cron_remove(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    job_id: str = typer.Argument(..., help="Cron job ID to remove"),
+):
+    """Remove a cron job from an agent's gateway."""
+    pod = _require_openclaw_agent(_get_pod_with_token(agent_id))
+
+    async def _run():
+        await pod.cron_remove(job_id)
+        console.print(f"[green]Cron job {job_id} removed[/green]")
+
+    _run_async(_run())
+
+
+@app.command("cron-run")
+def gateway_cron_run(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    job_id: str = typer.Argument(..., help="Cron job ID to trigger"),
+):
+    """Manually trigger a cron job on an agent's gateway."""
+    pod = _require_openclaw_agent(_get_pod_with_token(agent_id))
+
+    async def _run():
+        result = await pod.cron_run(job_id)
+        console.print(f"[green]Cron job {job_id} triggered[/green]")
+        if result:
+            console.print_json(json.dumps(result, default=str))
+
+    _run_async(_run())
+
+
 @app.command("gateway-chat")
 def gateway_chat(
     agent_id: str = typer.Argument(None, help="Agent ID or name"),
@@ -1015,6 +1073,8 @@ def gateway_chat(
                 console.print(f"[dim]{event.text}[/dim]", end="")
             elif event.type == "tool_call":
                 console.print(f"\n[yellow]🔧 {event.data}[/yellow]")
+            elif event.type == "tool_result":
+                console.print(f"\n[cyan]📤 {event.data}[/cyan]")
             elif event.type == "error":
                 console.print(f"\n[red]❌ {event.text}[/red]")
             elif event.type == "done":

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/cli.py

@@ -8,7 +8,7 @@ from rich.prompt import Prompt
 from hypercli import HyperCLI, APIError, configure
 from hypercli.config import CONFIG_FILE
 
-from . import agent, agents, billing, comfyui, flow, instances, jobs, keys, user, wallet
+from . import agent, agents, billing, comfyui, files, flow, instances, jobs, keys, user, wallet
 
 console = Console()
 
@@ -61,6 +61,7 @@ app.add_typer(agents.app, name="agents")
 app.add_typer(agent.app, name="agent")
 app.add_typer(billing.app, name="billing")
 app.add_typer(comfyui.app, name="comfyui")
+app.add_typer(files.app, name="files")
 app.add_typer(flow.app, name="flow")
 app.add_typer(instances.app, name="instances")
 app.add_typer(keys.app, name="keys")

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/embed.py

@@ -17,10 +17,10 @@ DEV_API_BASE = "https://api.dev.hypercli.com"
 
 
 def _get_api_key(key: str | None) -> str:
-    """Resolve API key: --key flag > env HYPERCLAW_API_KEY > agent-key.json."""
+    """Resolve API key: --key flag > env HYPER_API_KEY > agent-key.json."""
     if key:
         return key
-    env_key = os.environ.get("HYPERCLAW_API_KEY", "").strip()
+    env_key = os.environ.get("HYPER_API_KEY", "").strip()
     if env_key:
         return env_key
     if AGENT_KEY_PATH.exists():
@@ -29,7 +29,7 @@ def _get_api_key(key: str | None) -> str:
         if k:
             return k
     console.print("[red]❌ No API key found.[/red]")
-    console.print("Pass [bold]--key sk-...[/bold], set [bold]HYPERCLAW_API_KEY[/bold], or run [bold]hyper agent subscribe[/bold]")
+    console.print("Pass [bold]--key sk-...[/bold], set [bold]HYPER_API_KEY[/bold], or run [bold]hyper agent subscribe[/bold]")
     raise typer.Exit(1)
 
 

hypercli_cli-2026.3.25/hypercli_cli/files.py

@@ -0,0 +1,111 @@
+"""File management CLI commands"""
+import os
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(help="Upload, inspect, and delete files on the platform")
+console = Console()
+
+
+def _get_client():
+    from hypercli import HyperCLI
+    return HyperCLI()
+
+
+def _fmt_size(size: int) -> str:
+    """Format file size for display."""
+    if size < 1024:
+        return f"{size} B"
+    if size < 1024 * 1024:
+        return f"{size / 1024:.1f} KB"
+    return f"{size / (1024 * 1024):.1f} MB"
+
+
+@app.command("upload")
+def upload_file(
+    file_path: str = typer.Argument(..., help="Path to local file to upload"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for upload to complete"),
+):
+    """Upload a file for use in flows and renders."""
+    if not os.path.isfile(file_path):
+        console.print(f"[red]File not found: {file_path}[/red]")
+        raise typer.Exit(1)
+
+    client = _get_client()
+    console.print(f"Uploading [cyan]{os.path.basename(file_path)}[/cyan] ({_fmt_size(os.path.getsize(file_path))})...")
+    f = client.files.upload(file_path)
+    console.print(f"[green]Uploaded[/green]  ID: [bold]{f.id}[/bold]")
+
+    if wait and f.state == "processing":
+        console.print("Waiting for processing...", end="")
+        f = client.files.wait_ready(f.id)
+        console.print(f" [green]done[/green]")
+
+    console.print(f"  Filename:  {f.filename}")
+    console.print(f"  Type:      {f.content_type}")
+    console.print(f"  Size:      {_fmt_size(f.file_size)}")
+    console.print(f"  State:     {f.state or 'ready'}")
+    console.print(f"  URL:       [dim]{f.url}[/dim]")
+
+
+@app.command("upload-url")
+def upload_url(
+    url: str = typer.Argument(..., help="URL to download and upload"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for upload to complete"),
+):
+    """Upload a file from a URL."""
+    client = _get_client()
+    console.print(f"Uploading from URL...")
+    f = client.files.upload_url(url)
+    console.print(f"[green]Queued[/green]  ID: [bold]{f.id}[/bold]")
+
+    if wait and f.state == "processing":
+        console.print("Waiting for processing...", end="")
+        f = client.files.wait_ready(f.id)
+        console.print(f" [green]done[/green]")
+
+    console.print(f"  Filename:  {f.filename}")
+    console.print(f"  State:     {f.state or 'ready'}")
+
+
+@app.command("get")
+def get_file(
+    file_id: str = typer.Argument(..., help="File ID"),
+):
+    """Get file info and status."""
+    client = _get_client()
+    f = client.files.get(file_id)
+
+    table = Table(title=f"File {f.id[:12]}...")
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+
+    table.add_row("ID", f.id)
+    table.add_row("Filename", f.filename)
+    table.add_row("Type", f.content_type)
+    table.add_row("Size", _fmt_size(f.file_size))
+    table.add_row("State", f.state or "ready")
+    table.add_row("URL", f.url)
+    if f.error:
+        table.add_row("Error", f"[red]{f.error}[/red]")
+    if f.created_at:
+        table.add_row("Created", str(f.created_at))
+
+    console.print(table)
+
+
+@app.command("delete")
+def delete_file(
+    file_id: str = typer.Argument(..., help="File ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete an uploaded file."""
+    if not yes:
+        confirm = typer.confirm(f"Delete file {file_id[:12]}...?")
+        if not confirm:
+            raise typer.Abort()
+
+    client = _get_client()
+    client.files.delete(file_id)
+    console.print(f"[green]File {file_id[:12]}... deleted[/green]")

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/instances.py

@@ -11,6 +11,21 @@ def get_client() -> HyperCLI:
     return HyperCLI()
 
 
+def _parse_constraints(
+    constraints: Optional[list[str]],
+    cpu_vendor: Optional[str],
+) -> dict[str, str] | None:
+    parsed: dict[str, str] = {}
+    for item in constraints or []:
+        key, sep, value = item.partition("=")
+        if not sep or not key or not value:
+            raise typer.BadParameter(f"Invalid constraint '{item}', expected KEY=VALUE")
+        parsed[key.strip()] = value.strip()
+    if cpu_vendor:
+        parsed.setdefault("cpu_vendor", cpu_vendor.strip())
+    return parsed or None
+
+
 @app.command("list")
 def list_instances(
     gpu: Optional[str] = typer.Option(None, "--gpu", "-g", help="Filter by GPU type"),
@@ -64,7 +79,13 @@ def list_gpus(
 
     if fmt == "json":
         output({k: {"name": v.name, "description": v.description, "configs": [
-            {"gpu_count": c.gpu_count, "cpu_cores": c.cpu_cores, "memory_gb": c.memory_gb, "regions": c.regions}
+            {
+                "gpu_count": c.gpu_count,
+                "cpu_cores": c.cpu_cores,
+                "memory_gb": c.memory_gb,
+                "regions": c.regions,
+                "constraints": c.constraints,
+            }
             for c in v.configs
         ]} for k, v in types.items()}, "json")
     else:
@@ -187,6 +208,8 @@ def launch(
     gpu: str = typer.Option("l40s", "--gpu", "-g", help="GPU type"),
     count: int = typer.Option(1, "--count", "-n", help="Number of GPUs"),
     region: Optional[str] = typer.Option(None, "--region", "-r", help="Region code"),
+    constraint: Optional[list[str]] = typer.Option(None, "--constraint", help="Placement constraint KEY=VALUE (repeatable)"),
+    cpu_vendor: Optional[str] = typer.Option(None, "--cpu-vendor", help="CPU vendor constraint (e.g. intel, amd)"),
     runtime: Optional[int] = typer.Option(None, "--runtime", "-t", help="Runtime in seconds"),
     interruptible: bool = typer.Option(True, "--interruptible/--on-demand", help="Use interruptible instances"),
     env: Optional[list[str]] = typer.Option(None, "--env", "-e", help="Env vars (KEY=VALUE)"),
@@ -256,6 +279,8 @@ def launch(
     if command and any(op in command for op in ["&&", "||", "|", ";", ">", "<", "$"]):
         command = f'sh -c "{command}"'
 
+    constraints = _parse_constraints(constraint, cpu_vendor)
+
     follow_api_key = None
 
     if x402:
@@ -281,6 +306,7 @@ def launch(
                 gpu_type=gpu,
                 gpu_count=count,
                 region=region,
+                constraints=constraints,
                 interruptible=interruptible,
                 env=env_dict,
                 ports=ports_dict,
@@ -330,6 +356,7 @@ def launch(
                 gpu_type=gpu,
                 gpu_count=count,
                 region=region,
+                constraints=constraints,
                 runtime=runtime,
                 interruptible=interruptible,
                 env=env_dict,

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/jobs.py

@@ -44,17 +44,28 @@ def _resolve_job_id(client: HyperCLI, job_id: str) -> str:
 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"),
+    page: int = typer.Option(1, "--page", min=1, help="Page number (1-indexed)"),
+    page_size: int = typer.Option(50, "--page-size", min=1, max=100, help="Items per page (max 100)"),
     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, tags=tags)
+        result = client.jobs.list_page(state=state, tags=tags, page=page, page_size=page_size)
 
     if fmt == "json":
-        output(jobs, "json")
+        output(
+            {
+                "jobs": [job.__dict__ for job in result.jobs],
+                "total_count": result.total_count,
+                "page": result.page,
+                "page_size": result.page_size,
+            },
+            "json",
+        )
     else:
+        jobs = result.jobs
         if not jobs:
             console.print("[dim]No jobs found[/dim]")
             return
@@ -63,6 +74,11 @@ def list_jobs(
             "table",
             ["job_id", "state", "gpu_type", "gpu_count", "region", "time_left", "runtime", "hostname"],
         )
+        total_pages = max((result.total_count + result.page_size - 1) // result.page_size, 1)
+        console.print(
+            f"[dim]Page {result.page}/{total_pages} | "
+            f"{len(result.jobs)} shown | {result.total_count} total[/dim]"
+        )
 
 
 @app.command("get")

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/hypercli_cli/voice.py

@@ -18,10 +18,13 @@ DEFAULT_API_BASE = "https://api.hypercli.com"
 
 
 def _get_api_key(key: str | None) -> str:
-    """Resolve API key: --key flag > env HYPERCLAW_API_KEY > agent-key.json."""
+    """Resolve API key: --key > HYPER_API_KEY > HYPER_AGENTS_API_KEY > agent-key.json."""
     if key:
         return key
-    env_key = os.environ.get("HYPERCLAW_API_KEY", "").strip()
+    env_key = os.environ.get("HYPER_API_KEY", "").strip()
+    if env_key:
+        return env_key
+    env_key = os.environ.get("HYPER_AGENTS_API_KEY", "").strip()
     if env_key:
         return env_key
     if AGENT_KEY_PATH.exists():
@@ -30,15 +33,18 @@ def _get_api_key(key: str | None) -> str:
         if k:
             return k
     console.print("[red]❌ No API key found.[/red]")
-    console.print("Pass [bold]--key sk-...[/bold], set [bold]HYPERCLAW_API_KEY[/bold], or run [bold]hyper agent subscribe[/bold]")
+    console.print("Pass [bold]--key sk-...[/bold], set [bold]HYPER_API_KEY[/bold] or [bold]HYPER_AGENTS_API_KEY[/bold], or run [bold]hyper agent subscribe[/bold]")
     raise typer.Exit(1)
 
 
 def _resolve_api_base(base_url: str | None) -> str:
-    """Resolve API base: --base-url > HYPERCLAW_API_BASE env > default."""
+    """Resolve API base: --base-url > HYPER_API_BASE > HYPERCLI_API_URL > default."""
     if base_url:
         return base_url.rstrip("/")
-    env_base = os.environ.get("HYPERCLAW_API_BASE", "").strip()
+    env_base = os.environ.get("HYPER_API_BASE", "").strip()
+    if env_base:
+        return env_base.rstrip("/")
+    env_base = os.environ.get("HYPERCLI_API_URL", "").strip()
     if env_base:
         return env_base.rstrip("/")
     return DEFAULT_API_BASE

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "2026.3.18"
+version = "2026.3.25"
 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>=2026.3.18",
+    "hypercli-sdk>=2026.3.25",
     "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]>=2026.3.18",
+    "hypercli-sdk[comfyui]>=2026.3.25",
 ]
 wallet = [
     "x402[httpx,evm]>=2.0.0",
@@ -37,7 +37,7 @@ stt = [
     "faster-whisper>=1.1.0",
 ]
 all = [
-    "hypercli-sdk[comfyui]>=2026.3.18",
+    "hypercli-sdk[comfyui]>=2026.3.25",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-2026.3.25/tests/test_agent_env_resolution.py

@@ -0,0 +1,39 @@
+import importlib
+
+
+def test_agents_cli_prefers_agent_key_env(monkeypatch):
+    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+
+    import hypercli_cli.agents as agents
+
+    importlib.reload(agents)
+
+    assert agents._get_agent_api_key() == "sk-agent"
+
+
+def test_agents_cli_prefers_agent_base_env(monkeypatch):
+    monkeypatch.setenv("AGENTS_API_BASE_URL", "https://api.agents.dev.hypercli.com")
+    monkeypatch.setenv("AGENTS_WS_URL", "wss://api.agents.dev.hypercli.com/ws")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+
+    import hypercli_cli.agents as agents
+
+    importlib.reload(agents)
+
+    client = agents._get_deployments_client()
+    assert client._api_base == "https://api.dev.hypercli.com/agents"
+
+
+def test_voice_cli_prefers_product_envs(monkeypatch):
+    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+    monkeypatch.setenv("HYPER_API_BASE", "https://api.hypercli.com")
+    monkeypatch.setenv("HYPERCLI_API_URL", "https://api.dev.hypercli.com")
+
+    import hypercli_cli.voice as voice
+
+    importlib.reload(voice)
+
+    assert voice._get_api_key(None) == "sk-product"
+    assert voice._resolve_api_base(None) == "https://api.hypercli.com"

{hypercli_cli-2026.3.18 → hypercli_cli-2026.3.25}/tests/test_exec_shell_dryrun.py

@@ -98,6 +98,52 @@ def test_instances_launch_dry_run_mock(monkeypatch):
     assert "job-dryrun" in result.stdout
 
 
+def test_instances_launch_dry_run_includes_constraints(monkeypatch):
+    captured = {}
+
+    class FakeJobs:
+        def create(self, **kwargs):
+            captured.update(kwargs)
+            return SimpleNamespace(
+                job_id="job-dryrun",
+                state="validated",
+                gpu_type="h200",
+                gpu_count=8,
+                region="br",
+                constraints={"cpu_vendor": "amd"},
+                price_per_hour=12.34,
+                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",
+            "--gpu",
+            "h200",
+            "--count",
+            "8",
+            "--cpu-vendor",
+            "amd",
+            "--constraint",
+            "stack=prod",
+            "--output",
+            "json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert captured["constraints"] == {"cpu_vendor": "amd", "stack": "prod"}
+
+
 def test_agent_exec_command(monkeypatch):
     called = {}
 
@@ -126,3 +172,20 @@ def test_agent_shell_command(monkeypatch):
 
     assert result.exit_code == 0
     assert called["agent_id"] == "agent-xyz"
+
+
+def test_agents_cp_reports_directory_path_error(monkeypatch, tmp_path):
+    class FakeDeployments:
+        def cp_from(self, _pod, src_path, dst_path):
+            assert src_path == ".openclaw"
+            assert str(dst_path).endswith("download")
+            raise ValueError("Path is a directory: .openclaw. Use files_list(path) instead.")
+
+    monkeypatch.setattr("hypercli_cli.agents._get_deployments_client", lambda: FakeDeployments())
+    monkeypatch.setattr("hypercli_cli.agents._get_pod_with_token", lambda agent_id: SimpleNamespace(id=agent_id))
+
+    result = runner.invoke(app, ["agents", "cp", "agent-xyz:.openclaw", str(tmp_path / "download")])
+
+    assert result.exit_code == 1
+    assert "Path is a directory: .openclaw." in result.stdout
+    assert "Copy expects a file path, not a directory." in result.stdout

hypercli_cli-2026.3.25/tests/test_jobs_list_tags.py

@@ -0,0 +1,70 @@
+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_page(self, state=None, tags=None, page=None, page_size=None):
+            captured["state"] = state
+            captured["tags"] = tags
+            captured["page"] = page
+            captured["page_size"] = page_size
+            return SimpleNamespace(jobs=[], total_count=0, page=page, page_size=page_size)
+
+    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"},
+        "page": 1,
+        "page_size": 50,
+    }
+
+
+def test_jobs_list_passes_backend_pagination(monkeypatch):
+    captured = {}
+
+    class FakeJobs:
+        def list_page(self, state=None, tags=None, page=None, page_size=None):
+            captured["page"] = page
+            captured["page_size"] = page_size
+            return SimpleNamespace(jobs=[], total_count=0, page=page, page_size=page_size)
+
+    fake_client = SimpleNamespace(jobs=FakeJobs())
+    monkeypatch.setattr("hypercli_cli.jobs.get_client", lambda: fake_client)
+
+    result = runner.invoke(app, ["jobs", "list", "--page", "3", "--page-size", "25"])
+
+    assert result.exit_code == 0
+    assert captured == {"page": 3, "page_size": 25}
+
+
+def test_jobs_list_rejects_invalid_tag(monkeypatch):
+    fake_client = SimpleNamespace(
+        jobs=SimpleNamespace(
+            list_page=lambda state=None, tags=None, page=None, page_size=None: SimpleNamespace(
+                jobs=[], total_count=0, page=page, page_size=page_size
+            )
+        )
+    )
+    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-2026.3.18 → hypercli_cli-2026.3.25}/tests/test_openclaw_config.py

@@ -54,10 +54,10 @@ def test_config_openclaw_supports_placeholder_api_key_env():
             {"id": "qwen3-embedding-4b", "name": "Qwen3 Embedding 4B", "mode": "embedding"},
         ],
         "https://api.agents.hypercli.com",
-        placeholder_env="HYPER_AGENTS_API_KEY",
+        placeholder_env="HYPER_API_KEY",
     )
 
     providers = config["models"]["providers"]
-    assert providers["hyperclaw"]["apiKey"] == "${HYPER_AGENTS_API_KEY}"
-    assert providers["kimi-coding"]["apiKey"] == "${HYPER_AGENTS_API_KEY}"
-    assert config["agents"]["defaults"]["memorySearch"]["remote"]["apiKey"] == "${HYPER_AGENTS_API_KEY}"
+    assert providers["hyperclaw"]["apiKey"] == "${HYPER_API_KEY}"
+    assert providers["kimi-coding"]["apiKey"] == "${HYPER_API_KEY}"
+    assert config["agents"]["defaults"]["memorySearch"]["remote"]["apiKey"] == "${HYPER_API_KEY}"

hypercli_cli-2026.3.18/hypercli_cli/__init__.py

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

hypercli_cli-2026.3.18/tests/test_jobs_list_tags.py

@@ -1,39 +0,0 @@
-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