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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.15.1
+Version: 0.15.2
 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.15.1"
+version = "0.15.2"
 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" }]

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

@@ -1780,6 +1780,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 +1845,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 +1863,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,7 +1894,12 @@ 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()
 
@@ -1886,6 +1908,8 @@ def agents_watch(
 
                             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", ""),
@@ -1896,6 +1920,10 @@ def agents_watch(
                                 notification["opencode_port"] = oc_port
                             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():
                             time.sleep(0.5)
@@ -1937,7 +1965,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 +1987,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 +2005,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
@@ -2030,6 +2069,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.2/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.2}/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.2/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.15.1
+Version: 0.15.2
 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

{qbraid_cli-0.15.1 → qbraid_cli-0.15.2}/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