qbraid-cli 0.16.15__tar.gz → 0.16.17__tar.gz

{qbraid_cli-0.16.15/qbraid_cli.egg-info → qbraid_cli-0.16.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.16.15
+Version: 0.16.17
 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.5.0
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: qbraid-core>=0.6.34
+Requires-Dist: qbraid-core>=0.6.43
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.6.34; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.43; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.6.34; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.43; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.16.15"
+version = "0.16.17"
 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.5.0",
     "questionary>=2.0.0",
-    "qbraid-core>=0.6.34",
+    "qbraid-core>=0.6.43",
 ]
 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.6.34"]
-envs = ["qbraid-core[environments]>=0.6.34"]
+compute = ["qbraid-core[compute]>=0.6.43"]
+envs = ["qbraid-core[environments]>=0.6.43"]
 dev = ["isort", "black", "pytest", "pytest-cov", "pytest-asyncio"]
 
 [project.scripts]

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17}/qbraid_cli/agents/queue.py

@@ -25,15 +25,17 @@ _MAX_RESPONSE = 2 * 1024 * 1024
 _SSH_TIMEOUT = 120
 _STATES = {"queued", "sending", "sent", "uncertain", "cancelled", "stale", "expired", "resolved"}
 _ACTION_STATES = {"queue_edit": "queued", "queue_cancel": "cancelled", "queue_resolve": "resolved"}
+_HOLD_CAPABILITY = "message-queue-hold-v1"
 
 
 class QueueCommandError(Exception):
     """A safe failure with a request identifier for reconciliation."""
 
-    def __init__(self, code, message, request_id=None):
+    def __init__(self, code, message, request_id=None, *, retryable=False):
         super().__init__(message)
         self.code = code
         self.request_id = request_id
+        self.retryable = retryable
 
 
 def _plain(value, multiline=False):
@@ -112,6 +114,59 @@ def _valid_receipt(value, session_id, machine_id):
     )
 
 
+def _valid_hold(value, session_id, binding, *, state="held"):
+    """Validate the Core hold schema and exact destination binding."""
+    keys = {
+        "id",
+        "sessionId",
+        "expectedRuntime",
+        "receiver",
+        "machineId",
+        "bootId",
+        "turn",
+        "revision",
+        "state",
+        "reason",
+        "createdAt",
+        "updatedAt",
+    }
+    if not isinstance(value, dict) or set(value) != keys or not _valid_runtime(value["expectedRuntime"]):
+        return False
+    runtime = value["expectedRuntime"]
+    if set(runtime) != {"pid", "startedAt", "tool", "terminalId", "serverId", "transcriptPath"}:
+        return False
+    receiver = value["receiver"]
+    native = receiver is None and all(
+        isinstance(runtime[key], str) and runtime[key] for key in ("terminalId", "serverId")
+    )
+    tmux = (
+        runtime["terminalId"] is None
+        and runtime["serverId"] is None
+        and isinstance(receiver, dict)
+        and bool(receiver)
+        and len(json.dumps(receiver)) <= 4096
+    )
+    return all(
+        (
+            _canonical_uuid(value["id"]),
+            value["sessionId"] == session_id,
+            value["machineId"] == binding["expectedMachineId"],
+            value["bootId"] == binding["expectedBootId"],
+            _stamp(runtime["startedAt"]),
+            isinstance(runtime["transcriptPath"], str) and bool(runtime["transcriptPath"]),
+            native or tmux,
+            isinstance(value["turn"], str) and re.fullmatch(r"[0-9a-f]{64}", value["turn"]),
+            isinstance(value["revision"], int)
+            and not isinstance(value["revision"], bool)
+            and value["revision"] > 0,
+            value["state"] == state,
+            isinstance(value["reason"], str),
+            _stamp(value["createdAt"]),
+            _stamp(value["updatedAt"]),
+        )
+    )
+
+
 def _new_protocol():
     try:
         from qbraid_core.services.agents.machine_protocol import MachineProtocol
@@ -281,7 +336,10 @@ class Destination:
                     "UNKNOWN_OUTCOME", "Unconfirmed destination error; inspect request status.", rid
                 )
             raise QueueCommandError(
-                error.get("code", "OPERATION_FAILED"), error.get("message", "Request failed."), rid
+                error.get("code", "OPERATION_FAILED"),
+                error.get("message", "Request failed."),
+                rid,
+                retryable=error.get("retryable") is True,
             )
         result = response.get("result")
         if not isinstance(result, dict):
