hypercli-cli 0.8.13__tar.gz → 0.9.0__tar.gz

{hypercli_cli-0.8.13 → hypercli_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 0.8.13
+Version: 0.9.0
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com

hypercli_cli-0.9.0/hypercli_cli/agents.py

@@ -0,0 +1,559 @@
+"""HyperClaw Agents — Reef Pod Management CLI"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from hypercli.agents import Agents, ReefPod
+
+app = typer.Typer(help="Manage OpenClaw agent pods (reef containers)")
+console = Console()
+
+# Config — uses HyperClaw API key (sk-...) for backend auth
+CLAW_KEY_PATH = Path.home() / ".hypercli" / "claw-key.json"
+STATE_DIR = Path.home() / ".hypercli"
+AGENTS_STATE = STATE_DIR / "agents.json"
+
+
+def _get_claw_api_key() -> str:
+    """Resolve HyperClaw API key from env or saved key file."""
+    key = os.environ.get("HYPERCLAW_API_KEY", "")
+    if key:
+        return key
+    if CLAW_KEY_PATH.exists():
+        with open(CLAW_KEY_PATH) as f:
+            data = json.load(f)
+        key = data.get("key", "")
+        if key:
+            return key
+    console.print("[red]❌ No HyperClaw API key found.[/red]")
+    console.print("Set HYPERCLAW_API_KEY or subscribe: [bold]hyper claw subscribe 1aiu[/bold]")
+    raise typer.Exit(1)
+
+
+def _get_agents_client() -> Agents:
+    """Create an Agents client using the HyperClaw API key."""
+    from hypercli.http import HTTPClient
+    api_key = _get_claw_api_key()
+    api_base = os.environ.get("HYPERCLAW_API_BASE", "https://api.hyperclaw.app")
+    http = HTTPClient(api_base, api_key)
+    return Agents(http, claw_api_key=api_key, claw_api_base=api_base)
+
+
+def _save_pod_state(pod: ReefPod):
+    """Save pod info locally for quick reference."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state = _load_state()
+    state[pod.id] = {
+        "id": pod.id,
+        "pod_id": pod.pod_id,
+        "pod_name": pod.pod_name,
+        "user_id": pod.user_id,
+        "hostname": pod.hostname,
+        "jwt_token": pod.jwt_token,
+        "state": pod.state,
+    }
+    with open(AGENTS_STATE, "w") as f:
+        json.dump(state, f, indent=2, default=str)
+
+
+def _load_state() -> dict:
+    if AGENTS_STATE.exists():
+        with open(AGENTS_STATE) as f:
+            return json.load(f)
+    return {}
+
+
+def _remove_pod_state(agent_id: str):
+    state = _load_state()
+    state.pop(agent_id, None)
+    with open(AGENTS_STATE, "w") as f:
+        json.dump(state, f, indent=2, default=str)
+
+
+def _resolve_agent(agent_id: str) -> str:
+    """Resolve agent_id with prefix matching from local state."""
+    state = _load_state()
+    if agent_id in state:
+        return agent_id
+    matches = [k for k in state if k.startswith(agent_id)]
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        console.print(f"[yellow]Ambiguous ID prefix '{agent_id}'. Matches:[/yellow]")
+        for m in matches:
+            s = state[m]
+            console.print(f"  {m[:12]}  {s.get('pod_name', '')}  {s.get('state', '')}")
+        raise typer.Exit(1)
+    return agent_id
+
+
+def _get_pod_with_token(agent_id: str) -> ReefPod:
+    """Get a ReefPod, filling JWT from local state if needed."""
+    agents = _get_agents_client()
+    pod = agents.get(agent_id)
+    if not pod.jwt_token:
+        state = _load_state()
+        local = state.get(agent_id, {})
+        if local.get("jwt_token"):
+            pod.jwt_token = local["jwt_token"]
+    return pod
+
+
+@app.command("create")
+def create(
+    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()
+
+    console.print("\n[bold]Creating agent pod...[/bold]")
+
+    try:
+        pod = agents.create()
+    except Exception as e:
+        console.print(f"[red]❌ Create failed: {e}[/red]")
+        raise typer.Exit(1)
+
+    _save_pod_state(pod)
+
+    console.print(f"[green]✓[/green] Agent created: [bold]{pod.id[:12]}[/bold]")
+    console.print(f"  Pod:      {pod.pod_name}")
+    console.print(f"  State:    {pod.state}")
+    console.print(f"  Desktop:  {pod.vnc_url}")
+    console.print(f"  Shell:    {pod.shell_url}")
+
+    if wait:
+        console.print("\n[dim]Waiting for pod to start...[/dim]")
+        for i in range(60):
+            time.sleep(5)
+            try:
+                pod = agents.get(pod.id)
+                _save_pod_state(pod)
+                if pod.is_running:
+                    console.print(f"[green]✅ Agent is running![/green]")
+                    break
+                elif pod.state in ("failed", "stopped"):
+                    console.print(f"[red]❌ Agent failed: {pod.state}[/red]")
+                    if pod.last_error:
+                        console.print(f"  Error: {pod.last_error}")
+                    raise typer.Exit(1)
+                else:
+                    console.print(f"  [{i*5}s] State: {pod.state}")
+            except typer.Exit:
+                raise
+            except Exception as e:
+                console.print(f"  [{i*5}s] Checking... ({e})")
+        else:
+            console.print("[yellow]⚠ Timed out (5 min). Pod may still be starting.[/yellow]")
+
+    console.print(f"\nExec:    [bold]hyper agents exec {pod.id[:8]} 'echo hello'[/bold]")
+    console.print(f"Shell:   [bold]hyper agents shell {pod.id[:8]}[/bold]")
+    console.print(f"Desktop: {pod.vnc_url}")
+
+
+@app.command("list")
+def list_agents(
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+):
+    """List all agent pods."""
+    agents = _get_agents_client()
+
+    try:
+        pods = agents.list()
+    except Exception as e:
+        console.print(f"[red]❌ Failed to list agents: {e}[/red]")
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print_json(json.dumps([{
+            "id": p.id, "pod_name": p.pod_name, "state": p.state,
+            "hostname": p.hostname, "vnc_url": p.vnc_url,
+        } for p in pods], indent=2, default=str))
+        return
+
+    if not pods:
+        console.print("[dim]No agents found.[/dim]")
+        console.print("Create one: [bold]hyper agents create[/bold]")
+        return
+
+    table = Table(title="Agents")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Pod", style="blue")
+    table.add_column("State")
+    table.add_column("Desktop URL")
+    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 ""
+        table.add_row(
+            pod.id[:12],
+            pod.pod_name or "",
+            f"[{style}]{pod.state}[/{style}]",
+            pod.vnc_url or "",
+            created,
+        )
+        _save_pod_state(pod)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+@app.command("status")
+def status(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+):
+    """Get detailed status of an agent."""
+    agent_id = _resolve_agent(agent_id)
+    agents = _get_agents_client()
+
+    try:
+        pod = agents.get(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    _save_pod_state(pod)
+
+    console.print(f"\n[bold]Agent {pod.id[:12]}[/bold]")
+    console.print(f"  Pod:        {pod.pod_name}")
+    console.print(f"  State:      {pod.state}")
+    console.print(f"  Desktop:    {pod.vnc_url}")
+    console.print(f"  Shell:      {pod.shell_url}")
+    console.print(f"  Created:    {pod.created_at}")
+    if pod.started_at:
+        console.print(f"  Started:    {pod.started_at}")
+    if pod.stopped_at:
+        console.print(f"  Stopped:    {pod.stopped_at}")
+    if pod.jwt_expires_at:
+        console.print(f"  JWT Expires: {pod.jwt_expires_at}")
+    if pod.last_error:
+        console.print(f"  Error:      [red]{pod.last_error}[/red]")
+
+    if pod.is_running and pod.executor_url:
+        try:
+            health = agents.health(pod)
+            console.print(f"\n[bold]Executor:[/bold]")
+            console.print(f"  Status:    {health.get('status', 'unknown')}")
+            console.print(f"  Disk Free: {health.get('disk_free_mb', '?')} MB")
+        except Exception as e:
+            console.print(f"\n[dim]Executor not reachable: {e}[/dim]")
+
+
+@app.command("start")
+def start(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+):
+    """Start a previously stopped agent."""
+    agent_id = _resolve_agent(agent_id)
+    agents = _get_agents_client()
+
+    try:
+        pod = agents.start(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to start agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    _save_pod_state(pod)
+    console.print(f"[green]✓[/green] Agent starting: {pod.pod_name}")
+    console.print(f"  Desktop: {pod.vnc_url}")
+
+
+@app.command("stop")
+def stop(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Stop an agent (keeps DB record, destroys pod)."""
+    agent_id = _resolve_agent(agent_id)
+
+    if not force:
+        confirm = typer.confirm(f"Stop agent {agent_id[:12]}?")
+        if not confirm:
+            raise typer.Exit(0)
+
+    agents = _get_agents_client()
+
+    try:
+        pod = agents.stop(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to stop agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    _save_pod_state(pod)
+    console.print(f"[green]✅ Agent stopped[/green]")
+    console.print(f"Restart with: [bold]hyper agents start {agent_id[:8]}[/bold]")
+
+
+@app.command("delete")
+def delete(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete an agent entirely (pod + record)."""
+    agent_id = _resolve_agent(agent_id)
+
+    if not force:
+        confirm = typer.confirm(f"Permanently delete agent {agent_id[:12]}?")
+        if not confirm:
+            raise typer.Exit(0)
+
+    agents = _get_agents_client()
+
+    try:
+        agents.delete(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to delete agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    _remove_pod_state(agent_id)
+    console.print(f"[green]✅ Agent {agent_id[:12]} deleted[/green]")
+
+
+@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 an agent pod."""
+    agent_id = _resolve_agent(agent_id)
+
+    try:
+        pod = _get_pod_with_token(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    agents = _get_agents_client()
+
+    try:
+        result = agents.exec(pod, command, timeout=timeout)
+    except Exception as e:
+        console.print(f"[red]❌ Exec failed: {e}[/red]")
+        raise typer.Exit(1)
+
+    if result.stdout:
+        sys.stdout.write(result.stdout)
+        if not result.stdout.endswith("\n"):
+            sys.stdout.write("\n")
+    if result.stderr:
+        sys.stderr.write(result.stderr)
+        if not result.stderr.endswith("\n"):
+            sys.stderr.write("\n")
+
+    raise typer.Exit(result.exit_code)
+
+
+@app.command("shell")
+def shell(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+):
+    """Open an interactive shell on an agent pod (WebSocket PTY).
+
+    Connects to the executor's /shell endpoint. Press Ctrl+] to disconnect.
+    """
+    agent_id = _resolve_agent(agent_id)
+
+    try:
+        pod = _get_pod_with_token(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not pod.executor_url:
+        console.print("[red]❌ Agent has no executor URL[/red]")
+        raise typer.Exit(1)
+
+    ws_url = pod.executor_url.replace("https://", "wss://").replace("http://", "ws://")
+    ws_url = f"{ws_url}/shell"
+
+    console.print(f"[dim]Connecting to {ws_url}...[/dim]")
+
+    try:
+        import websockets
+        import asyncio
+        import termios
+        import tty
+    except ImportError:
+        console.print("[red]❌ 'websockets' required: pip install websockets[/red]")
+        raise typer.Exit(1)
+
+    async def _run_shell():
+        headers = {}
+        if pod.jwt_token:
+            headers["Authorization"] = f"Bearer {pod.jwt_token}"
+            headers["Cookie"] = f"{pod.pod_name}-token={pod.jwt_token}"
+
+        async with websockets.connect(ws_url, additional_headers=headers) as ws:
+            console.print("[green]Connected.[/green] Ctrl+] to disconnect.\n")
+
+            old_settings = termios.tcgetattr(sys.stdin)
+            try:
+                tty.setraw(sys.stdin.fileno())
+
+                import shutil
+                cols, rows = shutil.get_terminal_size()
+                await ws.send(f"\x1b[8;{rows};{cols}t")
+
+                async def read_ws():
+                    try:
+                        async for msg in ws:
+                            if isinstance(msg, str):
+                                sys.stdout.write(msg)
+                                sys.stdout.flush()
+                            elif isinstance(msg, bytes):
+                                sys.stdout.buffer.write(msg)
+                                sys.stdout.buffer.flush()
+                    except websockets.ConnectionClosed:
+                        pass
+
+                async def read_stdin():
+                    loop = asyncio.get_event_loop()
+                    try:
+                        while True:
+                            data = await loop.run_in_executor(None, lambda: os.read(sys.stdin.fileno(), 1024))
+                            if not data:
+                                break
+                            if b"\x1d" in data:
+                                break
+                            await ws.send(data.decode(errors="replace"))
+                    except (websockets.ConnectionClosed, OSError):
+                        pass
+
+                done, pending = await asyncio.wait(
+                    [asyncio.create_task(read_ws()), asyncio.create_task(read_stdin())],
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for t in pending:
+                    t.cancel()
+            finally:
+                termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+                console.print("\n[dim]Disconnected.[/dim]")
+
+    try:
+        asyncio.run(_run_shell())
+    except KeyboardInterrupt:
+        console.print("\n[dim]Disconnected.[/dim]")
+    except Exception as e:
+        console.print(f"[red]❌ Shell failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("logs")
+def logs(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+    lines: int = typer.Option(100, "-n", "--lines", help="Number of lines to show"),
+    follow: bool = typer.Option(True, "-f/--no-follow", help="Follow log output"),
+):
+    """Stream logs from an agent pod."""
+    agent_id = _resolve_agent(agent_id)
+
+    try:
+        pod = _get_pod_with_token(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    agents = _get_agents_client()
+
+    try:
+        for line in agents.logs_stream(pod, lines=lines, follow=follow):
+            console.print(line)
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        console.print(f"[red]❌ Logs failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("chat")
+def chat(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+    model: str = typer.Option("hyperclaw/kimi-k2.5", "--model", "-m", help="Model to use"),
+):
+    """Interactive chat with an agent's OpenClaw instance.
+
+    Connects to the OpenClaw gateway running inside the agent pod.
+    Type your messages, get streaming responses. Ctrl+C or 'exit' to quit.
+    """
+    agent_id = _resolve_agent(agent_id)
+
+    try:
+        pod = _get_pod_with_token(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to get agent: {e}[/red]")
+        raise typer.Exit(1)
+
+    agents = _get_agents_client()
+    messages = []
+
+    console.print(f"\n[bold]Chat with agent {pod.pod_name}[/bold] (model: {model})")
+    console.print("[dim]Type your message. 'exit' or Ctrl+C to quit.[/dim]\n")
+
+    while True:
+        try:
+            user_input = console.input("[bold cyan]> [/bold cyan]")
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Bye.[/dim]")
+            break
+
+        user_input = user_input.strip()
+        if not user_input:
+            continue
+        if user_input.lower() in ("exit", "quit", "/exit", "/quit"):
+            console.print("[dim]Bye.[/dim]")
+            break
+
+        messages.append({"role": "user", "content": user_input})
+
+        try:
+            full_response = ""
+            for chunk in agents.chat_stream(pod, messages, model=model):
+                sys.stdout.write(chunk)
+                sys.stdout.flush()
+                full_response += chunk
+            sys.stdout.write("\n\n")
+            sys.stdout.flush()
+
+            messages.append({"role": "assistant", "content": full_response})
+        except KeyboardInterrupt:
+            sys.stdout.write("\n")
+            continue
+        except Exception as e:
+            console.print(f"\n[red]Error: {e}[/red]\n")
+            # Remove failed user message
+            messages.pop()
+
+
+@app.command("token")
+def token(
+    agent_id: str = typer.Argument(..., help="Agent ID (or prefix)"),
+):
+    """Refresh the JWT token for an agent."""
+    agent_id = _resolve_agent(agent_id)
+    agents = _get_agents_client()
+
+    try:
+        result = agents.refresh_token(agent_id)
+    except Exception as e:
+        console.print(f"[red]❌ Failed to refresh token: {e}[/red]")
+        raise typer.Exit(1)
+
+    state = _load_state()
+    if agent_id in state:
+        state[agent_id]["jwt_token"] = result.get("token", "")
+        with open(AGENTS_STATE, "w") as f:
+            json.dump(state, f, indent=2, default=str)
+
+    console.print(f"[green]✅ Token refreshed[/green]")
+    console.print(f"  Expires: {result.get('expires_at', 'unknown')}")

{hypercli_cli-0.8.13 → hypercli_cli-0.9.0}/hypercli_cli/claw.py

@@ -8,12 +8,14 @@ from rich.console import Console
 from rich.table import Table
 
 from .onboard import onboard as _onboard_fn
+from .voice import app as voice_app
 
 app = typer.Typer(help="HyperClaw inference commands")
 console = Console()
 
-# Register onboard as a subcommand
+# Register subcommands
 app.command("onboard")(_onboard_fn)
+app.add_typer(voice_app, name="voice")
 
 # Check if wallet dependencies are available
 try:
@@ -194,7 +196,19 @@ async def _subscribe_async(account, plan_id: str, api_base: str, amount: str = N
             payment_headers = http_client.encode_payment_signature_header(payment_payload)
             console.print(f"[green]✓[/green] Payment signed")
             
-            # Step 6: Retry with payment
+            # Step 6: Retry with payment (include JWT if available from claw login)
+            jwt_path = HYPERCLI_DIR / "claw-jwt.json"
+            if jwt_path.exists():
+                try:
+                    with open(jwt_path) as f:
+                        jwt_data = json.load(f)
+                    jwt_token = jwt_data.get("token", "")
+                    if jwt_token:
+                        payment_headers["Authorization"] = f"Bearer {jwt_token}"
+                        console.print("[green]✓[/green] Attaching user auth (from claw login)")
+                except Exception:
+                    pass
+
             console.print("[bold]Sending payment...[/bold]")
             retry_response = await http.post(url, headers=payment_headers)
             
@@ -355,6 +369,134 @@ def models(
     console.print(f"Source: {url}")
 
 
+@app.command("login")
+def login(
+    api_url: str = typer.Option(None, "--api-url", help="API base URL override"),
+):
+    """Login to HyperClaw with your wallet.
+
+    Signs a challenge message with your wallet key to authenticate,
+    then creates a user-bound API key for agent management.
+
+    Prerequisite: hyper wallet create (if you don't have a wallet yet)
+
+    Flow:
+      1. Signs a challenge with your wallet private key
+      2. Backend verifies signature, creates/finds your user
+      3. Creates an API key bound to your user account
+      4. Saves the key to ~/.hypercli/claw-key.json
+
+    After login, you can use:
+      hyper agents create    Launch an OpenClaw agent pod
+      hyper agents list      List your agents
+      hyper claw config      Generate provider configs
+    """
+    try:
+        from eth_account.messages import encode_defunct
+        from eth_account import Account
+    except ImportError:
+        console.print("[red]❌ Wallet dependencies required[/red]")
+        console.print("Install with: [bold]pip install 'hypercli-cli[wallet]'[/bold]")
+        raise typer.Exit(1)
+
+    import httpx
+
+    # Import wallet loader from wallet module
+    from .wallet import load_wallet
+
+    base_url = (api_url or PROD_API_BASE).rstrip("/")
+
+    # Step 1: Load wallet
+    account = load_wallet()
+    console.print(f"\n[green]✓[/green] Wallet: [bold]{account.address}[/bold]\n")
+
+    # Step 2: Get challenge
+    console.print("[bold]Requesting challenge...[/bold]")
+    with httpx.Client(timeout=15) as client:
+        resp = client.post(
+            f"{base_url}/api/auth/wallet/challenge",
+            json={"wallet": account.address},
+        )
+        if resp.status_code != 200:
+            console.print(f"[red]❌ Challenge failed: {resp.text}[/red]")
+            raise typer.Exit(1)
+        challenge = resp.json()
+
+    # Step 3: Sign
+    console.print("[bold]Signing...[/bold]")
+    message = encode_defunct(text=challenge["message"])
+    signed = account.sign_message(message)
+
+    # Step 4: Verify signature and login
+    console.print("[bold]Authenticating...[/bold]")
+    with httpx.Client(timeout=15) as client:
+        resp = client.post(
+            f"{base_url}/api/auth/wallet/login",
+            json={
+                "wallet": account.address,
+                "signature": signed.signature.hex(),
+                "timestamp": challenge["timestamp"],
+            },
+        )
+        if resp.status_code != 200:
+            console.print(f"[red]❌ Login failed: {resp.text}[/red]")
+            raise typer.Exit(1)
+        login_data = resp.json()
+        jwt_token = login_data["token"]
+
+    console.print("[green]✓[/green] Authenticated\n")
+
+    user_id = login_data.get("user_id", "")
+    team_id = login_data.get("team_id", "")
+    wallet_addr = login_data.get("wallet_address", account.address)
+
+    # Step 5: Create a claw API key using the JWT
+    console.print("[bold]Creating API key...[/bold]")
+    with httpx.Client(timeout=15) as client:
+        resp = client.post(
+            f"{base_url}/api/keys",
+            json={"name": "claw-cli"},
+            headers={"Authorization": f"Bearer {jwt_token}"},
+        )
+        if resp.status_code != 200:
+            # Save JWT anyway so user can still auth
+            jwt_path = HYPERCLI_DIR / "claw-jwt.json"
+            HYPERCLI_DIR.mkdir(parents=True, exist_ok=True)
+            with open(jwt_path, "w") as f:
+                json.dump({"token": jwt_token, "user_id": user_id, "team_id": team_id}, f, indent=2)
+            console.print(f"[yellow]⚠ Key creation failed: {resp.text}[/yellow]")
+            console.print(f"[green]✓[/green] JWT saved to {jwt_path} (use for direct auth)")
+            raise typer.Exit(1)
+
+        key_data = resp.json()
+
+    api_key = key_data.get("api_key", key_data.get("key", ""))
+
+    # Step 6: Save as claw key
+    HYPERCLI_DIR.mkdir(parents=True, exist_ok=True)
+    claw_key_data = {
+        "key": api_key,
+        "plan_id": login_data.get("plan_id", "free"),
+        "user_id": user_id,
+        "team_id": team_id,
+        "wallet_address": wallet_addr,
+        "tpm_limit": 0,
+        "rpm_limit": 0,
+        "expires_at": "",
+    }
+    with open(CLAW_KEY_PATH, "w") as f:
+        json.dump(claw_key_data, f, indent=2)
+
+    console.print(f"[green]✓[/green] API key saved to [bold]{CLAW_KEY_PATH}[/bold]\n")
+    console.print(f"  User:    {user_id[:12]}...")
+    console.print(f"  Team:    {team_id[:12]}...")
+    console.print(f"  Key:     {api_key[:20]}...")
+    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 claw config openclaw --apply[/bold]")
+
+
 OPENCLAW_CONFIG_PATH = Path.home() / ".openclaw" / "openclaw.json"
 
 

{hypercli_cli-0.8.13 → hypercli_cli-0.9.0}/hypercli_cli/cli.py

@@ -7,7 +7,7 @@ from rich.prompt import Prompt
 from hypercli import HyperCLI, APIError, configure
 from hypercli.config import CONFIG_FILE
 
-from . import billing, claw, comfyui, flow, instances, jobs, keys, user, wallet
+from . import agents, billing, claw, comfyui, flow, instances, jobs, keys, user, wallet
 
 console = Console()
 
@@ -56,6 +56,7 @@ app = typer.Typer(
 )
 
 # Register subcommands
+app.add_typer(agents.app, name="agents")
 app.add_typer(billing.app, name="billing")
 app.add_typer(claw.app, name="claw")
 app.add_typer(comfyui.app, name="comfyui")

{hypercli_cli-0.8.13 → hypercli_cli-0.9.0}/hypercli_cli/instances.py

@@ -195,6 +195,7 @@ def launch(
     lb_auth: bool = typer.Option(False, "--lb-auth", help="Enable auth on load balancer"),
     registry_user: Optional[str] = typer.Option(None, "--registry-user", help="Private registry username"),
     registry_password: Optional[str] = typer.Option(None, "--registry-password", help="Private registry password"),
+    dockerfile: Optional[str] = typer.Option(None, "--dockerfile", "-d", help="Path to Dockerfile (built on GPU node, overrides image as base)"),
     x402: bool = typer.Option(False, "--x402", help="Pay per-use via embedded x402 wallet"),
     amount: Optional[float] = typer.Option(None, "--amount", help="USDC amount to spend with --x402"),
     follow: bool = typer.Option(False, "--follow", "-f", help="Follow logs after creation"),
@@ -234,6 +235,16 @@ def launch(
     if registry_user and registry_password:
         registry_auth = {"username": registry_user, "password": registry_password}
 
+    # Read and base64-encode Dockerfile if provided
+    dockerfile_b64 = None
+    if dockerfile:
+        import base64
+        from pathlib import Path
+        df_path = Path(dockerfile)
+        if not df_path.exists():
+            raise typer.BadParameter(f"Dockerfile not found: {dockerfile}")
+        dockerfile_b64 = base64.b64encode(df_path.read_bytes()).decode()
+
     # Auto-wrap command in sh -c if it contains shell operators
     if command and any(op in command for op in ["&&", "||", "|", ";", ">", "<", "$"]):
         command = f'sh -c "{command}"'
@@ -310,6 +321,7 @@ def launch(
                 ports=ports_dict,
                 auth=lb_auth,
                 registry_auth=registry_auth,
+                dockerfile=dockerfile_b64,
             )
 
         if fmt == "json":

hypercli_cli-0.9.0/hypercli_cli/voice.py

@@ -0,0 +1,155 @@
+"""HyperClaw Voice API commands — TTS, clone, design"""
+import base64
+import json
+import sys
+from pathlib import Path
+
+import httpx
+import typer
+from rich.console import Console
+
+app = typer.Typer(help="Voice API — text-to-speech, voice cloning, voice design")
+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"
+
+
+def _get_api_key(key: str | None) -> str:
+    """Resolve API key from flag or saved claw key."""
+    if key:
+        return key
+    if CLAW_KEY_PATH.exists():
+        with open(CLAW_KEY_PATH) as f:
+            k = json.load(f).get("key", "")
+        if k:
+            return k
+    console.print("[red]❌ No API key found.[/red]")
+    console.print("Pass [bold]--key sk-...[/bold] or run [bold]hyper claw subscribe[/bold]")
+    raise typer.Exit(1)
+
+
+def _post_voice(
+    endpoint: str,
+    payload: dict,
+    api_key: str,
+    output: Path,
+    dev: bool = False,
+):
+    """POST to voice endpoint and save audio output."""
+    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    url = f"{api_base}/voice/{endpoint}"
+
+    console.print(f"[dim]→ POST {url}[/dim]")
+
+    try:
+        with httpx.Client(timeout=600.0) as client:
+            resp = client.post(
+                url,
+                json=payload,
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                },
+            )
+
+        if resp.status_code != 200:
+            console.print(f"[red]❌ {resp.status_code}: {resp.text[:500]}[/red]")
+            raise typer.Exit(1)
+
+        output.parent.mkdir(parents=True, exist_ok=True)
+        with open(output, "wb") as f:
+            f.write(resp.content)
+
+        size_kb = len(resp.content) / 1024
+        console.print(f"[green]✅ Saved {output} ({size_kb:.1f} KB)[/green]")
+
+    except httpx.HTTPError as e:
+        console.print(f"[red]❌ Request failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("tts")
+def tts(
+    text: str = typer.Argument(..., help="Text to synthesize"),
+    voice: str = typer.Option("Chelsie", "--voice", "-v", help="Voice name (CustomVoice preset)"),
+    language: str = typer.Option("auto", "--language", "-l", help="Language: auto, english, chinese, etc."),
+    output: Path = typer.Option("output.wav", "--output", "-o", help="Output audio file"),
+    key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+):
+    """Generate speech from text using a preset voice.
+    
+    Examples:
+      hyper claw voice tts "Hello world"
+      hyper claw voice tts "Bonjour" -v Etienne -l french -o hello.wav
+    """
+    api_key = _get_api_key(key)
+    payload = {
+        "text": text,
+        "voice": voice,
+        "language": language,
+    }
+    _post_voice("tts", payload, api_key, output, dev)
+
+
+@app.command("clone")
+def clone(
+    text: str = typer.Argument(..., help="Text to synthesize"),
+    ref_audio: Path = typer.Option(..., "--ref", "-r", help="Reference audio file (wav/mp3/ogg)"),
+    language: str = typer.Option("auto", "--language", "-l", help="Language: auto, english, chinese, etc."),
+    x_vector_only: bool = typer.Option(True, "--x-vector-only/--full-clone", help="Use x_vector_only mode (recommended)"),
+    output: Path = typer.Option("output.wav", "--output", "-o", help="Output audio file"),
+    key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+):
+    """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 -o cloned.wav
+    """
+    api_key = _get_api_key(key)
+
+    if not ref_audio.exists():
+        console.print(f"[red]❌ Reference audio not found: {ref_audio}[/red]")
+        raise typer.Exit(1)
+
+    with open(ref_audio, "rb") as f:
+        ref_b64 = base64.b64encode(f.read()).decode()
+
+    console.print(f"[dim]Reference: {ref_audio} ({ref_audio.stat().st_size / 1024:.1f} KB)[/dim]")
+
+    payload = {
+        "text": text,
+        "ref_audio_base64": ref_b64,
+        "language": language,
+        "x_vector_only": x_vector_only,
+    }
+    _post_voice("clone", payload, api_key, output, dev)
+
+
+@app.command("design")
+def design(
+    text: str = typer.Argument(..., help="Text to synthesize"),
+    description: str = typer.Option(..., "--desc", "-d", help="Voice description (e.g. 'young female, warm, American accent')"),
+    language: str = typer.Option("auto", "--language", "-l", help="Language: auto, english, chinese, etc."),
+    output: Path = typer.Option("output.wav", "--output", "-o", help="Output audio file"),
+    key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+):
+    """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" -o designed.wav
+    """
+    api_key = _get_api_key(key)
+    payload = {
+        "text": text,
+        "instruct": description,
+        "language": language,
+    }
+    _post_voice("design", payload, api_key, output, dev)

{hypercli_cli-0.8.13 → hypercli_cli-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "0.8.13"
+version = "0.9.0"
 description = "CLI for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"