qbraid-cli 0.15.1__tar.gz → 0.15.3__tar.gz

{qbraid_cli-0.15.1/qbraid_cli.egg-info → qbraid_cli-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.15.1
+Version: 0.15.3
 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.5.0
+Requires-Dist: qbraid-core>=0.6.5
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.5.0; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.5; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.5.0; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.5; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.15.1"
+version = "0.15.3"
 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.5.0",
+    "qbraid-core>=0.6.5",
 ]
 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.5.0"]
-envs = ["qbraid-core[environments]>=0.5.0"]
+compute = ["qbraid-core[compute]>=0.6.5"]
+envs = ["qbraid-core[environments]>=0.6.5"]
 dev = ["isort", "black", "pytest", "pytest-cov", "pytest-asyncio"]
 
 [project.scripts]

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3}/qbraid_cli/agents/app.py

@@ -4,6 +4,7 @@
 """Agents CLI - Monitor and manage AI coding agent sessions."""
 
 import inspect
+import json
 import os
 import re
 import signal
@@ -207,7 +208,6 @@ def agents_register():
 
     Reads session data from stdin JSON (used by hooks).
     """
-    import json
     import sys
 
     try:
@@ -237,7 +237,6 @@ def agents_deregister():
 
     Reads session data from stdin JSON (used by hooks).
     """
-    import json
     import sys
 
     try:
