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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.13.3
+Version: 0.15.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.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.13.3"
+version = "0.15.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.15.0}/qbraid_cli/agents/app.py

@@ -3,13 +3,15 @@
 
 """Agents CLI - Monitor and manage AI coding agent sessions."""
 
+import inspect
 import os
 import re
 import signal
 import time
 from datetime import datetime
+from enum import Enum
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import click
 import typer
@@ -1096,10 +1098,59 @@ def _interactive_attach(console_: Console) -> str:
     return selected
 
 
+class ApprovalMode(str, Enum):
+    """How much the agent asks before acting.
+
+    A launched agent is detached, so a confirmation prompt has nobody to
+    answer it — ``auto`` is the mode for anything you intend to leave running.
+    """
+
+    ASK = "ask"
+    AUTO = "auto"
+
+
+def _approval_kwargs(method: Callable[..., Any], approval: Optional[str]) -> Dict[str, Any]:
+    """Forward ``approval`` only to a qbraid-core new enough to accept it.
+
+    The CLI's floor is qbraid-core>=0.5.0, which predates the parameter. Passing
+    it unconditionally would raise TypeError on EVERY launch there, not only
+    when --approval was used — so detect support and, when the user actually
+    asked for a mode we cannot honour, say so plainly instead of forwarding it.
+
+    A Mock reports ``(*args, **kwargs)``; VAR_KEYWORD therefore counts as
+    support, which is both correct in general and keeps test doubles working.
+    """
+    try:
+        params = inspect.signature(method).parameters
+        supported = "approval" in params or any(
+            param.kind is inspect.Parameter.VAR_KEYWORD for param in params.values()
+        )
+    except (TypeError, ValueError):  # pragma: no cover - non-introspectable callable
+        supported = True
+
+    if supported:
+        return {"approval": approval}
+
+    if approval is not None:
+        try:
+            from qbraid_core import __version__ as core_version
+        except ImportError:  # pragma: no cover
+            core_version = "unknown"
+        handle_error(
+            error_type="UnsupportedOptionError",
+            message=(
+                f"--approval requires a newer qbraid-core (installed: {core_version}). "
+                "Upgrade with: pip install -U qbraid-core"
+            ),
+            include_traceback=False,
+        )
+    return {}
+
+
 @agents_app.command("launch")
 def agents_launch(
     tool: Optional[str] = typer.Option(
-        None, "--tool", "-t", help="Agent tool (claude, claude-auto, codeq, codex)"
+        None, "--tool", "-t", help="Agent tool (claude, codeq, codex; claude-auto = claude --approval auto)"
     ),
     cwd: Optional[str] = typer.Option(None, "--cwd", help="Working directory"),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Agent name"),
@@ -1116,10 +1167,21 @@ def agents_launch(
     compute: Optional[str] = typer.Option(
         None, "--compute", "-c", help="SSH alias for remote compute server"
     ),
+    approval: Optional[ApprovalMode] = typer.Option(
+        None,
+        "--approval",
+        help="ask: the agent confirms before acting. auto: it acts without asking.",
+    ),
 ):
     """Launch an AI coding agent.
 
     Starts the agent in a managed tmux session.
+
+    The agent runs detached, so nothing is watching its confirmation prompts.
+    Pass --approval auto for an agent you intend to leave running: it starts
+    the tool in its own non-interactive mode instead of parking on a prompt
+    until you come back. Approval mode is remembered, so `qbraid agents
+    resume` restores it.
     """
     try:
         from qbraid_core.services.agents import AgentLauncher, AgentLauncherError
@@ -1148,6 +1210,7 @@ def agents_launch(
                 instructions=instructions,
                 agent_type=agent_type,
                 tags=tag,
+                **_approval_kwargs(launcher.remote_launch, approval.value if approval else None),
             )
         else:
 
@@ -1164,6 +1227,7 @@ def agents_launch(
                 parent_session_id=parent,
                 team_id=team,
                 tags=tag,
+                **_approval_kwargs(launcher.launch, approval.value if approval else None),
                 progress_callback=_clone_progress if repo else None,
             )
 
@@ -1334,12 +1398,15 @@ def agents_resume(
                     if original:
                         tool_value = original.tool.value if original.tool else "claude"
                         fork_name = name or f"{tmux_win}-fork"
-                        # Launch fresh with same tool and cwd
+                        # Launch fresh with same tool and cwd.
                         session = launcher.launch(
                             tool=tool_value,
                             cwd=original.cwd,
                             name=fork_name,
                             instructions=None,
+                            # A fork of a detached agent must not quietly
+                            # become one that waits for a human.
+                            **_approval_kwargs(launcher.launch, getattr(original, "approval", None)),
                         )
                     else:
                         console.print("[red]Could not find original session to fork.[/red]")

{qbraid_cli-0.13.3 → qbraid_cli-0.15.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")