hypercli-cli 0.9.2__tar.gz → 1.0.1__tar.gz

{hypercli_cli-0.9.2 → hypercli_cli-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 0.9.2
+Version: 1.0.1
 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.2 → hypercli_cli-1.0.1}/hypercli_cli/agents.py

@@ -137,7 +137,7 @@ def budget():
 
 @app.command("create")
 def create(
-    name: str = typer.Option("agent", "--name", "-n", help="Agent name"),
+    name: str = typer.Option(None, "--name", "-n", help="Agent name (auto-generated if omitted, becomes {name}.hyperclaw.app)"),
     size: str = typer.Option(None, "--size", "-s", help="Size preset: small, medium, large"),
     cpu: int = typer.Option(None, "--cpu", help="Custom CPU in cores"),
     memory: int = typer.Option(None, "--memory", help="Custom memory in GB"),
@@ -399,41 +399,26 @@ def shell(
 ):
     """Open an interactive shell on an agent pod (WebSocket PTY).
 
-    Connects to the executor's /shell endpoint. Press Ctrl+] to disconnect.
+    Connects via the HyperClaw backend WebSocket proxy. Press Ctrl+] to disconnect.
     """
     agent_id = _resolve_agent(agent_id)
+    agents = _get_agents_client()
 
-    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]")
+    console.print(f"[dim]Connecting to shell...[/dim]")
 
     try:
-        import websockets
         import asyncio
         import termios
         import tty
     except ImportError:
