qbraid-cli 0.13.3__tar.gz → 0.14.0__tar.gz

{qbraid_cli-0.13.3/qbraid_cli.egg-info → qbraid_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.13.3
+Version: 0.14.0
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary
@@ -30,11 +30,11 @@ Requires-Dist: typer>=0.12.1
 Requires-Dist: rich>=10.11.0
 Requires-Dist: click<=8.3.3
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: qbraid-core>=0.3.11
+Requires-Dist: qbraid-core>=0.5.0
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.3.3; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.5.0; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.3.0; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.5.0; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.13.3 → qbraid_cli-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.13.3"
+version = "0.14.0"
 description = "Command Line Interface for interacting with all parts of the qBraid platform."
 readme = "README.md"
 authors = [{ name = "qBraid Development Team", email = "contact@qbraid.com" }]
@@ -32,7 +32,7 @@ dependencies = [
     "rich>=10.11.0",
     "click<=8.3.3",
     "questionary>=2.0.0",
-    "qbraid-core>=0.3.11",
+    "qbraid-core>=0.5.0",
 ]
 requires-python = ">= 3.10"
 
@@ -43,8 +43,8 @@ Documentation = "https://docs.qbraid.com/v2/cli/api-reference/qbraid"
 Discord = "https://discord.gg/KugF6Cnncm"
 
 [project.optional-dependencies]
-compute = ["qbraid-core[compute]>=0.3.3"]
-envs = ["qbraid-core[environments]>=0.3.0"]
+compute = ["qbraid-core[compute]>=0.5.0"]
+envs = ["qbraid-core[environments]>=0.5.0"]
 dev = ["isort", "black", "pytest", "pytest-cov", "pytest-asyncio"]
 
 [project.scripts]

{qbraid_cli-0.13.3 → qbraid_cli-0.14.0}/qbraid_cli/compute/app.py

@@ -7,13 +7,21 @@ from typing import Optional
 
 import typer
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 from qbraid_cli.handlers import handle_error, run_progress_task
 
+from .instances import (
+    _ON_DEMAND_WAIT_TIMEOUT,
+    _SUBSCRIPTION_WAIT_TIMEOUT,
+    _fail,
+    instances_app,
+    run_launch,
+    run_list,
+    run_stop,
+)
 from .profiles import profiles_app
-from .server import _print_unified_status_table, _select_bma_instance, server_app
+from .server import server_app
 from .ssh import ssh_app
 
 compute_app = typer.Typer(
@@ -29,16 +37,17 @@ compute_app = typer.Typer(
         "  \u2022 Connect VS Code or Cursor to a remote server\n"
         "  \u2022 Launch AI agents on more powerful hardware\n\n"
         "Quick start:\n"
-        "  qbraid compute up <profile>    # Start server + configure SSH\n"
-        "  qbraid compute status          # Check server status\n"
-        "  qbraid compute ssh connect     # SSH into running server\n"
-        "  qbraid compute down            # Stop server"
+        "  qbraid compute up <profile>          # Launch an instance + configure SSH\n"
+        "  qbraid compute status                # List your instances\n"
+        "  qbraid compute instances ...         # launch/start/stop/terminate/ssh/...\n"
+        "  qbraid compute down                  # Stop an instance"
     ),
     no_args_is_help=True,
 )
 console = Console()
 
 # Add subcommand groups
+compute_app.add_typer(instances_app, name="instances")
 compute_app.add_typer(profiles_app, name="profiles")
 compute_app.add_typer(server_app, name="server")
 compute_app.add_typer(ssh_app, name="ssh")
@@ -58,204 +67,88 @@ def _get_client():
 
 @compute_app.command("up")
 def compute_up(
-    profile_slug: str = typer.Argument(..., help="Profile slug to start"),
-    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Cluster ID"),
-    timeout: int = typer.Option(120, "--timeout", "-t", help="Server start timeout"),
+    profile_slug: str = typer.Argument(..., help="Profile slug to launch"),
+    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Subscription cluster ID"),
+    timeout: Optional[int] = typer.Option(
+        None,
+        "--timeout",
+        "-t",
+        help=f"Seconds to wait (default {_ON_DEMAND_WAIT_TIMEOUT} on-demand, "
+        f"{_SUBSCRIPTION_WAIT_TIMEOUT} subscription)",
+    ),
     no_ssh: bool = typer.Option(False, "--no-ssh", help="Skip SSH configuration"),
 ):
-    """Start server and configure SSH.
+    """Launch an instance and configure SSH.
 
-    Waits for the server to be ready. This is a convenience command that combines:
-    - qbraid compute server start <profile> --wait
-    - qbraid compute ssh setup
+    Alias for `qbraid compute instances launch <profile> --ssh`. On-demand
+    profiles always launch a new instance; the subscription server attaches
+    if it's already running.
 
     Example:
-        qbraid compute up 2vCPU_4GB
+        qbraid compute up gpu-l4
     """
     try:
-        client = _get_client()
-
-        # Check if server is already running
-        status = client.get_server_status(cluster_id)
-        if status.server_running:
-            console.print(f"[yellow]Server already running with profile: {status.current_profile}[/yellow]")
-            console.print()
-            if not no_ssh:
-                console.print("Configuring SSH...")
-                _setup_ssh(client, cluster_id)
-            return
-
-        # Start server
-        console.print(f"Starting server with profile '[cyan]{profile_slug}[/cyan]'...")
-
-        def start():
-            return client.start_server(profile_slug, cluster_id)
-
-        run_progress_task(
-            start,
-            description="Starting...",
-            include_error_traceback=False,
+        run_launch(
+            profile_slug,
+            wait=True,
+            ssh=not no_ssh,
+            timeout=timeout,
+            cluster_id=cluster_id,
+            client=_get_client(),
         )
-
-        # Wait for server
-        def wait():
-            return client.wait_for_server(timeout=timeout, cluster_id=cluster_id)
-
-        try:
-            status = run_progress_task(
-                wait,
-                description="Waiting for server to be ready...",
-                include_error_traceback=False,
-            )
-        except TimeoutError:
-            console.print(f"[yellow]Server did not start within {timeout}s[/yellow]")
-            console.print("Check status: qbraid compute server status")
-            raise typer.Exit(code=1)
-
-        # Configure SSH
-        if not no_ssh:
-            console.print()
-            _setup_ssh(client, cluster_id)
-
     except (typer.Exit, SystemExit):
         raise
-    except Exception as e:
-        handle_error(str(e))
-        raise typer.Exit(code=1)
-
-
-def _setup_ssh(client, cluster_id: Optional[str]):
-    """Configure SSH for the running server."""
-    from qbraid_core.services.compute import setup_qbraid_ssh
-
-    token_resp = client.get_session_token(cluster_id)
-    status = client.get_server_status(cluster_id)
-    username = status.user_info.name if status.user_info else token_resp.token.user
-
-    ssh_config = setup_qbraid_ssh(
-        username=username,
-        token=token_resp.token.token,
-        cluster_id=token_resp.cluster_id,
-    )
-
-    # Show connection info
-    panel_lines = [
-        "[bold cyan]SSH[/bold cyan]",
-        f"  {ssh_config['ssh_command']}",
-        "",
-        "[bold blue]VSCode[/bold blue]",
-        f"  {ssh_config['vscode_command']}",
-        "",
-        "[bold magenta]Cursor[/bold magenta]",
-        f"  {ssh_config['cursor_command']}",
-    ]
-
-    panel = Panel(
-        "\n".join(panel_lines),
-        title="Connect with",
-        border_style="green",
-    )
-    console.print(panel)
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        _fail(err)
 
 
 @compute_app.command("down")
 def compute_down(
-    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Cluster ID"),
+    target: Optional[str] = typer.Argument(
+        None, help="Instance: id, hash, label, profile slug, or 'subscription'"
+    ),
+    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Subscription cluster ID"),
+    instance: Optional[str] = typer.Option(None, "--instance", "-i", help="Same as the positional target"),
     force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
-    cleanup_ssh: bool = typer.Option(False, "--cleanup-ssh", help="Remove SSH config"),
+    cleanup_ssh: bool = typer.Option(False, "--cleanup-ssh", help="Remove the subscription SSH config"),
 ):
-    """Stop the running server.
+    """Stop an instance.
+
+    Alias for `qbraid compute instances stop`. With no target, stops your
+    running on-demand instance (asking which if several) or else the
+    subscription server.
 
     Example:
         qbraid compute down
-        qbraid compute down --cleanup-ssh
+        qbraid compute down trainer
     """
     try:
-        client = _get_client()
-
-        # Route to a BMA instance if an on-demand instance is running.
-        target_instance = _select_bma_instance(client, None, "stop")
-        if target_instance:
-            if not force:
-                confirm = typer.confirm(f"Stop instance {target_instance}?")
-                if not confirm:
-                    console.print("Cancelled.")
-                    raise typer.Exit(code=0)
-
-            def stop_instance():
-                return client.stop_bma_instance(target_instance)
-
-            inst = run_progress_task(
-                stop_instance,
-                description=f"Stopping {target_instance}...",
-                include_error_traceback=False,
-            )
-            console.print(f"[green]Stopping instance {inst.instance_id}[/green]")
-            console.print(f"  Status: {inst.status.value}")
-            console.print("[dim]Poll with: qbraid compute status[/dim]")
-            return
-
-        # Check if a legacy server is running
-        status = client.get_server_status(cluster_id)
-        if not status.server_running and not status.server_starting:
-            console.print("[dim]No server is currently running.[/dim]")
-            return
-
-        if not force:
-            profile = status.current_profile or "unknown"
-            confirm = typer.confirm(f"Stop server (profile: {profile})?")
-            if not confirm:
-                console.print("Cancelled.")
-                raise typer.Exit(code=0)
-
-        # Stop server
-        def stop():
-            return client.stop_server(cluster_id)
-
-        run_progress_task(
-            stop,
-            description="Stopping server...",
-            include_error_traceback=False,
-        )
-
-        # Cleanup SSH if requested
+        run_stop(target or instance, yes=force, cluster_id=cluster_id, client=_get_client())
         if cleanup_ssh:
             from qbraid_core.services.compute.ssh import remove_pod_ssh_config
 
-            # Remove default qbraid-lab config
-            removed = remove_pod_ssh_config("lab")
-            if removed:
+            if remove_pod_ssh_config("lab"):
                 console.print("[dim]SSH config removed.[/dim]")
-
     except (typer.Exit, SystemExit):
         raise
-    except Exception as e:
-        handle_error(str(e))
-        raise typer.Exit(code=1)
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        _fail(err)
 
 
 @compute_app.command("status")
 def compute_status(
-    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Cluster ID"),
+    cluster_id: Optional[str] = typer.Option(None, "--cluster", "-c", help="Subscription cluster ID"),
 ):
-    """Check server status.
+    """List your instances.
 
-    Quick status check (alias for 'server status').
+    Alias for `qbraid compute instances list`.
     """
     try:
-        client = _get_client()
-        status = client.get_server_status(cluster_id)
-        instances = _print_unified_status_table(client, status)
-
-        if not status.server_running and not status.server_starting and not instances:
-            console.print()
-            console.print("[dim]Start with: qbraid compute up <profile>[/dim]")
-
+        run_list(cluster_id, client=_get_client())
     except (typer.Exit, SystemExit):
         raise
-    except Exception as e:
-        handle_error(str(e))
-        raise typer.Exit(code=1)
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        _fail(err)
 
 
 @compute_app.command("list")