hypercli-cli 0.9.1__tar.gz → 1.0.0__tar.gz

{hypercli_cli-0.9.1 → hypercli_cli-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 0.9.1
+Version: 1.0.0
 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>=0.8.9
+Requires-Dist: hypercli-sdk>=1.0.0
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=14.2.0
@@ -18,11 +18,11 @@ Requires-Dist: websocket-client>=1.6.0
 Provides-Extra: all
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'all'
 Requires-Dist: eth-account>=0.13.0; extra == 'all'
-Requires-Dist: hypercli-sdk[comfyui]>=0.8.9; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; 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]>=0.8.9; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=1.0.0; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

{hypercli_cli-0.9.1 → hypercli_cli-1.0.0}/hypercli_cli/claw.py

@@ -8,14 +8,12 @@ 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 subcommands
+# Register onboard as a subcommand
 app.command("onboard")(_onboard_fn)
-app.add_typer(voice_app, name="voice")
 
 # Check if wallet dependencies are available
 try:
@@ -196,19 +194,7 @@ 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 (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
-
+            # Step 6: Retry with payment
             console.print("[bold]Sending payment...[/bold]")
             retry_response = await http.post(url, headers=payment_headers)
             
@@ -369,134 +355,6 @@ 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.9.1 → hypercli_cli-1.0.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 agents, billing, claw, comfyui, flow, instances, jobs, keys, user, wallet
+from . import billing, claw, comfyui, flow, instances, jobs, keys, user, wallet
 
 console = Console()
 
@@ -56,7 +56,6 @@ 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.9.1 → hypercli_cli-1.0.0}/hypercli_cli/instances.py

@@ -195,7 +195,6 @@ 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"),
@@ -235,16 +234,6 @@ 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}"'
@@ -321,7 +310,6 @@ def launch(
                 ports=ports_dict,
                 auth=lb_auth,
                 registry_auth=registry_auth,
-                dockerfile=dockerfile_b64,
             )
 
         if fmt == "json":

{hypercli_cli-0.9.1 → hypercli_cli-1.0.0}/hypercli_cli/jobs.py

@@ -232,6 +232,106 @@ def _follow_job(job_id: str, cancel_on_exit: bool = False):
     run_job_monitor(job_id, cancel_on_exit=cancel_on_exit)
 
 
+@app.command("shell")
+def shell(
+    job_id: str = typer.Argument(..., help="Job ID (full or prefix)"),
+    shell_cmd: str = typer.Option("/bin/bash", "--shell", "-s", help="Shell to use"),
+):
+    """Open an interactive shell on a running job container (WebSocket PTY)"""
+    import asyncio
+    import sys
+
+    client = get_client()
+    job_id = _resolve_job_id(client, job_id)
+
+    with spinner("Connecting to shell..."):
+        job = client.jobs.get(job_id)
+
+    if job.state != "running":
+        console.print(f"[red]Error:[/red] Job is {job.state}, not running")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Connected to job {job_id[:8]}... (press Ctrl+D or type 'exit' to disconnect)[/dim]")
+
+    asyncio.run(_run_shell(client, job_id, job.job_key, shell_cmd))
+
+
+async def _run_shell(client, job_id: str, job_key: str, shell_cmd: str):
+    """Run interactive shell with raw terminal mode."""
+    import os
+    import sys
+    import signal
+    import struct
+    import termios
+    import tty
+    import fcntl
+
+    from hypercli.shell import shell_connect
+
+    loop = asyncio.get_event_loop()
+
+    # Save terminal state
+    stdin_fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(stdin_fd)
+
+    session = None
+    try:
+        # Connect
+        session = await shell_connect(
+            client,
+            job_id,
+            job_key=job_key,
+            shell=shell_cmd,
+            on_output=lambda data: sys.stdout.write(data) or sys.stdout.flush(),
+            on_close=lambda reason: None,
+        )
+
+        # Send initial terminal size
+        try:
+            sz = struct.unpack("hh", fcntl.ioctl(stdin_fd, termios.TIOCGWINSZ, b"\x00" * 4))
+            await session.resize(cols=sz[1], rows=sz[0])
+        except Exception:
+            await session.resize(cols=80, rows=24)
+
+        # Handle SIGWINCH (terminal resize)
+        def on_resize(*_):
+            try:
+                sz = struct.unpack("hh", fcntl.ioctl(stdin_fd, termios.TIOCGWINSZ, b"\x00" * 4))
+                asyncio.run_coroutine_threadsafe(session.resize(cols=sz[1], rows=sz[0]), loop)
+            except Exception:
+                pass
+
+        signal.signal(signal.SIGWINCH, on_resize)
+
+        # Enter raw mode
+        tty.setraw(stdin_fd)
+
+        # Read stdin and forward to shell
+        reader = asyncio.StreamReader()
+        protocol = asyncio.StreamReaderProtocol(reader)
+        await loop.connect_read_pipe(lambda: protocol, sys.stdin)
+
+        while not session.closed:
+            try:
+                data = await asyncio.wait_for(reader.read(4096), timeout=0.5)
+                if not data:
+                    break
+                await session.send(data.decode(errors="replace"))
+            except asyncio.TimeoutError:
+                continue
+            except Exception:
+                break
+
+    finally:
+        # Restore terminal
+        termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_settings)
+        signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+        if session:
+            await session.close()
+        sys.stdout.write("\r\n")
+        sys.stdout.flush()
+
+
 def _watch_metrics(job_id: str):
     """Watch metrics live"""
     import time

{hypercli_cli-0.9.1 → hypercli_cli-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "0.9.1"
+version = "1.0.0"
 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>=0.8.9",
+    "hypercli-sdk>=1.0.0",
     "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]>=0.8.9",
+    "hypercli-sdk[comfyui]>=1.0.0",
 ]
 wallet = [
     "x402[httpx,evm]>=2.0.0",
@@ -34,7 +34,7 @@ wallet = [
     "qrcode[pil]>=7.4.0",
 ]
 all = [
-    "hypercli-sdk[comfyui]>=0.8.9",
+    "hypercli-sdk[comfyui]>=1.0.0",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-0.9.1/hypercli_cli/agents.py

@@ -1,559 +0,0 @@
-"""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.9.1/hypercli_cli/voice.py

@@ -1,167 +0,0 @@
-"""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."),
-    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"),
-):
-    """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
-    """
-    api_key = _get_api_key(key)
-    if output is None:
-        output = Path(f"output.{format}")
-    payload = {
-        "text": text,
-        "voice": voice,
-        "language": language,
-        "response_format": format,
-    }
-    _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)"),
-    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"),
-):
-    """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
-    """
-    api_key = _get_api_key(key)
-    if output is None:
-        output = Path(f"output.{format}")
-
-    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,
-        "response_format": format,
-    }
-    _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."),
-    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"),
-):
-    """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
-    """
-    api_key = _get_api_key(key)
-    if output is None:
-        output = Path(f"output.{format}")
-    payload = {
-        "text": text,
-        "instruct": description,
-        "language": language,
-        "response_format": format,
-    }
-    _post_voice("design", payload, api_key, output, dev)