-        console.print("[red]❌ 'websockets' required: pip install websockets[/red]")
+        console.print("[red]❌ TTY libraries required[/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}"
+        # Connect via backend WebSocket
+        ws = await agents.shell_connect(agent_id)
 
-        async with websockets.connect(ws_url, additional_headers=headers) as ws:
+        try:
             console.print("[green]Connected.[/green] Ctrl+] to disconnect.\n")
 
             old_settings = termios.tcgetattr(sys.stdin)
@@ -453,7 +438,7 @@ def shell(
                             elif isinstance(msg, bytes):
                                 sys.stdout.buffer.write(msg)
                                 sys.stdout.buffer.flush()
-                    except websockets.ConnectionClosed:
+                    except Exception:
                         pass
 
                 async def read_stdin():
@@ -463,10 +448,10 @@ def shell(
                             data = await loop.run_in_executor(None, lambda: os.read(sys.stdin.fileno(), 1024))
                             if not data:
                                 break
-                            if b"\x1d" in data:
+                            if b"\x1d" in data:  # Ctrl+]
                                 break
                             await ws.send(data.decode(errors="replace"))
-                    except (websockets.ConnectionClosed, OSError):
+                    except Exception:
                         pass
 
                 done, pending = await asyncio.wait(
@@ -478,6 +463,8 @@ def shell(
             finally:
                 termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
                 console.print("\n[dim]Disconnected.[/dim]")
+        finally:
+            await ws.close()
 
     try:
         asyncio.run(_run_shell())
@@ -493,26 +480,46 @@ 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"),
+    ws: bool = typer.Option(False, "--ws", help="Use WebSocket instead of SSE (via backend)"),
 ):
     """Stream logs from an agent pod."""
     agent_id = _resolve_agent(agent_id)
+    agents = _get_agents_client()
 
-    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 ws:
+        # WebSocket mode via backend
+        import asyncio
 
-    agents = _get_agents_client()
+        async def _stream_ws():
+            try:
+                async for line in agents.logs_stream_ws(agent_id, tail_lines=lines):
+                    console.print(line)
+            except KeyboardInterrupt:
+                pass
+            except Exception as e:
+                console.print(f"[red]❌ Logs failed: {e}[/red]")
+                raise typer.Exit(1)
 
-    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)
+        try:
+            asyncio.run(_stream_ws())
+        except KeyboardInterrupt:
+            pass
+    else:
+        # SSE mode via executor (legacy)
+        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)
+
+        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")
@@ -596,3 +603,187 @@ def token(
 
     console.print(f"[green]✅ Token refreshed[/green]")
     console.print(f"  Expires: {result.get('expires_at', 'unknown')}")
+
+
+# ---------------------------------------------------------------------------
+# Gateway commands (OpenClaw Gateway RPC via WebSocket)
+# ---------------------------------------------------------------------------
+
+def _run_async(coro):
+    """Run an async coroutine from sync CLI."""
+    import asyncio
+    return asyncio.run(coro)
+
+
+@app.command("config")
+def gateway_config(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    schema: bool = typer.Option(False, "--schema", help="Show config schema instead of current config"),
+):
+    """Get the OpenClaw gateway config for an agent."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            if schema:
+                result = await gw.config_schema()
+            else:
+                result = await gw.config_get()
+            console.print_json(json.dumps(result, default=str))
+
+    _run_async(_run())
+
+
+@app.command("config-patch")
+def gateway_config_patch(
+    agent_id: str = typer.Argument(..., help="Agent ID or name"),
+    patch: str = typer.Argument(..., help="JSON patch to apply"),
+):
+    """Patch the OpenClaw gateway config (merges with existing). Restarts gateway."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+    patch_data = json.loads(patch)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            result = await gw.config_patch(patch_data)
+            console.print("[green]✅ Config patched. Gateway restarting.[/green]")
+
+    _run_async(_run())
+
+
+@app.command("models")
+def gateway_models(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+):
+    """List available models on an agent's gateway."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            models = await gw.models_list()
+            if not models:
+                console.print("[dim]No models configured[/dim]")
+                return
+            for m in models:
+                ctx = m.get("contextWindow", "?")
+                console.print(f"  {m['provider']}/{m['name']}  (ctx={ctx})")
+
+    _run_async(_run())
+
+
+@app.command("files")
+def gateway_files(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    get: str = typer.Option(None, "--get", help="Read a specific file"),
+    set_file: str = typer.Option(None, "--set", help="Write a file (name=content)"),
+):
+    """List or read/write workspace files on an agent via Gateway."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            # Get the default agent ID from the gateway
+            agents = await gw.agents_list()
+            gw_agent_id = agents[0]["id"] if agents else "main"
+
+            if get:
+                content = await gw.file_get(gw_agent_id, get)
+                console.print(content)
+            elif set_file:
+                name, _, content = set_file.partition("=")
+                if not content:
+                    console.print("[red]Usage: --set 'SOUL.md=# My Agent'[/red]")
+                    raise typer.Exit(1)
+                await gw.file_set(gw_agent_id, name, content)
+                console.print(f"[green]✅ Written {name}[/green]")
+            else:
+                files = await gw.files_list(gw_agent_id)
+                if not files:
+                    console.print("[dim]No workspace files[/dim]")
+                    return
+                for f in files:
+                    icon = "📄" if not f.get("missing") else "❌"
+                    size = f.get("size", 0)
+                    console.print(f"  {icon} {f['name']:30s} {size:>8,} bytes")
+
+    _run_async(_run())
+
+
+@app.command("sessions")
+def gateway_sessions(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    limit: int = typer.Option(20, "--limit", "-n"),
+):
+    """List chat sessions on an agent's gateway."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            sessions = await gw.sessions_list(limit=limit)
+            if not sessions:
+                console.print("[dim]No sessions[/dim]")
+                return
+            for s in sessions:
+                console.print(f"  {s.get('key','?'):20s}  {s.get('status','?'):10s}  {s.get('lastActivity','')}")
+
+    _run_async(_run())
+
+
+@app.command("cron")
+def gateway_cron(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+):
+    """List cron jobs on an agent's gateway."""
+    from hypercli.gateway import GatewayClient
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            jobs = await gw.cron_list()
+            if not jobs:
+                console.print("[dim]No cron jobs[/dim]")
+                return
+            for j in jobs:
+                enabled = "✅" if j.get("enabled", True) else "⏸️"
+                console.print(f"  {enabled} {j.get('id','?'):20s}  {j.get('name','unnamed'):20s}  {j.get('schedule','')}")
+
+    _run_async(_run())
+
+
+@app.command("gateway-chat")
+def gateway_chat(
+    agent_id: str = typer.Argument(None, help="Agent ID or name"),
+    message: str = typer.Argument(..., help="Message to send"),
+):
+    """Send a chat message to an agent via the Gateway and stream the response."""
+    from hypercli.gateway import GatewayClient, ChatEvent
+
+    pod = _get_pod_with_token(agent_id)
+
+    async def _run():
+        async with pod.gateway() as gw:
+            async for event in gw.chat_send(message):
+                if event.type == "content":
+                    print(event.text, end="", flush=True)
+                elif event.type == "thinking":
+                    console.print(f"[dim]{event.text}[/dim]", end="")
+                elif event.type == "tool_call":
+                    console.print(f"\n[yellow]🔧 {event.data}[/yellow]")
+                elif event.type == "error":
+                    console.print(f"\n[red]❌ {event.text}[/red]")
+                elif event.type == "done":
+                    print()
+            print()
+
+    _run_async(_run())

{hypercli_cli-0.9.2 → hypercli_cli-1.0.1}/hypercli_cli/instances.py

@@ -196,6 +196,7 @@ def launch(
     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)"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Validate configuration without creating job or reserving funds"),
     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"),
@@ -308,7 +309,8 @@ def launch(
     else:
         client = get_client()
 
-        with spinner("Launching instance..."):
+        spinner_msg = "Validating configuration..." if dry_run else "Launching instance..."
+        with spinner(spinner_msg):
             job = client.jobs.create(
                 image=image,
                 command=command,
@@ -322,18 +324,37 @@ def launch(
                 auth=lb_auth,
                 registry_auth=registry_auth,
                 dockerfile=dockerfile_b64,
+                dry_run=dry_run,
             )
 
         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 dry_run:
+                console.print("[bold green]✓[/] Dry run successful - configuration valid")
+                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")
+                console.print(f"  Runtime:  {job.runtime}s")
+                # Display cold boot status
+                import sys
+                if job.cold_boot:
+                    console.print("[yellow]⏳ Cold boot — instance provisioning may take up to 15 minutes[/]", file=sys.stderr)
+                else:
+                    console.print("[green]🚀 Warm instance available — should be ready in under a minute[/]", file=sys.stderr)
+            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}")
+                # Display cold boot status for real launches too
+                if job.cold_boot:
+                    console.print("[yellow]⏳ Cold boot — instance provisioning may take up to 15 minutes[/]")
+                else:
+                    console.print("[green]🚀 Warm instance available — should be ready in under a minute[/]")
 
     if follow:
         console.print()

{hypercli_cli-0.9.2 → hypercli_cli-1.0.1}/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
@@ -296,3 +396,129 @@ def _render_metrics(m):
 
     panels.append(Panel(table, title="[bold]GPU Metrics[/bold]", border_style="green"))
     return Group(*panels)
+
+
+@app.command("exec")
+def exec_command(
+    job_id: str = typer.Argument(..., help="Job ID (full or prefix)"),
+    command: str = typer.Argument(..., help="Command to execute"),
+    timeout: int = typer.Option(30, "--timeout", "-t", help="Timeout in seconds"),
+):
+    """Execute a command non-interactively on a running job container.
+
+    Runs the command and returns stdout/stderr. For interactive shells, use 'hyper jobs shell'.
+
+    Examples:
+        hyper jobs exec <job_id> "nvidia-smi"
+        hyper jobs exec <job_id> "ps aux" --timeout 10
+    """
+    import sys
+
+    client = get_client()
+    job_id = _resolve_job_id(client, job_id)
+
+    with spinner("Executing command..."):
+        try:
+            result = client.jobs.exec(job_id, command, timeout=timeout)
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise typer.Exit(1)
+
+    # Print stdout to stdout
+    if result.stdout:
+        sys.stdout.write(result.stdout)
+        sys.stdout.flush()
+
+    # Print stderr to stderr
+    if result.stderr:
+        sys.stderr.write(result.stderr)
+        sys.stderr.flush()
+
+    # Exit with remote exit code
+    if result.exit_code != 0:
+        raise typer.Exit(result.exit_code)
+
+
+@app.command("shell")
+def shell(
+    job_id: str = typer.Argument(..., help="Job ID (or prefix/hostname)"),
+    shell_bin: str = typer.Option("/bin/bash", "--shell", "-s", help="Shell binary"),
+):
+    """Open an interactive shell on a running job container (WebSocket PTY).
+
+    Connects via the director WebSocket proxy. Press Ctrl+] to disconnect.
+    """
+    import asyncio
+    import os
+    import sys
+
+    client = get_client()
+    job_id = _resolve_job_id(client, job_id)
+
+    console.print(f"[dim]Connecting to shell...[/dim]")
+
+    try:
+        import termios
+        import tty
+    except ImportError:
+        console.print("[red]❌ TTY libraries required (not available on Windows)[/red]")
+        raise typer.Exit(1)
+
+    async def _run_shell():
+        ws = await client.jobs.shell_connect(job_id, shell=shell_bin)
+
+        try:
+            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 Exception:
+                        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:  # Ctrl+]
+                                break
+                            await ws.send(data.decode(errors="replace"))
+                    except Exception:
+                        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]")
+        finally:
+            await ws.close()
+
+    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)

{hypercli_cli-0.9.2 → hypercli_cli-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "0.9.2"
+version = "1.0.1"
 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",