hypercli-cli 2026.4.5__tar.gz → 2026.4.6__tar.gz

{hypercli_cli-2026.4.5 → hypercli_cli-2026.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 2026.4.5
+Version: 2026.4.6
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -9,8 +9,9 @@ Author-email: HyperCLI <support@hypercli.com>
 License: MIT
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: hypercli-sdk>=2026.4.5
+Requires-Dist: hypercli-sdk>=2026.4.6
 Requires-Dist: mutagen>=1.47.0
+Requires-Dist: openai>=2.8.1
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=14.2.0
 Requires-Dist: typer>=0.20.0
@@ -19,11 +20,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.4.5; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.4.6; 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.4.5; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.4.6; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

hypercli_cli-2026.4.6/hypercli_cli/__init__.py

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

{hypercli_cli-2026.4.5 → hypercli_cli-2026.4.6}/hypercli_cli/agent.py

@@ -2,6 +2,8 @@
 import asyncio
 import json
 import os
+import shutil
+import subprocess
 from pathlib import Path
 from datetime import datetime, timedelta
 import typer
@@ -151,7 +153,7 @@ def subscribe(
         console.print(f"Limits: {result['tpm_limit']:,} TPM / {result['rpm_limit']:,} RPM")
         console.print(f"\n[green]✓[/green] Key saved to [bold]{AGENT_KEY_PATH}[/bold]")
         console.print(f"[green]✓[/green] Key history: [bold]{keys_history_path}[/bold]")
-        console.print("\nConfigure OpenClaw with: [bold]hyper agent openclaw-setup[/bold]")
+        console.print("\nConfigure OpenClaw with: [bold]hyper config openclaw --apply[/bold]")
 
 
 async def _subscribe_async(account, plan_id: str, api_base: str, amount: str = None):
@@ -538,7 +540,7 @@ def login(
     console.print(f"  Wallet:  {wallet_addr}")
     console.print(f"\n[green]You're all set![/green]")
     console.print(f"  Launch agent:   [bold]hyper agents create[/bold]")
-    console.print(f"  Configure:      [bold]hyper agent config openclaw --apply[/bold]")
+    console.print(f"  Configure:      [bold]hyper config openclaw --apply[/bold]")
 
 
 OPENCLAW_CONFIG_PATH = Path.home() / ".openclaw" / "openclaw.json"
@@ -734,15 +736,16 @@ def _config_openclaw(
     embedding_models = [m for m in supported_models if m.get("mode") == "embedding"]
     kimi_models = [m for m in chat_models if "kimi" in _model_suffix(m.get("id", ""))]
     glm_models = [m for m in chat_models if _model_suffix(m.get("id", "")) == "glm-5"]
-    openai_chat_models = [
+    other_chat_models = [
         m for m in chat_models
         if m not in kimi_models and m not in glm_models
     ]
+    provider_models = kimi_models + glm_models + other_chat_models
     embedding_model_id = embedding_models[0]["id"] if embedding_models else None
     primary_model = (
-        f"kimi-coding/{kimi_models[0]['id']}" if kimi_models else (
+        f"hyperclaw/{kimi_models[0]['id']}" if kimi_models else (
             f"hyperclaw/{glm_models[0]['id']}" if glm_models else (
-                f"hyperclaw-openai/{openai_chat_models[0]['id']}" if openai_chat_models else None
+                f"hyperclaw/{other_chat_models[0]['id']}" if other_chat_models else None
             )
         )
     )
@@ -756,46 +759,18 @@ def _config_openclaw(
                     "baseUrl": api_base,
                     "apiKey": config_api_key,
                     "api": "anthropic-messages",
-                    "models": glm_models,
-                },
-                **(
-                    {
-                        "kimi-coding": {
-                            # Use the upstream Kimi provider semantics while still
-                            # routing requests through the HyperClaw Anthropic proxy.
-                            "baseUrl": api_base,
-                            "apiKey": config_api_key,
-                            "api": "anthropic-messages",
-                            "headers": {
-                                "User-Agent": "claude-code/0.1.0",
-                            },
-                            "models": kimi_models,
-                        },
-                    }
-                    if kimi_models
-                    else {}
-                ),
-                **(
-                    {
-                        "hyperclaw-openai": {
-                            "baseUrl": f"{api_base}/v1",
-                            "apiKey": config_api_key,
-                            "api": "openai-completions",
-                            "models": openai_chat_models,
-                        },
-                    }
-                    if openai_chat_models
-                    else {}
-                ),
+                    "authHeader": True,
+                    "models": provider_models,
+                }
             }
         },
         "agents": {
             "defaults": {
                 **({"model": {"primary": primary_model}} if primary_model else {}),
                 "models": {
+                    **{f"hyperclaw/{m['id']}": {"alias": "kimi"} for m in kimi_models},
                     **{f"hyperclaw/{m['id']}": {"alias": "glm"} for m in glm_models},
-                    **{f"kimi-coding/{m['id']}": {"alias": "kimi"} for m in kimi_models},
-                    **{f"hyperclaw-openai/{m['id']}": {"alias": m['id'].split('-')[0]} for m in openai_chat_models},
+                    **{f"hyperclaw/{m['id']}": {"alias": m['id'].split('-')[0]} for m in other_chat_models},
                 },
                 **(
                     {
@@ -890,10 +865,10 @@ def config_cmd(
 
     Examples:
       hyper agent config                          # Show all configs
-      hyper agent config openclaw                 # OpenClaw snippet
+      hyper config openclaw                       # OpenClaw snippet
       hyper agent config opencode --key sk-...    # OpenCode with explicit key
-      hyper agent config openclaw --base-url https://api.dev.hypercli.com
-      hyper agent config openclaw --apply         # Write directly to openclaw.json
+      hyper config openclaw --base-url https://api.dev.hypercli.com
+      hyper config openclaw --apply               # Write directly to openclaw.json
       hyper agent config env                      # Shell export lines
     """
     api_key = _resolve_api_key(key)
@@ -937,8 +912,11 @@ def _show_snippet(name: str, path_hint: str, data: dict, apply: bool, target_pat
         if target_path.exists():
             with open(target_path) as f:
                 existing = json.load(f)
-            _deep_merge(existing, data)
-            merged = existing
+            if name == "OpenClaw":
+                merged = _merge_openclaw_config(existing, data)
+            else:
+                _deep_merge(existing, data)
+                merged = existing
         else:
             merged = data
 
@@ -947,6 +925,31 @@ def _show_snippet(name: str, path_hint: str, data: dict, apply: bool, target_pat
             json.dump(merged, f, indent=2)
             f.write("\n")
         console.print(f"[green]✅ Written to {target_path}[/green]\n")
+        if name == "OpenClaw":
+            _refresh_openclaw_runtime()
+
+
+def _refresh_openclaw_runtime():
+    """Best-effort refresh of OpenClaw generated runtime state after config changes."""
+    if shutil.which("openclaw") is None:
+        console.print("[yellow]⚠[/yellow] OpenClaw CLI not found in PATH.")
+        console.print("Run after install: [bold]openclaw models list[/bold]")
+        console.print("Then restart when ready: [bold]openclaw gateway restart[/bold]\n")
+        return
+
+    try:
+        subprocess.run(
+            ["openclaw", "models", "list"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=True,
+        )
+        console.print("[green]✓[/green] Regenerated OpenClaw model cache.")
+    except Exception:
+        console.print("[yellow]⚠[/yellow] Could not regenerate OpenClaw model cache automatically.")
+        console.print("Run manually: [bold]openclaw models list[/bold]")
+    console.print("Restart when ready: [bold]openclaw gateway restart[/bold]\n")
 
 
 def _deep_merge(base: dict, overlay: dict):
@@ -956,3 +959,28 @@ def _deep_merge(base: dict, overlay: dict):
             _deep_merge(base[k], v)
         else:
             base[k] = v
+
+
+def _merge_openclaw_config(existing: dict, snippet: dict) -> dict:
+    """Merge OpenClaw config while replacing generated provider/model sections exactly."""
+    merged = dict(existing)
+    _deep_merge(merged, snippet)
+
+    snippet_models = ((snippet.get("models") or {}).get("providers") or {})
+    if snippet_models:
+        merged.setdefault("models", {})
+        merged["models"]["providers"] = snippet_models
+
+    snippet_defaults = (((snippet.get("agents") or {}).get("defaults") or {}).get("models") or {})
+    if snippet_defaults:
+        merged.setdefault("agents", {})
+        merged["agents"].setdefault("defaults", {})
+        merged["agents"]["defaults"]["models"] = snippet_defaults
+
+    snippet_model_config = (((snippet.get("agents") or {}).get("defaults") or {}).get("model") or {})
+    if snippet_model_config:
+        merged.setdefault("agents", {})
+        merged["agents"].setdefault("defaults", {})
+        merged["agents"]["defaults"]["model"] = snippet_model_config
+
+    return merged

{hypercli_cli-2026.4.5 → hypercli_cli-2026.4.6}/hypercli_cli/cli.py

@@ -4,11 +4,12 @@ import json
 import typer
 from rich.console import Console
 from rich.prompt import Prompt
+from rich.table import Table
 
 from hypercli import HyperCLI, APIError, configure
 from hypercli.config import CONFIG_FILE
 
-from . import agent, agents, billing, comfyui, files, flow, instances, jobs, keys, user, wallet
+from . import agent, agents, billing, comfyui, files, flow, instances, jobs, keys, llm, user, wallet
 from .output import output, spinner
 
 console = Console()
@@ -56,10 +57,16 @@ app = typer.Typer(
     no_args_is_help=True,
     rich_markup_mode="rich",
 )
+config_app = typer.Typer(
+    help="Generate config for OpenClaw and other tools",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
 
 # Register subcommands
 app.add_typer(agents.app, name="agents")
 app.add_typer(agent.app, name="agent")
+app.add_typer(config_app, name="config")
 app.add_typer(billing.app, name="billing")
 app.add_typer(comfyui.app, name="comfyui")
 app.add_typer(files.app, name="files")
@@ -67,10 +74,30 @@ app.add_typer(flow.app, name="flow")
 app.add_typer(instances.app, name="instances")
 app.add_typer(keys.app, name="keys")
 app.add_typer(jobs.app, name="jobs")
+app.add_typer(llm.app, name="llm")
 app.add_typer(user.app, name="user")
 app.add_typer(wallet.app, name="wallet")
 
 
+@config_app.command("openclaw")
+def config_openclaw_cmd(
+    key: str = typer.Option(None, "--key", "-k", help="API key. Falls back to ~/.hypercli/agent-key.json"),
+    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 directly to ~/.openclaw/openclaw.json"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+):
+    """Generate or apply OpenClaw config."""
+    agent.config_cmd(
+        format="openclaw",
+        key=key,
+        base_url=base_url,
+        placeholder_env=placeholder_env,
+        apply=apply,
+        dev=dev,
+    )
+
+
 @app.command("me")
 def me_cmd(
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
@@ -79,7 +106,27 @@ def me_cmd(
     client = HyperCLI()
     with spinner("Resolving auth context..."):
         auth_me = client.user.auth_me()
-    output(auth_me, fmt)
+    if fmt == "json":
+        output(auth_me, fmt)
+        return
+
+    table = Table(show_header=False, box=None)
+    table.add_column("Key", style="bold cyan")
+    table.add_column("Value")
+    table.add_row("user_id", auth_me.user_id)
+    table.add_row("orchestra_user_id", str(auth_me.orchestra_user_id or ""))
+    table.add_row("team_id", auth_me.team_id)
+    table.add_row("plan_id", auth_me.plan_id)
+    table.add_row("email", str(auth_me.email or ""))
+    table.add_row("auth_type", auth_me.auth_type)
+    has_active_subscription = bool(getattr(auth_me, "has_active_subscription", False))
+    table.add_row("has_active_subscription", "yes" if has_active_subscription else "no")
+    table.add_row("key_id", str(getattr(auth_me, "key_id", None) or ""))
+    table.add_row("key_name", str(getattr(auth_me, "key_name", None) or ""))
+    raw_capabilities = list(getattr(auth_me, "capabilities", []) or [])
+    capabilities = "\n".join(raw_capabilities) if raw_capabilities else ""
+    table.add_row("capabilities", capabilities)
+    console.print(table)
 
 
 @app.command("configure")

{hypercli_cli-2026.4.5 → hypercli_cli-2026.4.6}/hypercli_cli/flow.py

@@ -1,16 +1,13 @@
 """hyper flow commands - simplified flow interfaces"""
-import json
 import math
-from datetime import datetime, timezone
 from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
 import typer
 from pathlib import Path
 from typing import Any, Optional, List
+from urllib.parse import urlparse
 
 from hypercli import HyperCLI, X402Client
-from .output import output, console, spinner
-
-X402_RENDERS_FILE = Path.home() / ".hypercli" / "x402_renders.jsonl"
+from .output import output, console, spinner, success
 
 HUMO_FPS = 25  # HuMo video_humo template frame rate
 USDC_ATOMIC_UNITS = Decimal("1000000")
@@ -23,6 +20,16 @@ def get_client() -> HyperCLI:
     return HyperCLI()
 
 
+def _get_flow_client(x402: bool = False) -> HyperCLI:
+    if not x402:
+        return get_client()
+
+    from .wallet import get_wallet_auth_token, require_wallet_deps
+
+    require_wallet_deps()
+    return HyperCLI(api_key=get_wallet_auth_token())
+
+
 def get_audio_duration(file_path: str) -> float | None:
     """Get audio duration in seconds using mutagen. Returns None on failure."""
     try:
@@ -56,32 +63,13 @@ def _usd_to_atomic(amount_usd: float) -> int:
     return int((usd * USDC_ATOMIC_UNITS).to_integral_value(rounding=ROUND_HALF_UP))
 
 
-def _save_x402_render(flow_type: str, amount: float, x402_result) -> None:
-    """Append x402 render info to ~/.hypercli/x402_renders.jsonl"""
-    try:
-        X402_RENDERS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        entry = {
-            "ts": datetime.now(timezone.utc).isoformat(),
-            "flow_type": flow_type,
-            "render_id": x402_result.render.render_id,
-            "amount_usd": amount,
-            "access_key": x402_result.access_key,
-            "status_url": x402_result.status_url,
-            "cancel_url": x402_result.cancel_url,
-        }
-        with open(X402_RENDERS_FILE, "a") as f:
-            f.write(json.dumps(entry) + "\n")
-    except Exception:
-        pass  # best-effort, don't break the flow
-
-
 def _create_flow_render(
     flow_type: str,
     payload: dict[str, Any],
     x402: bool,
     amount: Optional[float],
 ):
-    """Create a flow render either via account billing or x402."""
+    """Create a flow render via subscription/account billing unless --x402 is explicit."""
     clean_payload = {k: v for k, v in payload.items() if v is not None}
 
     if x402:
@@ -113,7 +101,6 @@ def _create_flow_render(
                 params=clean_payload,
                 notify_url=notify_url,
             )
-        _save_x402_render(flow_type, amount, x402_result)
         return x402_result.render, x402_result
 
     with spinner("Creating render..."):
@@ -150,6 +137,61 @@ def print_render_result(render, fmt: str, x402_result=None):
         console.print(f"  Cancel URL: {x402_result.cancel_url}")
 
 
+def _watch_flow_status(client: HyperCLI, render_id: str, poll_interval: float = 2.0):
+    """Watch flow render status live."""
+    import time
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.table import Table
+
+    def render_status_panel(status, render=None):
+        table = Table(show_header=False, box=None)
+        table.add_column("Key", style="cyan")
+        table.add_column("Value")
+        table.add_row("ID", status.render_id)
+        table.add_row("State", status.state)
+        if status.progress is not None:
+            table.add_row("Progress", f"{status.progress:.0%}")
+        if render and render.result_url:
+            table.add_row("Result", render.result_url)
+        if render and render.error:
+            table.add_row("Error", render.error)
+        return Panel(table, title="[bold]Flow Status[/bold]")
+
+    with Live(console=console, refresh_per_second=2) as live:
+        while True:
+            status = client.renders.status(render_id)
+            render = None
+            if status.state in ("completed", "failed", "cancelled"):
+                render = client.renders.get(render_id)
+                live.update(render_status_panel(status, render))
+                break
+            live.update(render_status_panel(status))
+            time.sleep(poll_interval)
+
+
+def _download_flow_result(render, destination: Path) -> Path:
+    import httpx
+
+    if not render.result_url:
+        raise typer.BadParameter("Render has no result URL to download yet.")
+
+    target = destination.expanduser()
+    if target.is_dir():
+        parsed = urlparse(render.result_url)
+        filename = Path(parsed.path).name or f"{render.render_id}.bin"
+        target = target / filename
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    with httpx.stream("GET", render.result_url, follow_redirects=True, timeout=60) as response:
+        response.raise_for_status()
+        with target.open("wb") as handle:
+            for chunk in response.iter_bytes():
+                handle.write(chunk)
+
+    return target
+
+
 # =============================================================================
 # Common option definitions
 # =============================================================================
@@ -163,76 +205,112 @@ OPT_AMOUNT = typer.Option(None, "--amount", help="USDC amount to spend with --x4
 OPT_FMT = typer.Option("table", "--output", "-o", help="Output format: table|json")
 
 
-@app.command("renders")
-def list_renders(
-    limit: int = typer.Option(10, "--limit", "-n", help="Number of recent renders to show"),
-    check: bool = typer.Option(False, "--check", "-c", help="Check current status of each render"),
+@app.command("history")
+def flow_history(
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of recent runs to show"),
+    state: Optional[str] = typer.Option(None, "--state", "-s", help="Filter by state"),
+    template: Optional[str] = typer.Option(None, "--template", "-t", help="Filter by template"),
+    type: Optional[str] = typer.Option(None, "--type", help="Filter by render type"),
+    x402: bool = typer.Option(False, "--x402", help="Use the local wallet's backend x402 user context."),
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
 ):
-    """List saved x402 render history from ~/.hypercli/x402_renders.jsonl"""
-    if not X402_RENDERS_FILE.exists():
-        console.print("[dim]No x402 renders recorded yet.[/dim]")
-        raise typer.Exit(0)
-
-    entries = []
-    with open(X402_RENDERS_FILE) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                try:
-                    entries.append(json.loads(line))
-                except json.JSONDecodeError:
-                    pass
-
-    if not entries:
-        console.print("[dim]No x402 renders recorded yet.[/dim]")
-        raise typer.Exit(0)
-
-    entries = entries[-limit:]
-
-    if check:
-        import httpx
-        for entry in entries:
-            access_key = entry.get("access_key", "")
-            status_path = entry.get("status_url", "")
-            if access_key and status_path:
-                try:
-                    url = f"https://api.hypercli.com/api{status_path}" if status_path.startswith("/flow") else f"https://api.hypercli.com{status_path}"
-                    resp = httpx.get(url, headers={"Authorization": f"Bearer {access_key}"}, timeout=10)
-                    if resp.status_code == 200:
-                        data = resp.json()
-                        entry["live_state"] = data.get("state", "?")
-                        entry["result_url"] = data.get("result_url")
-                        entry["error"] = data.get("error")
-                except Exception:
-                    entry["live_state"] = "error"
+    """List recent flow renders from the remote render API."""
+    client = _get_flow_client(x402=x402)
+    with spinner("Fetching flow history..."):
+        renders = client.renders.list(state=state, template=template, type=type)
+
+    renders = renders[:limit]
 
     if fmt == "json":
-        output(entries, "json")
+        output(renders, "json")
         return
 
-    from rich.table import Table
-    table = Table(title="x402 Renders")
-    table.add_column("Time", style="dim")
-    table.add_column("Flow")
-    table.add_column("Render ID", style="cyan")
-    table.add_column("USD", justify="right")
-    if check:
-        table.add_column("State")
-        table.add_column("Result")
-
-    for e in entries:
-        ts = e.get("ts", "?")[:19].replace("T", " ")
-        row = [ts, e.get("flow_type", "?"), e.get("render_id", "?")[:13] + "…", f"${e.get('amount_usd', 0):.2f}"]
-        if check:
-            state = e.get("live_state", "?")
-            style = "green" if state == "completed" else "red" if state == "failed" else "yellow"
-            row.append(f"[{style}]{state}[/{style}]")
-            result = e.get("result_url") or e.get("error") or ""
-            row.append(result[:60] if result else "")
-        table.add_row(*row)
-
-    console.print(table)
+    if not renders:
+        console.print("[dim]No flow renders found[/dim]")
+        return
+
+    output(renders, "table", ["render_id", "state", "template", "render_type", "created_at"])
+
+@app.command("list")
+def flow_list(
+    state: Optional[str] = typer.Option(None, "--state", "-s", help="Filter by state"),
+    template: Optional[str] = typer.Option(None, "--template", "-t", help="Filter by template"),
+    type: Optional[str] = typer.Option(None, "--type", help="Filter by render type"),
+    x402: bool = typer.Option(False, "--x402", help="Use the local wallet's backend x402 user context."),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List flow renders available to the current auth context."""
+    client = _get_flow_client(x402=x402)
+    with spinner("Fetching flow renders..."):
+        renders = client.renders.list(state=state, template=template, type=type)
+
+    if fmt == "json":
+        output(renders, "json")
+        return
+
+    if not renders:
+        console.print("[dim]No flow renders found[/dim]")
+        return
+
+    output(renders, "table", ["render_id", "state", "template", "render_type", "created_at"])
+
+
+@app.command("get")
+def flow_get(
+    render_id: str = typer.Argument(..., help="Flow render ID"),
+    output_path: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Write completed render output to file. Legacy: `-o json` or `-o table`.",
+    ),
+    x402: bool = typer.Option(False, "--x402", help="Use the local wallet's backend x402 user context."),
+    fmt: str = typer.Option("table", "--format", "-f", help="Output format: table|json"),
+):
+    """Get flow render details."""
+    client = _get_flow_client(x402=x402)
+    with spinner("Fetching flow render..."):
+        render = client.renders.get(render_id)
+
+    if output_path in {"json", "table"} and fmt == "table":
+        fmt = output_path
+        output_path = None
+
+    if output_path:
+        saved = _download_flow_result(render, Path(output_path))
+        success(f"Saved flow output to {saved}")
+        return
+
+    output(render, fmt)
+
+
+@app.command("status")
+def flow_status(
+    render_id: str = typer.Argument(..., help="Flow render ID"),
+    watch: bool = typer.Option(False, "--watch", "-w", help="Watch status live"),
+    x402: bool = typer.Option(False, "--x402", help="Use the local wallet's backend x402 user context."),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get flow render status."""
+    client = _get_flow_client(x402=x402)
+    if watch:
+        _watch_flow_status(client, render_id)
+        return
+    with spinner("Fetching flow status..."):
+        status = client.renders.status(render_id)
+    output(status, fmt)
+
+
+@app.command("cancel")
+def flow_cancel(
+    render_id: str = typer.Argument(..., help="Flow render ID"),
+    x402: bool = typer.Option(False, "--x402", help="Use the local wallet's backend x402 user context."),
+):
+    """Cancel a flow render."""
+    client = _get_flow_client(x402=x402)
+    with spinner("Cancelling flow render..."):
+        client.renders.cancel(render_id)
+    success(f"Flow render {render_id} cancelled")
 
 
 @app.command("text-to-image")