@@ -381,6 +439,10 @@ def _emit(result, json_output, request_id=None, *, ok=True):
             envelope["requestId"] = request_id
         typer.echo(json.dumps(envelope, ensure_ascii=True))
     elif "messages" in result:
+        if result.get("hold"):
+            hold = result["hold"]
+            typer.echo(f"Queue paused. Hold {_plain(hold['id'])}, revision {_plain(hold['revision'])}.")
+            typer.echo("Use queue continue with this hold ID and revision to allow automatic delivery.")
         for row in result["messages"]:
             typer.echo(f"{_plain(row['id'])}  {_plain(row['state'])}  revision {_plain(row['revision'])}")
             prose = _plain(row["text"], multiline=True).replace("\n", "\n  ")
@@ -396,18 +458,64 @@ def _emit(result, json_output, request_id=None, *, ok=True):
         typer.echo(status)
         if result.get("reason"):
             typer.echo(_plain(result["reason"]))
+    elif result.get("interruptRequested") is True:
+        typer.echo("Interrupt requested; queued input is paused.")
+    elif isinstance(result.get("hold"), dict) and result["hold"].get("state") == "released":
+        typer.echo("Queue continued. A running watcher will deliver when the agent is ready.")
+    elif result.get("waiting") == "BUSY":
+        typer.echo("Queue is busy; the watcher will retry on its next tick.")
+    elif "delivered" in result and isinstance(result["delivered"], list):
+        typer.echo(f"Delivered {len(result['delivered'])} queued message(s).")
+    elif isinstance(result.get("state"), str):
+        typer.echo(f"Request status: {_plain(result['state'])}")
+    elif type(result.get("canInterrupt")) is bool:  # pylint: disable=unidiomatic-typecheck
+        if result["canInterrupt"]:
+            typer.echo("Interrupt is available for the verified active turn.")
+        else:
+            reason = result.get("reason")
+            typer.echo(
+                f"Interrupt unavailable: {_plain(reason)}"
+                if isinstance(reason, str)
+                else "Interrupt unavailable."
+            )
     else:
-        typer.echo(_plain(json.dumps(result, ensure_ascii=True)))
+        # Never serialize arbitrary protocol results to a human terminal. Some
+        # operations include receiver identities and transcript paths.
+        typer.echo("Operation completed.")
 
 
 def _mutation(destination, operation, json_output, request_id, **fields):
     rid = _uuid(request_id)
     # Written before crossing the transport, so even Ctrl+C leaves the ID visible.
     typer.echo(f"Request ID: {rid}", err=True)
-    result = destination.call(operation, rid, **fields)
+    result = None
+    for attempt in range(4):
+        try:
+            result = destination.call(operation, rid, **fields)
+            break
+        except QueueCommandError as error:
+            # Core marks only queue-lock refusals that happened before any
+            # durable state or terminal write as retryable. A BUSY code alone
+            # is insufficient: transport-queue BUSY may not carry that proof.
+            if not error.retryable or error.code != "BUSY" or attempt == 3:
+                raise
+            time.sleep(0.1 * (2**attempt))
+    assert result is not None  # every successful destination call returns a JSON object
     if operation == "interrupt":
         confirmed = (
-            result.get("interruptRequested") is True and result.get("sessionId") == fields["sessionId"]
+            result.get("interruptRequested") is True
+            and result.get("sessionId") == fields["sessionId"]
+            and _valid_hold(result.get("hold"), fields["sessionId"], destination.binding)
+            and result["hold"]["expectedRuntime"] == fields["expectedRuntime"]
+            and result["hold"]["turn"] == fields["expectedTurn"]
+        )
+    elif operation == "queue_resume":
+        hold = result.get("hold")
+        confirmed = (
+            _valid_hold(hold, fields["sessionId"], destination.binding, state="released")
+            and hold["id"] == fields["holdId"]
+            and hold["revision"] == fields["revision"] + 1
+            and hold["expectedRuntime"] == fields["expectedRuntime"]
         )
     else:
         expected_id = rid if operation == "queue_enqueue" else fields["messageId"]