@@ -381,10 +380,9 @@ def agents_list(
 
         # JSON output mode
         if json_output:
-            import json as _json
 
             output = [s.model_dump(mode="json", by_alias=True, exclude_none=True) for s in sessions]
-            print(_json.dumps(output, indent=2))
+            print(json.dumps(output, indent=2))
             return
 
         # Sort
@@ -1109,6 +1107,57 @@ class ApprovalMode(str, Enum):
     AUTO = "auto"
 
 
+class ExecutionMode(str, Enum):
+    """Codex command isolation, independent of approval prompts."""
+
+    NATIVE = "native"
+    WORKSPACE = "workspace"
+    CONTAINER = "container"
+
+
+def _execution_kwargs(method: Callable[..., Any], mode: Optional[str]) -> Dict[str, Any]:
+    """Never silently discard an explicitly selected execution policy."""
+    if mode is None:
+        return {}
+    try:
+        params = inspect.signature(method).parameters
+        supported = "execution_mode" in params or any(
+            param.kind is inspect.Parameter.VAR_KEYWORD for param in params.values()
+        )
+    except (TypeError, ValueError):
+        supported = False
+    if not supported:
+        handle_error(
+            error_type="UnsupportedOptionError",
+            message="--execution-mode requires a newer qbraid-core. Upgrade qbraid-core first.",
+            include_traceback=False,
+        )
+    return {"execution_mode": mode}
+
+
+def _request_id_kwargs(method: Callable[..., Any], request_id: Optional[str]) -> Dict[str, Any]:
+    """Require explicit Core support before promising remote replay protection."""
+    if request_id is None:
+        return {}
+    try:
+        params = inspect.signature(method).parameters
+        supported = "request_id" in params or any(
+            param.kind is inspect.Parameter.VAR_KEYWORD for param in params.values()
+        )
+    except (TypeError, ValueError):
+        supported = False
+    if not supported:
+        handle_error(
+            error_type="UnsupportedOptionError",
+            message=(
+                "--request-id requires a newer qbraid-core. "
+                "Upgrade Core on this machine and the destination before launching."
+            ),
+            include_traceback=False,
+        )
+    return {"request_id": request_id}
+
+
 def _approval_kwargs(method: Callable[..., Any], approval: Optional[str]) -> Dict[str, Any]:
     """Forward ``approval`` only to a qbraid-core new enough to accept it.
 
@@ -1147,6 +1196,115 @@ def _approval_kwargs(method: Callable[..., Any], approval: Optional[str]) -> Dic
     return {}
 
 
+@agents_app.command("readiness")
+def agents_readiness(
+    tool: str = typer.Option(..., "--tool", help="Provider to inspect: claude, codex, or codeq."),
+    cwd: Optional[str] = typer.Option(None, "--cwd", help="Working directory on this machine."),
+    approval: Optional[ApprovalMode] = typer.Option(None, "--approval"),
+    execution_mode: Optional[ExecutionMode] = typer.Option(None, "--execution-mode"),
+    json_output: bool = typer.Option(False, "--json", help="Print structured checks and recovery actions."),
+    verify_auth: bool = typer.Option(
+        False,
+        "--verify-auth",
+        help="Explicitly check provider authentication; does not sign in or transfer credentials.",
+    ),
+):
+    """Check this destination before launch.
+
+    Known blockers exit with status 1.
+    """
+    try:
+        from qbraid_core.services.agents.readiness import agent_readiness
+    except ImportError:
+        typer.echo("Destination readiness requires a newer qbraid-core.", err=True)
+        raise typer.Exit(2) from None
+    report = agent_readiness(
+        tool,
+        cwd=cwd,
+        approval=approval.value if approval else None,
+        execution_mode=execution_mode.value if execution_mode else None,
+        verify_auth=verify_auth,
+    )
+    if json_output:
+        print(json.dumps(report))
+    else:
+        for check in report["checks"]:
+            console.print(f"{check['id']}: {check['state']} — {check['message']}", markup=False)
+        for action in report.get("auth", {}).get("actions", []):
+            if action.get("command"):
+                console.print(str(action["command"]), markup=False)
+        console.print("Unknown checks are not proof of readiness. Use --json for recovery actions.")
+    if not report["ready"]:
+        raise typer.Exit(1)
+
+
+@agents_app.command("machine")
+def agents_machine(
+    serve: bool = typer.Option(
+        False, "--serve", help="Serve JSON lines over authenticated SSH stdin/stdout."
+    ),
+    once: bool = typer.Option(
+        False, "--once", help="Read one JSON request from stdin and return one response."
+    ),
+):
+    """Serve the fleet machine protocol.
+
+    Protocol v1 writes only JSON frames to stdout.
+    """
+    if serve == once:
+        raise typer.BadParameter("Choose exactly one of --serve or --once.")
+    try:
+        from qbraid_core.services.agents.machine_protocol import serve_machine
+    except ImportError:
+        typer.echo("Machine protocol requires a newer qbraid-core.", err=True)
+        raise typer.Exit(2) from None
+    serve_machine(once=once)
+
+
+@agents_app.command("settings")
+def agents_settings(
+    execution_mode: Optional[ExecutionMode] = typer.Option(
+        None, "--execution-mode", help="Save the Codex execution default for this machine."
+    ),
+    reset: bool = typer.Option(False, "--reset", help="Remove this machine's execution preference."),
+    json_output: bool = typer.Option(
+        False, "--json", help="Print structured settings and sandbox readiness."
+    ),
+):
+    """Inspect or configure agent execution.
+
+    Defaults are shared by the CLI and dashboard on this machine.
+    """
+    try:
+        from qbraid_core.services.agents.execution import execution_settings, set_execution_default
+
+        if reset and execution_mode is not None:
+            raise ValueError("Choose --reset or --execution-mode, not both.")
+        if reset:
+            settings = set_execution_default(None)
+        elif execution_mode is not None:
+            settings = set_execution_default(execution_mode.value)
+        else:
+            settings = execution_settings()
+        if json_output:
+            print(json.dumps(settings))
+        else:
+            console.print(
+                "Codex execution default: " + (settings["execution_mode"] or "not set (legacy defaults)")
+            )
+            console.print("Scope: this machine; applies to new CLI and dashboard launches.")
+            console.print(settings["workspace"]["detail"])
+            console.print("Override one launch with --execution-mode native|workspace|container.")
+    except ImportError:
+        handle_error(
+            error_type="UnsupportedOptionError",
+            message="Agent execution settings require a newer qbraid-core.",
+            include_traceback=False,
+        )
+    except Exception as error:
+        handle_error(error_type=type(error).__name__, message=str(error), include_traceback=False)
+
+
 @agents_app.command("launch")
 def agents_launch(
     tool: Optional[str] = typer.Option(
@@ -1167,6 +1325,18 @@ def agents_launch(
     compute: Optional[str] = typer.Option(
         None, "--compute", "-c", help="SSH alias for remote compute server"
     ),
+    request_id: Optional[str] = typer.Option(
+        None, "--request-id", help="Remote launch UUID retained for reconciling an interrupted request."
+    ),
+    execution_mode: Optional[ExecutionMode] = typer.Option(
+        None,
+        "--execution-mode",
+        help=(
+            "Codex only: native uses Codex defaults; workspace adds its workspace sandbox; "
+            "container uses current user access without an extra Codex sandbox (no sudo). "
+            "Omitted preserves existing behavior. Independent of --approval."
+        ),
+    ),
     approval: Optional[ApprovalMode] = typer.Option(
         None,
         "--approval",
@@ -1177,11 +1347,11 @@ def agents_launch(
 
     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.
+    Detached agents may wait for approval until you open their terminal or dashboard.
+    Approval and execution mode are independent and remembered for resume.
+    --approval auto disables approval prompts; --execution-mode container
+    explicitly uses the current user's access without an extra Codex sandbox.
+    Choose it only where you trust the surrounding machine/container isolation.
     """
     try:
         from qbraid_core.services.agents import AgentLauncher, AgentLauncherError
@@ -1197,6 +1367,12 @@ def agents_launch(
             tag = tag or result.get("tags")
             repo = repo or result.get("repo")
 
+        if request_id is not None:
+            import uuid
+
+            if not compute or str(uuid.UUID(request_id)) != request_id:
+                raise AgentLauncherError("--request-id requires --compute and a canonical UUID.")
+
         launcher = AgentLauncher()
 
         # Remote launch via SSH
@@ -1210,7 +1386,9 @@ def agents_launch(
                 instructions=instructions,
                 agent_type=agent_type,
                 tags=tag,
+                **_request_id_kwargs(launcher.remote_launch, request_id),
                 **_approval_kwargs(launcher.remote_launch, approval.value if approval else None),
+                **_execution_kwargs(launcher.remote_launch, execution_mode.value if execution_mode else None),
             )
         else:
 
@@ -1228,6 +1406,7 @@ def agents_launch(
                 team_id=team,
                 tags=tag,
                 **_approval_kwargs(launcher.launch, approval.value if approval else None),
+                **_execution_kwargs(launcher.launch, execution_mode.value if execution_mode else None),
                 progress_callback=_clone_progress if repo else None,
             )
 
@@ -1287,7 +1466,9 @@ def _interactive_resume(console_: Console) -> str:
     import questionary
 
     registry = _get_registry()
-    all_sessions = registry.load_registry().sessions
+    # Use the display enumeration so retained transcript aliases do not appear
+    # as duplicate choices. Stopped sessions remain available for resuming.
+    all_sessions = registry.search_sessions(include_stopped=True)
 
     # Show sessions that could be resumed (have a session_id, prefer recent)
     resumable = sorted(
@@ -1345,6 +1526,9 @@ def agents_resume(
         None, help="Session ID, prefix, or name. Omit for interactive picker."
     ),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Agent name for the resumed session"),
+    execution_mode: Optional[ExecutionMode] = typer.Option(
+        None, "--execution-mode", help="Override the recorded Codex execution mode for this resume."
+    ),
 ):
     """Resume a previous agent session.
 
@@ -1361,7 +1545,11 @@ def agents_resume(
 
         # Try resume — handle active session and ambiguous matches
         try:
-            session = launcher.resume(session_id=session_id, name=name)
+            session = launcher.resume(
+                session_id=session_id,
+                name=name,
+                **_execution_kwargs(launcher.resume, execution_mode.value if execution_mode else None),
+            )
         except AgentLauncherError as e:
             err_msg = str(e)
 
@@ -1407,6 +1595,14 @@ def agents_resume(
                             # A fork of a detached agent must not quietly
                             # become one that waits for a human.
                             **_approval_kwargs(launcher.launch, getattr(original, "approval", None)),
+                            **_execution_kwargs(
+                                launcher.launch,
+                                (
+                                    execution_mode.value
+                                    if execution_mode
+                                    else getattr(original, "execution_mode", None)
+                                ),
+                            ),
                         )
                     else:
                         console.print("[red]Could not find original session to fork.[/red]")
@@ -1425,7 +1621,7 @@ def agents_resume(
             import questionary
 
             registry = _get_registry()
-            all_sessions = registry.load_registry().sessions
+            all_sessions = registry.search_sessions(include_stopped=True)
             matches = [
                 s
                 for s in all_sessions
@@ -1438,6 +1634,13 @@ def agents_resume(
             ]
             matches.sort(key=lambda s: s.last_activity or s.started_at or 0, reverse=True)
 
+            if not matches:
+                console.print(
+                    "[yellow]No visible sessions match this prefix. "
+                    "Use a full session ID to resume a retained record.[/yellow]"
+                )
+                raise typer.Exit(code=1)
+
             choices = []
             for s in matches:
                 sid = s.session_id[:8]
@@ -1459,7 +1662,11 @@ def agents_resume(
             if selected is None:
                 raise typer.Exit()
 
-            session = launcher.resume(session_id=selected, name=name)
+            session = launcher.resume(
+                session_id=selected,
+                name=name,
+                **_execution_kwargs(launcher.resume, execution_mode.value if execution_mode else None),
+            )
 
         status_val = session.status.value if session.status else "idle"
         style = _status_style(status_val)
@@ -1718,9 +1925,8 @@ def agents_watch(
                     else:
                         # Parse and render
                         try:
-                            import json as _json
 
-                            event = _json.loads(line)
+                            event = json.loads(line)
                             entry_type = event.get("type", "unknown")
                             content = event.get("content", "")
                             ts = event.get("timestamp")
@@ -1780,6 +1986,11 @@ def agents_watch(
         can_prompt = interactive and not stream
         can_notify = stream
 
+        if can_prompt or can_notify:
+            from .permission_response import require_bound_permission_support
+
+            require_bound_permission_support()
+
         # Resolve the session ID used for permission files
         perm_session_id = session.session_id
 
@@ -1840,9 +2051,17 @@ def agents_watch(
         # (stdin can't be read from multiple threads safely).
         import threading
 
-        from qbraid_core.services.agents.permissions import get_pending_request, respond_to_request
+        from qbraid_core.services.agents.permissions import get_pending_request
+
+        from .permission_response import (
+            UnsupportedPermissionApproval,
+            request_identity,
+            respond_to_displayed_request,
+            supports_bound_approval,
+        )
 
         perm_stop_event = threading.Event()
+        perm_retry = threading.Event()
         perm_pending = threading.Event()  # Set when a permission request is detected
         perm_data: dict = {}  # Stores the current request
 
@@ -1850,8 +2069,12 @@ def agents_watch(
 
         def _permission_detector():
             """Background thread that detects permission requests."""
+            last_request_id = None
             while not perm_stop_event.is_set():
                 if not perm_pending.is_set():
+                    if perm_retry.is_set():
+                        last_request_id = None
+                        perm_retry.clear()
                     request = None
 
                     if oc_port:
@@ -1877,15 +2100,21 @@ def agents_watch(
                         # Claude/Codex: check file-based permission request
                         request = get_pending_request(perm_session_id)
 
-                    if request:
+                    if not isinstance(request, dict):
+                        request = None
+                    identity = request_identity(perm_session_id, request) if request else None
+                    if request and identity != last_request_id:
+                        last_request_id = identity
+                        perm_data.clear()
                         perm_data.update(request)
                         perm_pending.set()
 
                         if can_notify:
-                            import json as _json
 
                             notification = {
                                 "type": "permission_required",
+                                "request_id": identity,
+                                "protocol_version": request.get("protocol_version", 1),
                                 "session_id": perm_session_id,
                                 "tool_name": request.get("tool_name", "?"),
                                 "summary": request.get("summary", ""),
@@ -1894,7 +2123,11 @@ def agents_watch(
                             if request.get("opencode_request_id"):
                                 notification["opencode_request_id"] = request["opencode_request_id"]
                                 notification["opencode_port"] = oc_port
-                            print(_json.dumps(notification), flush=True)
+                            print(json.dumps(notification), flush=True)
+
+                        if not can_prompt:
+                            perm_data.clear()
+                            perm_pending.clear()
 
                         # Wait for main loop to clear the flag
                         while perm_pending.is_set() and not perm_stop_event.is_set():
@@ -1937,7 +2170,13 @@ def agents_watch(
                 console.print()
                 console.print(f"[bold yellow]Permission required:[/bold yellow] [bold]{tool_name}[/bold]")
                 console.print(f"[dim]{summary}[/dim]")
-                console.print("  [bold]1.[/bold] Allow")
+                if supports_bound_approval(perm_data):
+                    console.print("  [bold]1.[/bold] Allow")
+                else:
+                    console.print(
+                        "[dim]Automatic Allow unavailable for this legacy gate; "
+                        "restart the agent or use its terminal.[/dim]"
+                    )
                 console.print("  [bold]2.[/bold] Deny")
                 console.print("  [bold]3.[/bold] Pass to agent (show Claude's prompt)")
 
@@ -1953,8 +2192,8 @@ def agents_watch(
                         oc_reply_map = {"allow": "once", "deny": "reject", "ask": "once"}
                         reply_to_permission(oc_req_port, oc_req_id, oc_reply_map.get(decision, "once"))
                     else:
-                        # Claude: reply via file
-                        respond_to_request(perm_session_id, decision, reason)
+                        # Bind the reply to the request actually shown to the user.
+                        respond_to_displayed_request(perm_session_id, perm_data, decision, reason)
 
                 try:
                     choice = console.input("[dim]> [/dim]").strip()
@@ -1971,16 +2210,21 @@ def agents_watch(
                         _send_response("ask")
                         console.print("[dim]Invalid — passed to agent's terminal.[/dim]")
                 except (KeyboardInterrupt, EOFError):
-                    _send_response("ask")
+                    try:
+                        _send_response("ask")
+                    except ValueError as exc:
+                        perm_retry.set()
+                        console.print(f"[yellow]{exc}[/yellow]")
+                except UnsupportedPermissionApproval as exc:
+                    console.print(f"[yellow]{exc}[/yellow]")
+                except ValueError as exc:
+                    perm_retry.set()
+                    console.print(f"[yellow]{exc}[/yellow]")
 
-                perm_pending.clear()
                 perm_data.clear()
-                # Delete the request file to prevent re-detection (Claude only)
-                if not oc_req_id:
-                    req_file = (
-                        Path(os.path.expanduser("~/.qbraid/permissions")) / f"{perm_session_id}.request.json"
-                    )
-                    req_file.unlink(missing_ok=True)
+                perm_pending.clear()
+                # Only the tool-side gate owns request-file cleanup. Removing it
+                # here can erase the next request after the tool consumes our reply.
                 continue
 
             # Drain available transcript entries
@@ -2010,7 +2254,6 @@ def agents_watch(
                 tool_info = f" ({entry.tool_name})"
 
             if stream:
-                import json as _json
 
                 event = {
                     "type": entry_type,
@@ -2021,7 +2264,7 @@ def agents_watch(
                     "cost_usd": entry.cost_usd,
                     "token_count": entry.token_count,
                 }
-                print(_json.dumps({k: v for k, v in event.items() if v is not None}), flush=True)
+                print(json.dumps({k: v for k, v in event.items() if v is not None}), flush=True)
             else:
                 line = f"{prefix}{type_label}{tool_info}: [{style}]{content}[/{style}]"
                 console.print(line, highlight=False)
@@ -2030,6 +2273,9 @@ def agents_watch(
         console.print("\n[dim]Stopped watching.[/dim]")
     except (typer.Exit, SystemExit):
         raise
+    except ValueError as e:
+        handle_error(message=str(e), include_traceback=False)
+        raise typer.Exit(code=1)
     except Exception as e:
         handle_error(message=str(e))
         raise typer.Exit(code=1)

qbraid_cli-0.15.3/qbraid_cli/agents/permission_response.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2026, qBraid Development Team
+# All rights reserved.
+
+"""Bind watch-mode decisions to the permission request displayed to the user."""
+
+from qbraid_core.services.agents import permissions
+
+
+class UnsupportedPermissionApproval(ValueError):
+    """The displayed gate cannot safely accept an automatic approval."""
+
+
+def supports_bound_approval(request: dict) -> bool:
+    """Only explicit v2-or-newer gates can bind automatic approvals."""
+    try:
+        return int(request.get("protocol_version", 1)) >= 2
+    except (TypeError, ValueError, OverflowError):
+        return False
+
+
+def require_bound_permission_support() -> None:
+    """Refuse permission handling on core versions that ignore request identity."""
+    if not getattr(permissions, "SUPPORTS_BOUND_PERMISSION_RESPONSES", False):
+        raise ValueError(
+            "Permission handling requires a qbraid-core release with bound-response support; "
+            "upgrade core first, or watch read-only with --no-interactive."
+        )
+
+
+def request_identity(session_id: str, request: dict) -> str:
+    """Support nonce requests and the timestamp identity of older integrations."""
+    return (
+        request.get("request_id")
+        or request.get("opencode_request_id")
+        or (f"{session_id}:{request['timestamp']}" if request.get("timestamp") is not None else session_id)
+    )
+
+
+def respond_to_displayed_request(session_id: str, request: dict, decision: str, reason: str = "") -> None:
+    """Reject an expired prompt without reporting success or deleting gate state."""
+    require_bound_permission_support()
+    if decision == "allow" and not supports_bound_approval(request):
+        raise UnsupportedPermissionApproval(
+            "This legacy gate cannot bind approvals. Restart the agent or use its terminal."
+        )
+    if not permissions.respond_to_permission(
+        session_id, request_identity(session_id, request), decision, reason
+    ):
+        raise ValueError("Permission request expired or was already answered")

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3}/qbraid_cli/skills/app.py

@@ -271,7 +271,7 @@ def skills_install(
 
     try:
         console.print(f"[dim]Installing skill '{slug}'...[/dim]")
-        results = run_progress_task(install_skill)
+        results = run_progress_task(install_skill, include_error_traceback=False)
 
         if legacy_core and force:
             console.print(
@@ -329,6 +329,11 @@ def skills_uninstall(
         "-t",
         help="Target AI coding tool(s) to uninstall from",
     ),
+    path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="Uninstall from this directory instead of the tool directories",
+    ),
 ) -> None:
     """Uninstall a skill from AI coding tools.
 
@@ -337,9 +342,15 @@ def skills_uninstall(
     """
 
     def uninstall_skill():
+        from pathlib import Path as _Path
+
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
+        if path:
+            # `install --path` had no counterpart, so such an install could
+            # only be removed with `rm -rf`.
+            return client.uninstall_skill(slug, install_path=_Path(path).expanduser())
         return client.uninstall_skill(slug, target=target.value)
 
     console = Console()
@@ -359,6 +370,8 @@ def skills_uninstall(
         else:
             console.print(f"[yellow]Skill '{slug}' was not installed in any location.[/yellow]")
 
+    except typer.Exit:
+        raise
     except Exception as err:  # pylint: disable=broad-exception-caught
         handle_error(message=f"Failed to uninstall skill: {err}")
 
@@ -371,23 +384,39 @@ def skills_installed(
         "-t",
         help="Show skills for specific tool only",
     ),
+    path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="List skills installed in this directory",
+    ),
 ) -> None:
     """List locally installed skills.
 
     Shows each skill's name, registry slug and version per tool.
     """
+    # `all` is in the enum for `install`/`uninstall`, where it means every
+    # tool. There is no directory called "all", so passing it here reached
+    # get_skills_install_path and raised.
+    one_target = target if target and target is not SkillTargetOption.ALL else None
 
     def list_installed():
+        from pathlib import Path as _Path
+
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
+        install_path = _Path(path).expanduser() if path else None
         if hasattr(client, "list_all_installed_skills_detailed"):
-            if target:
-                return {target.value: client.list_installed_skills_detailed(target=target.value)}
+            if install_path is not None:
+                return {"custom": client.list_installed_skills_detailed(install_path=install_path)}
+            if one_target:
+                return {one_target.value: client.list_installed_skills_detailed(target=one_target.value)}
             return client.list_all_installed_skills_detailed()
         # older qbraid-core: directory names only
-        if target:
-            listed = {target.value: client.list_installed_skills(target=target.value)}
+        if install_path is not None:
+            listed = {"custom": client.list_installed_skills(install_path=install_path)}
+        elif one_target:
+            listed = {one_target.value: client.list_installed_skills(target=one_target.value)}
         else:
             listed = client.list_all_installed_skills()
         return {
@@ -424,6 +453,10 @@ def skills_installed(
 
         console.print("")
 
+    except typer.Exit:
+        # handle_error already reported and chose the exit code; catching it
+        # again below printed a second, empty "Error:" block.
+        raise
     except Exception as err:  # pylint: disable=broad-exception-caught
         handle_error(message=f"Failed to list installed skills: {err}")
 
@@ -431,13 +464,22 @@ def skills_installed(
 @skills_app.command(name="check")
 def skills_check(
     slug: str = typer.Argument(..., help="The skill slug to check"),
+    path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="Check this directory instead of the tool directories",
+    ),
 ) -> None:
     """Check if a skill is installed and where."""
 
     def check_skill():
+        from pathlib import Path as _Path
+
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
+        if path:
+            return {"custom": client.is_skill_installed(slug, install_path=_Path(path).expanduser())}
         return client.is_skill_installed_anywhere(slug)
 
     console = Console()
@@ -458,6 +500,8 @@ def skills_check(
             console.print(f"\n[yellow]Skill '{slug}' is not installed anywhere.[/yellow]")
             console.print(f"\n[dim]Install it with: qbraid skills install {slug}[/dim]")
 
+    except typer.Exit:
+        raise
     except Exception as err:  # pylint: disable=broad-exception-caught
         handle_error(message=f"Failed to check skill: {err}")
 

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.15.1
+Version: 0.15.3
 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.5.0
+Requires-Dist: qbraid-core>=0.6.5
 Provides-Extra: compute
-Requires-Dist: qbraid-core[compute]>=0.5.0; extra == "compute"
+Requires-Dist: qbraid-core[compute]>=0.6.5; extra == "compute"
 Provides-Extra: envs
-Requires-Dist: qbraid-core[environments]>=0.5.0; extra == "envs"
+Requires-Dist: qbraid-core[environments]>=0.6.5; extra == "envs"
 Provides-Extra: dev
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: black; extra == "dev"

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3}/qbraid_cli.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ qbraid_cli/admin/headers.py
 qbraid_cli/admin/validation.py
 qbraid_cli/agents/__init__.py
 qbraid_cli/agents/app.py
+qbraid_cli/agents/permission_response.py
 qbraid_cli/ai/__init__.py
 qbraid_cli/ai/app.py
 qbraid_cli/ai/token.py

{qbraid_cli-0.15.1 → qbraid_cli-0.15.3}/qbraid_cli.egg-info/requires.txt

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