hypercli-cli 0.8.5__tar.gz → 0.8.7__tar.gz

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 0.8.5
+Version: 0.8.7
 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.7.1
+Requires-Dist: hypercli-sdk>=0.8.7
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: openai>=2.8.1
 Requires-Dist: pyyaml>=6.0
@@ -19,11 +19,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.7.1; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=0.8.7; 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.7.1; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=0.8.7; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

hypercli_cli-0.8.7/hypercli_cli/__init__.py

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

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/claw.py

@@ -304,6 +304,57 @@ def plans(
     console.print("Subscribe with: [bold]hyper claw subscribe <plan_id> <amount>[/bold]")
 
 
+@app.command("models")
+def models(
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON response"),
+):
+    """List available HyperClaw models from the public /models endpoint."""
+    import httpx
+
+    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    url = f"{api_base}/models"
+
+    try:
+        response = httpx.get(url, timeout=15)
+        response.raise_for_status()
+        payload = response.json()
+    except Exception as e:
+        console.print(f"[red]❌ Failed to fetch models from {url}: {e}[/red]")
+        raise typer.Exit(1)
+
+    models_data = payload.get("models")
+    if not isinstance(models_data, list):
+        console.print("[red]❌ Unexpected /models response shape (expected top-level models list)[/red]")
+        if json_output:
+            console.print_json(json.dumps(payload))
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print_json(json.dumps(payload))
+        return
+
+    table = Table(title="HyperClaw Models")
+    table.add_column("Model ID", style="cyan")
+    table.add_column("Context", style="blue")
+    table.add_column("Vision", style="green")
+    table.add_column("Tools", style="green")
+    table.add_column("Reasoning", style="magenta")
+
+    for model in models_data:
+        model_id = str(model.get("id", ""))
+        context_length = model.get("context_length", "")
+        vision = "yes" if model.get("supports_vision") else "no"
+        tools = "yes" if model.get("supports_tools") else "no"
+        reasoning = "yes" if model.get("supports_reasoning") else "no"
+        table.add_row(model_id, str(context_length), vision, tools, reasoning)
+
+    console.print()
+    console.print(table)
+    console.print()
+    console.print(f"Source: {url}")
+
+
 OPENCLAW_CONFIG_PATH = Path.home() / ".openclaw" / "openclaw.json"
 
 

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/instances.py

@@ -1,7 +1,7 @@
 """hyper instances commands"""
 import typer
 from typing import Optional
-from hypercli import HyperCLI
+from hypercli import HyperCLI, X402Client
 from .output import output, console, success, spinner
 
 app = typer.Typer(help="GPU instances - browse and launch")
@@ -193,12 +193,20 @@ def launch(
     port: Optional[list[str]] = typer.Option(None, "--port", "-p", help="Ports (name:port)"),
     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"),
+    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"),
     cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C"),
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
 ):
-    """Launch a new GPU instance"""
-    client = get_client()
+    """Launch a new GPU instance
+
+    Examples:
+        hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -c 'nvidia-smi && sleep 60'
+        hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 -g l4 -r kr -c 'nvidia-smi' -t 120
+        hyper instances launch my-registry.com/my-image:latest -g h100 -n 8 -c 'python train.py'
+        hyper instances launch nvidia/cuda:12.6.3-base-ubuntu22.04 --x402 --amount 2.5
+    """
 
     # Parse env vars
     env_dict = None
@@ -223,32 +231,99 @@ def launch(
     if registry_user and registry_password:
         registry_auth = {"username": registry_user, "password": registry_password}
 
-    with spinner("Launching instance..."):
-        job = client.jobs.create(
-            image=image,
-            command=command,
-            gpu_type=gpu,
-            gpu_count=count,
-            region=region,
-            runtime=runtime,
-            interruptible=interruptible,
-            env=env_dict,
-            ports=ports_dict,
-            registry_auth=registry_auth,
-        )
-
-    if fmt == "json":
-        output(job, "json")
+    # 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}"'
+
+    follow_api_key = None
+
+    if x402:
+        if amount is None:
+            raise typer.BadParameter("--amount is required when using --x402")
+        if amount <= 0:
+            raise typer.BadParameter("--amount must be greater than 0")
+        if runtime is not None:
+            console.print("[yellow]Ignoring --runtime with --x402 (runtime is computed from payment amount).[/yellow]")
+
+        from .wallet import require_wallet_deps, load_wallet
+
+        require_wallet_deps()
+        account = load_wallet()
+        x402_client = X402Client()
+
+        with spinner("Launching instance with x402..."):
+            x402_job = x402_client.create_job(
+                amount=amount,
+                account=account,
+                image=image,
+                command=command,
+                gpu_type=gpu,
+                gpu_count=count,
+                region=region,
+                interruptible=interruptible,
+                env=env_dict,
+                ports=ports_dict,
+                registry_auth=registry_auth,
+            )
+        job = x402_job.job
+        follow_api_key = x402_job.access_key
+
+        if fmt == "json":
+            output(
+                {
+                    "job": job.__dict__,
+                    "access_key": x402_job.access_key,
+                    "status_url": x402_job.status_url,
+                    "logs_url": x402_job.logs_url,
+                    "cancel_url": x402_job.cancel_url,
+                },
+                "json",
+            )
+        else:
+            success(f"Instance launched: {job.job_id}")
+            console.print(f"  State:      {job.state}")
+            console.print(f"  GPU:        {job.gpu_type} x{job.gpu_count}")
+            console.print(f"  Region:     {job.region}")
+            console.print(f"  Price:      ${job.price_per_hour:.2f}/hr")
+            if job.hostname:
+                console.print(f"  Hostname:   {job.hostname}")
+            console.print(f"  Access Key: {x402_job.access_key}")
+            console.print(f"  Status URL: {x402_job.status_url}")
+            console.print(f"  Logs URL:   {x402_job.logs_url}")
+            console.print(f"  Cancel URL: {x402_job.cancel_url}")
     else:
-        success(f"Instance launched: {job.job_id}")
-        console.print(f"  State:    {job.state}")
-        console.print(f"  GPU:      {job.gpu_type} x{job.gpu_count}")
-        console.print(f"  Region:   {job.region}")
-        console.print(f"  Price:    ${job.price_per_hour:.2f}/hr")
-        if job.hostname:
-            console.print(f"  Hostname: {job.hostname}")
+        client = get_client()
+
+        with spinner("Launching instance..."):
+            job = client.jobs.create(
+                image=image,
+                command=command,
+                gpu_type=gpu,
+                gpu_count=count,
+                region=region,
+                runtime=runtime,
+                interruptible=interruptible,
+                env=env_dict,
+                ports=ports_dict,
+                registry_auth=registry_auth,
+            )
+
+        if fmt == "json":
+            output(job, "json")
+        else:
+            success(f"Instance launched: {job.job_id}")
+            console.print(f"  State:    {job.state}")
+            console.print(f"  GPU:      {job.gpu_type} x{job.gpu_count}")
+            console.print(f"  Region:   {job.region}")
+            console.print(f"  Price:    ${job.price_per_hour:.2f}/hr")
+            if job.hostname:
+                console.print(f"  Hostname: {job.hostname}")
 
     if follow:
         console.print()
         from .tui.job_monitor import run_job_monitor
-        run_job_monitor(job.job_id, cancel_on_exit=cancel_on_exit)
+
+        if follow_api_key:
+            run_job_monitor(job.job_id, cancel_on_exit=cancel_on_exit, api_key=follow_api_key)
+        else:
+            run_job_monitor(job.job_id, cancel_on_exit=cancel_on_exit)

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/jobs.py

@@ -45,18 +45,28 @@ def get_job(
 @app.command("logs")
 def logs(
     job_id: str = typer.Argument(..., help="Job ID"),
-    follow: bool = typer.Option(False, "--follow", "-f", help="Stream logs"),
-    cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Stream logs via WebSocket"),
+    tail: int = typer.Option(None, "--tail", "-n", help="Show last N lines"),
+    tui: bool = typer.Option(False, "--tui", help="Interactive TUI with metrics"),
+    cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C (with --tui)"),
 ):
     """Get job logs"""
     client = get_client()
 
-    if follow:
+    if tui:
         _follow_job(job_id, cancel_on_exit=cancel_on_exit)
+    elif follow:
+        _stream_logs(job_id)
     else:
-        with spinner("Fetching logs..."):
-            logs_str = client.jobs.logs(job_id)
-        console.print(logs_str)
+        logs_str = client.jobs.logs(job_id)
+        if not logs_str:
+            print("(no logs)")
+            return
+        lines = logs_str.rstrip("\n").split("\n")
+        if tail:
+            lines = lines[-tail:]
+        for line in lines:
+            print(line)
 
 
 @app.command("metrics")
@@ -168,6 +178,31 @@ def _make_bar(value: float, max_val: float, warn: float = None, crit: float = No
     return f"[{color}]{bar}[/{color}]"
 
 
+def _stream_logs(job_id: str):
+    """Stream logs via WebSocket (like tail -f)"""
+    import asyncio
+    from hypercli import stream_logs
+
+    client = get_client()
+
+    async def _run():
+        try:
+            await stream_logs(
+                client,
+                job_id,
+                on_line=lambda line: print(line),
+                fetch_initial=True,
+                fetch_final=True,
+            )
+        except KeyboardInterrupt:
+            pass
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        pass
+
+
 def _follow_job(job_id: str, cancel_on_exit: bool = False):
     """Follow job with TUI"""
     from .tui.job_monitor import run_job_monitor

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/renders.py

@@ -2,7 +2,7 @@
 import time
 import typer
 from typing import Optional
-from hypercli import HyperCLI
+from hypercli import HyperCLI, X402Client
 from .output import output, console, success, spinner
 
 app = typer.Typer(help="Manage renders")
@@ -52,12 +52,13 @@ def create_render(
     gpu: str = typer.Option("L40S", "--gpu", "-g", help="GPU type"),
     region: Optional[str] = typer.Option(None, "--region", "-r", help="Region"),
     render_type: str = typer.Option("comfyui", "--type", "-t", help="Render type"),
+    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"),
     wait: bool = typer.Option(False, "--wait", "-w", help="Wait for completion"),
     notify_url: Optional[str] = typer.Option(None, "--notify", help="Webhook URL for completion"),
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
 ):
     """Create a new render"""
-    client = get_client()
 
     params = {
         "template": template,
@@ -67,6 +68,51 @@ def create_render(
     if region:
         params["region"] = region
 
+    if x402:
+        if amount is None:
+            raise typer.BadParameter("--amount is required when using --x402")
+        if amount <= 0:
+            raise typer.BadParameter("--amount must be greater than 0")
+
+        from .wallet import require_wallet_deps, load_wallet
+
+        require_wallet_deps()
+        account = load_wallet()
+        x402_client = X402Client()
+
+        with spinner("Creating render with x402..."):
+            x402_render = x402_client.create_render(
+                amount=amount,
+                account=account,
+                params=params,
+                render_type=render_type,
+                notify_url=notify_url,
+            )
+        render = x402_render.render
+        wait_client = HyperCLI(api_key=x402_render.access_key)
+
+        if fmt == "json" and not wait:
+            output(
+                {
+                    "render": render.__dict__,
+                    "access_key": x402_render.access_key,
+                    "status_url": x402_render.status_url,
+                    "cancel_url": x402_render.cancel_url,
+                },
+                "json",
+            )
+        else:
+            console.print(f"[bold green]✓[/bold green] Render created: [cyan]{render.render_id}[/cyan]")
+            console.print(f"  State:      {render.state}")
+            console.print(f"  Access Key: {x402_render.access_key}")
+            console.print(f"  Status URL: {x402_render.status_url}")
+            console.print(f"  Cancel URL: {x402_render.cancel_url}")
+
+        if wait:
+            _wait_for_render(wait_client, render.render_id, fmt)
+        return
+
+    client = get_client()
     with spinner("Creating render..."):
         render = client.renders.create(params=params, render_type=render_type, notify_url=notify_url)
 
@@ -79,7 +125,6 @@ def create_render(
     if wait:
         _wait_for_render(client, render.render_id, fmt)
 
-
 @app.command("status")
 def status(
     render_id: str = typer.Argument(..., help="Render ID"),

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/tui/job_monitor.py

@@ -163,9 +163,10 @@ async def _run_job_monitor_async(
     status_q: Queue = None,
     stop_on_status_complete: bool = False,
     cancel_on_exit: bool = False,
+    api_key: str | None = None,
 ):
     """Async job monitor - uses SDK LogStream for logs"""
-    client = HyperCLI()
+    client = HyperCLI(api_key=api_key) if api_key else HyperCLI()
     should_cancel = False
     logs: deque[str] = deque(maxlen=MAX_LOG_LINES)
     log_stream: Optional[LogStream] = None
@@ -340,6 +341,7 @@ def run_job_monitor(
     status_q: Queue = None,
     stop_on_status_complete: bool = False,
     cancel_on_exit: bool = False,
+    api_key: str | None = None,
 ):
     """Run the job monitor TUI (sync wrapper).
 
@@ -348,5 +350,6 @@ def run_job_monitor(
         status_q: Optional queue receiving JobStatus updates for status pane
         stop_on_status_complete: If True, exit when JobStatus.complete is True
         cancel_on_exit: If True, cancel the job when exiting via Ctrl+C
+        api_key: Optional bearer token (API key or x402 access key)
     """
-    asyncio.run(_run_job_monitor_async(job_id, status_q, stop_on_status_complete, cancel_on_exit))
+    asyncio.run(_run_job_monitor_async(job_id, status_q, stop_on_status_complete, cancel_on_exit, api_key))

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/hypercli_cli/wallet.py

@@ -20,6 +20,7 @@ except ImportError:
 
 WALLET_DIR = Path.home() / ".hypercli"
 WALLET_PATH = WALLET_DIR / "wallet.json"
+WALLET_PASSPHRASE_PATH = WALLET_DIR / "wallet.passphrase"
 BASE_RPC = "https://mainnet.base.org"
 USDC_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
 
@@ -33,6 +34,20 @@ def require_wallet_deps():
         raise typer.Exit(1)
 
 
+
+def _get_wallet_passphrase(prompt: str = "Unlock keystore passphrase: ") -> str:
+    passphrase_env = os.getenv("HYPERCLI_WALLET_PASSPHRASE")
+    if passphrase_env:
+        return passphrase_env
+
+    if WALLET_PASSPHRASE_PATH.exists():
+        passphrase_file = WALLET_PASSPHRASE_PATH.read_text().strip()
+        if passphrase_file:
+            console.print("[dim]Using passphrase from ~/.hypercli/wallet.passphrase[/dim]")
+            return passphrase_file
+
+    return getpass.getpass(prompt)
+
 @app.command("create")
 def create():
     """Create a new wallet with encrypted keystore"""
@@ -195,12 +210,7 @@ def balance():
     with open(WALLET_PATH) as f:
         keystore = json.load(f)
     
-    # Get passphrase
-    passphrase_env = os.getenv("HYPERCLI_WALLET_PASSPHRASE")
-    if passphrase_env:
-        passphrase = passphrase_env
-    else:
-        passphrase = getpass.getpass("Unlock keystore passphrase: ")
+    passphrase = _get_wallet_passphrase()
     
     try:
         private_key = Account.decrypt(keystore, passphrase)
@@ -503,12 +513,7 @@ def load_wallet():
     with open(WALLET_PATH) as f:
         keystore = json.load(f)
     
-    # Get passphrase
-    passphrase_env = os.getenv("HYPERCLI_WALLET_PASSPHRASE")
-    if passphrase_env:
-        passphrase = passphrase_env
-    else:
-        passphrase = getpass.getpass("Unlock keystore passphrase: ")
+    passphrase = _get_wallet_passphrase()
     
     try:
         private_key = Account.decrypt(keystore, passphrase)

{hypercli_cli-0.8.5 → hypercli_cli-0.8.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "0.8.5"
+version = "0.8.7"
 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.7.1",
+    "hypercli-sdk>=0.8.7",
     "openai>=2.8.1",
     "typer>=0.20.0",
     "rich>=14.2.0",
@@ -25,7 +25,7 @@ dependencies = [
 
 [project.optional-dependencies]
 comfyui = [
-    "hypercli-sdk[comfyui]>=0.7.1",
+    "hypercli-sdk[comfyui]>=0.8.7",
 ]
 wallet = [
     "x402[httpx,evm]>=2.0.0",
@@ -35,7 +35,7 @@ wallet = [
     "qrcode[pil]>=7.4.0",
 ]
 all = [
-    "hypercli-sdk[comfyui]>=0.7.1",
+    "hypercli-sdk[comfyui]>=0.8.7",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-0.8.5/hypercli_cli/__init__.py

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