@@ -463,8 +571,8 @@ def enqueue(
         )
         if not json_output:
             typer.echo(
-                "Queued input needs a running queue watcher on the destination. "
-                "Sent means terminal submission, not a model response."
+                "Queued input needs a running queue watcher. Check queue list for its status; "
+                "if paused, use queue continue with the displayed hold ID and revision."
             )
 
 
@@ -482,12 +590,29 @@ def list_messages(
         messages: list[dict] = []
         seen, seen_ids = set(), set()
         cursor = None
+        hold = None
+        hold_supported = _HOLD_CAPABILITY in destination.snapshot["capabilities"]
         for _ in range(257):
             page = destination.call(
                 "queue_list", sessionId=session_id, **({"cursor": cursor} if cursor else {})
             )
             if not isinstance(page.get("messages"), list) or "nextCursor" not in page:
                 raise QueueCommandError("INVALID_RESPONSE", "Invalid queue listing.")
+            if hold_supported:
+                current_hold = page.get("hold")
+                if (
+                    "hold" not in page
+                    or current_hold is not None
+                    and not _valid_hold(current_hold, session_id, destination.binding)
+                ):
+                    raise QueueCommandError("INVALID_RESPONSE", "Invalid queue hold receipt.")
+                if current_hold is not None and current_hold["expectedRuntime"] != destination.runtime(
+                    session_id
+                ):
+                    raise QueueCommandError("QUEUE_CHANGED", "The paused runtime changed; list it again.")
+                if cursor is not None and current_hold != hold:
+                    raise QueueCommandError("QUEUE_CHANGED", "The queue hold changed; list it again.")
+                hold = current_hold
             for row in page["messages"]:
                 if (
                     not _valid_receipt(row, session_id, destination.snapshot["machineId"])
@@ -499,7 +624,10 @@ def list_messages(
                 messages.append(row)
             cursor = page["nextCursor"]
             if cursor is None:
-                _emit({"messages": messages, "nextCursor": None}, json_output)
+                _emit(
+                    {"messages": messages, "nextCursor": None, **({"hold": hold} if hold_supported else {})},
+                    json_output,
+                )
                 return
             if (
                 not _canonical_uuid(cursor)
@@ -512,6 +640,33 @@ def list_messages(
         raise QueueCommandError("QUEUE_CHANGED", "Queue pagination changed; start the list again.")
 
 
+@queue_app.command("continue")
+def continue_queue(
+    session_id: str = typer.Argument(..., help="Exact destination session ID."),
+    hold_id: str = typer.Argument(..., help="Hold UUID shown by queue list."),
+    revision: int = typer.Option(..., "--revision", min=1, help="Hold revision shown by queue list."),
+    compute: Optional[str] = typer.Option(None, "--compute"),
+    request_id: Optional[str] = typer.Option(None, "--request-id"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Continue this paused queue.
+
+    Releases only the displayed hold. The watcher still checks turn completion,
+    pending approvals and uncertain messages; no input is sent by this command.
+    """
+    with _action(json_output, compute, _HOLD_CAPABILITY) as destination:
+        _mutation(
+            destination,
+            "queue_resume",
+            json_output,
+            request_id,
+            sessionId=session_id,
+            expectedRuntime=destination.runtime(session_id),
+            holdId=_uuid(hold_id),
+            revision=revision,
+        )
+
+
 @queue_app.command("edit")
 def edit(
     session_id: str = typer.Argument(...),
@@ -634,7 +789,12 @@ def watch(
             raise QueueCommandError(
                 "UNSUPPORTED_OPERATION", "Update qbraid-core to host queued delivery."
             ) from None
-        watcher = MessageQueue(destination.protocol)
+        # Opt in only when this CLI and destination share the hold contract.
+        # Older Core versions retain their original constructor signature.
+        watcher_options = (
+            {"track_native_holds": True} if _HOLD_CAPABILITY in destination.snapshot["capabilities"] else {}
+        )
+        watcher = MessageQueue(destination.protocol, **watcher_options)
         if not once and not json_output:
             typer.echo(f"Watching this machine's queue every {interval:g}s. Ctrl+C pauses delivery.")
         try:
@@ -670,11 +830,18 @@ def interrupt(
 ):
     """Interrupt one verified active turn.
 
-    Request one Escape, without ending the agent process.
+    Request one Escape and pause queued input, without ending the agent process.
     """
     with _action(json_output, compute, "interrupt-v1") as destination:
+        if _HOLD_CAPABILITY not in destination.snapshot["capabilities"]:
+            raise QueueCommandError(
+                "UNSUPPORTED_OPERATION",
+                "Update qbraid-core on this destination to pause queued input safely when interrupting.",
+            )
         runtime = destination.runtime(session_id)
-        offer = destination.call("interrupt_preflight", sessionId=session_id, expectedRuntime=runtime)
+        offer = destination.call(
+            "interrupt_preflight", sessionId=session_id, expectedRuntime=runtime, requireQueueHold=True
+        )
         if preflight:
             available = offer.get("canInterrupt") is True
             _emit(
@@ -697,6 +864,7 @@ def interrupt(
             sessionId=session_id,
             expectedRuntime=runtime,
             expectedTurn=offer["turn"],
+            requireQueueHold=True,
         )
         if not json_output:
-            typer.echo("Interrupt requested. This acknowledges Escape input, not that the agent has stopped.")
+            typer.echo("This acknowledges Escape input, not that the agent has stopped.")

qbraid_cli-0.16.17/qbraid_cli/artifacts/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2026, qBraid Development Team
+# All rights reserved.
+"""Artifact CLI commands."""
+
+from .app import artifacts_app
+
+__all__ = ["artifacts_app"]

qbraid_cli-0.16.17/qbraid_cli/artifacts/app.py

@@ -0,0 +1,245 @@
+# Copyright (c) 2026, qBraid Development Team
+# All rights reserved.
+"""CLI surfaces for hosted HTML artifacts; all operations delegate to Core."""
+
+import json
+import re
+from enum import Enum
+from pathlib import Path
+from typing import Callable, Optional, TypeVar
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from qbraid_cli.agents.work import _safe
+from qbraid_cli.handlers import handle_error
+
+artifacts_app = typer.Typer(
+    help="Publish and share standalone HTML.\n\nLists show only your artifacts.", no_args_is_help=True
+)
+
+CORE_MODULE = "qbraid_core.services.artifacts"
+OLD_CORE = "qbraid artifacts requires qbraid-core 0.6.43 or newer; run: pip install -U qbraid-core"
+PUBLIC_NOTE = "Anyone with the link can view this artifact."
+MAX_ERROR = 300
+_ID = re.compile(r"[a-f0-9]{32}")
+_EMAIL = re.compile(r"[^@\s]+@[^@\s]+\.[^@\s]+")
+# An error page (HTML/XML) rather than an API message: show the status instead.
+_MARKUP = re.compile(r"<\s*[!/?a-zA-Z]")
+_Result = TypeVar("_Result")
+
+
+class Access(str, Enum):
+    """Artifact visibility."""
+
+    PRIVATE = "private"
+    SHARED = "shared"
+    PUBLIC = "public"
+
+
+def _client():
+    from qbraid_core.services.artifacts import ArtifactsClient
+
+    return ArtifactsClient()
+
+
+def _plain(value) -> str:
+    """API text made terminal-inert: no controls, escapes, bidi or invisible marks."""
+    return _safe(value if isinstance(value, str) else str(value)).plain
+
+
+def _error_text(err: Exception) -> str:
+    if isinstance(err, ModuleNotFoundError) and (err.name or "").startswith(CORE_MODULE):
+        return OLD_CORE
+    if isinstance(err, UnicodeDecodeError):
+        return "The file is not valid UTF-8; save it as UTF-8 and try again"
+    text = str(err)
+    if _MARKUP.search(text):
+        status = getattr(err, "status_code", None)
+        text = "Artifact request failed" + (f" (HTTP {status})" if status else "")
+        return text + "; the API returned a non-JSON error page"
+    text = _plain(text)
+    return text if len(text) <= MAX_ERROR else text[: MAX_ERROR - 1] + "…"
+
+
+def _run(operation: Callable[..., _Result]) -> _Result:
+    """Run one operation with a client that is always closed; failures exit 1."""
+    client = None
+    try:
+        client = _client()
+        return operation(client)
+    except Exception as err:  # pylint: disable=broad-exception-caught
+        handle_error(message=_error_text(err), include_traceback=False)
+        raise  # unreachable: handle_error exits
+    finally:
+        if client is not None:
+            client.close()
+
+
+def _fail(message: str) -> None:
+    handle_error(message=message, include_traceback=False)
+
+
+def _check_id(slug: str) -> str:
+    if not _ID.fullmatch(slug):
+        raise typer.BadParameter("use the 32-character ID shown by 'qbraid artifacts list'")
+    return slug
+
+
+def _check_file(path: Optional[Path]) -> None:
+    """Say precisely why a file is refused before any request; Core re-checks."""
+    if path is None:
+        return
+    if path.is_symlink():
+        _fail("Symbolic links are not supported; pass the HTML file itself")
+    if path.suffix.lower() not in (".html", ".htm"):
+        _fail("Provide one .html or .htm file")
+
+
+def _check_email(email: str) -> str:
+    if not _EMAIL.fullmatch(email):
+        raise typer.BadParameter("Provide a valid email address")
+    return email
+
+
+def _dump(model) -> str:
+    # ASCII-escaped JSON: raw data for scripts, inert in a terminal.
+    return json.dumps(model.model_dump(mode="json", by_alias=True))
+
+
+def _emit(artifact, as_json: bool):
+    if as_json:
+        print(_dump(artifact))
+        return
+    print(f"{_plain(artifact.title)} ({_plain(artifact.visibility)})\n{_plain(artifact.url)}")
+    if artifact.visibility == "public":
+        print(PUBLIC_NOTE)
+
+
+ID_ARG = typer.Argument(
+    ..., metavar="ID", callback=_check_id, help="Artifact ID from 'qbraid artifacts list'."
+)
+EMAIL_OPT = typer.Option(..., "--email", callback=_check_email)
+
+
+@artifacts_app.command("publish")
+def publish(
+    file: Path = typer.Argument(..., exists=True, dir_okay=False),
+    title: Optional[str] = typer.Option(None, "--title"),
+    visibility: Access = typer.Option(Access.PRIVATE, "--visibility"),
+    as_json: bool = typer.Option(False, "--json"),
+    new: bool = typer.Option(False, "--new", help="Publish a copy even if this file is already published."),
+):
+    """Publish one standalone HTML file.
+
+    Publishing is immediate; there is no review queue. Publishing the same file
+    with the same title and access returns the existing artifact.
+    """
+    _check_file(file)
+    artifact = _run(
+        lambda client: client.publish(file, title=title, visibility=visibility.value, duplicate=new)
+    )
+    if artifact.created is False and not as_json:
+        print("Already published")
+    _emit(artifact, as_json)
+
+
+@artifacts_app.command("list")
+def list_artifacts(
+    page: int = typer.Option(1, min=1),
+    limit: int = typer.Option(50, min=1, max=100),
+    as_json: bool = typer.Option(False, "--json"),
+):
+    """List your published HTML artifacts.
+
+    This never lists a public or global catalog.
+    """
+    result = _run(lambda client: client.list_artifacts(page=page, limit=limit))
+    if as_json:
+        print(_dump(result))
+        return
+    # IDs never wrap or truncate so they can be copied; long titles and links fold.
+    table = Table()
+    table.add_column("ID", no_wrap=True, min_width=32)
+    table.add_column("Title", overflow="fold")
+    table.add_column("Access", no_wrap=True)
+    table.add_column("Link", overflow="fold")
+    for item in result.data:
+        table.add_row(*(Text(_plain(v)) for v in (item.slug, item.title, item.visibility, item.url)))
+    Console().print(table)
+    print(f"Page {page}; {result.pagination.total} artifacts total")
+
+
+@artifacts_app.command("get")
+def get(slug: str = ID_ARG, as_json: bool = typer.Option(False, "--json")):
+    """Show one artifact you can view."""
+    _emit(_run(lambda client: client.get_artifact(slug)), as_json)
+
+
+@artifacts_app.command("update")
+def update(
+    slug: str = ID_ARG,
+    file: Optional[Path] = typer.Option(None, "--file", exists=True, dir_okay=False),
+    title: Optional[str] = typer.Option(None, "--title"),
+    visibility: Optional[Access] = typer.Option(None, "--visibility"),
+    as_json: bool = typer.Option(False, "--json"),
+):
+    """Update HTML, title, or access.
+
+    The share link is preserved.
+    """
+    _check_file(file)
+    artifact = _run(
+        lambda client: client.update(
+            slug, path=file, title=title, visibility=visibility.value if visibility else None
+        )
+    )
+    _emit(artifact, as_json)
+
+
+@artifacts_app.command("share")
+def share(slug: str = ID_ARG, email: str = EMAIL_OPT, as_json: bool = typer.Option(False, "--json")):
+    """Grant a qBraid user viewing access.
+
+    The recipient must sign in. Send them the link after granting access.
+    """
+    _emit(_run(lambda client: client.share(slug, email)), as_json)
+
+
+@artifacts_app.command("revoke")
+def revoke(slug: str = ID_ARG, email: str = EMAIL_OPT, as_json: bool = typer.Option(False, "--json")):
+    """Remove a collaborator viewing grant.
+
+    Public artifacts remain accessible via their link.
+    """
+    _emit(_run(lambda client: client.revoke(slug, email)), as_json)
+
+
+@artifacts_app.command("unpublish")
+def unpublish(slug: str = ID_ARG, as_json: bool = typer.Option(False, "--json")):
+    """Make an artifact owner-only.
+
+    Disables both public and shared viewing.
+    """
+    _emit(_run(lambda client: client.update(slug, visibility="private")), as_json)
+
+
+@artifacts_app.command("delete")
+def delete(
+    slug: str = ID_ARG,
+    yes: bool = typer.Option(False, "--yes"),
+    as_json: bool = typer.Option(False, "--json"),
+):
+    """Delete an artifact and its HTML.
+
+    Use --yes in non-interactive scripts; --json requires --yes.
+    """
+    if as_json and not yes:
+        print(json.dumps({"deleted": False, "slug": slug, "error": "--json requires --yes"}))
+        raise typer.Exit(code=1)
+    if not yes:
+        typer.confirm("Delete this artifact and its HTML?", abort=True, err=True)
+    _run(lambda client: client.delete(slug))
+    print(json.dumps({"deleted": True, "slug": slug}) if as_json else "Artifact deleted")

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17}/qbraid_cli/main.py

@@ -13,6 +13,7 @@ from qbraid_cli.account import account_app
 from qbraid_cli.admin import admin_app
 from qbraid_cli.agents import agents_app
 from qbraid_cli.ai.app import ai_app
+from qbraid_cli.artifacts import artifacts_app
 from qbraid_cli.comms import comms_app
 from qbraid_cli.compute import compute_app
 from qbraid_cli.configure import configure_app
@@ -55,6 +56,7 @@ app.add_typer(devices_app, name="devices")
 app.add_typer(jobs_app, name="jobs")
 app.add_typer(projects_app, name="projects")
 app.add_typer(skills_app, name="skills")
+app.add_typer(artifacts_app, name="artifacts")
 app.add_typer(troubleshoot_app, name="troubleshoot")
 
 if ENVS_COMMANDS is True:

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.16.15
+Version: 0.16.17
 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.5.0
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: qbraid-core>=0.6.34
+Requires-Dist: qbraid-core>=0.6.43
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.6.34; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.43; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.6.34; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.43; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17}/qbraid_cli.egg-info/SOURCES.txt

@@ -30,6 +30,8 @@ qbraid_cli/agents/work.py
 qbraid_cli/ai/__init__.py
 qbraid_cli/ai/app.py
 qbraid_cli/ai/token.py
+qbraid_cli/artifacts/__init__.py
+qbraid_cli/artifacts/app.py
 qbraid_cli/comms/__init__.py
 qbraid_cli/comms/app.py
 qbraid_cli/compute/__init__.py

{qbraid_cli-0.16.15 → qbraid_cli-0.16.17}/qbraid_cli.egg-info/requires.txt

@@ -2,10 +2,10 @@ typer>=0.12.1
 rich>=10.11.0
 click<=8.5.0
 questionary>=2.0.0
-qbraid-core>=0.6.34
+qbraid-core>=0.6.43
 
 [compute]
-qbraid-core[compute]>=0.6.34
+qbraid-core[compute]>=0.6.43
 
 [dev]
 isort
@@ -15,4 +15,4 @@ pytest-cov
 pytest-asyncio
 
 [envs]
-qbraid-core[environments]>=0.6.34
+qbraid-core[environments]>=0.6.43