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

{qbraid_cli-0.15.0/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.0
+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.0 → qbraid_cli-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.15.0"
+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.0 → 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.0 → qbraid_cli-0.15.2}/qbraid_cli/skills/app.py

@@ -40,11 +40,21 @@ class SkillTargetOption(str, Enum):
 
     CLAUDE_CODE = "claude-code"
     CODEX = "codex"
+    PI = "pi"
     CURSOR = "cursor"
     COPILOT = "copilot"
     ALL = "all"
 
 
+_ACTION_STYLE = {
+    "installed": "[green]installed[/green]",
+    "updated": "[green]updated[/green]",
+    "unchanged": "[dim]unchanged[/dim]",
+    "failed": "[red]failed[/red]",
+    "unknown": "[dim]done (older qbraid-core)[/dim]",
+}
+
+
 class VisibilityOption(str, Enum):
     """Skill visibility level."""
 
@@ -213,55 +223,134 @@ def skills_install(
         "-t",
         help="Target AI coding tool(s) to install for",
     ),
+    path: Optional[str] = typer.Option(
+        None,
+        "--path",
+        "-p",
+        help="Install into this directory instead of a tool's skills directory",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Replace the installed copy even if it is unchanged or was not installed by qbraid",
+    ),
 ) -> None:
     """Install a skill for AI coding tools.
 
-    By default, installs to Claude Code (~/.claude/skills/).
-    Use --target all to install to all supported tools.
+    By default, installs to Claude Code (~/.claude/skills/). Use --target all
+    for every supported tool; --target codex or --target pi both land in
+    ~/.agents/skills/, which Codex and CodeQ (pi) read.
+
+    In a tool's skills directory the skill is placed under its own name (not
+    its slug); with --path it is placed under its slug at that path. The
+    download is checked against the registry's checksum, and installing an
+    unchanged skill again is a no-op.
     """
+    from pathlib import Path
+
+    install_path = Path(path).expanduser() if path else None
+    console = Console()
+    legacy_core = False
 
     def install_skill():
+        nonlocal legacy_core
         from qbraid_core.services.skills import SkillsClient
 
         client = SkillsClient()
-        return client.install_skill(slug, target=target.value)
-
-    console = Console()
+        if hasattr(client, "install_skill_ex"):
+            return client.install_skill_ex(slug, target=target.value, install_path=install_path, force=force)
+        # older qbraid-core: slug-named directories, no checksum or manifest, no --force
+        legacy_core = True
+        return {
+            name: _LegacyInstall(slug, installed_path)
+            for name, installed_path in client.install_skill(
+                slug, target=target.value, install_path=install_path
+            ).items()
+        }
 
     try:
         console.print(f"[dim]Installing skill '{slug}'...[/dim]")
-        installed_paths = run_progress_task(install_skill)
+        results = run_progress_task(install_skill, include_error_traceback=False)
 
-        console.print(f"\n[green]✓[/green] Skill '{slug}' installed successfully!\n")
+        if legacy_core and force:
+            console.print(
+                "[yellow]Note:[/yellow] the installed qbraid-core does not support --force; "
+                "the flag was ignored. Upgrade qbraid-core for --force, checksum "
+                "verification and name-based skill directories."
+            )
 
-        for target_name, path in installed_paths.items():
-            console.print(f"  [cyan]{target_name}[/cyan]: {path}")
+        failed = [name for name, result in results.items() if result.action == "failed"]
+        mark = "[yellow]![/yellow]" if failed else "[green]✓[/green]"
+        console.print(f"\n{mark} Skill '{slug}':\n")
+        for target_name, result in results.items():
+            version = f" v{result.version}" if result.version else ""
+            line = (
+                f"  [cyan]{target_name}[/cyan]: "
+                f"{_ACTION_STYLE.get(result.action, result.action)} "
+                f"[bold]{result.name}[/bold]{version} → {result.path}"
+            )
+            if result.action == "failed" and getattr(result, "error", None):
+                line += f"\n      [red]{result.error}[/red]"
+            console.print(line)
 
+        if failed:
+            handle_error(message=f"Skill '{slug}' failed for: {', '.join(failed)}")
         console.print("\n[dim]The skill is now available in your AI coding tool(s).[/dim]")
 
+    except typer.Exit:
+        raise
     except Exception as err:  # pylint: disable=broad-exception-caught
         handle_error(message=f"Failed to install skill: {err}")
 
 
+class _LegacyInstall:  # pylint: disable=too-few-public-methods
+    """Install result shape for a qbraid-core without install_skill_ex.
+
+    That core cannot tell whether anything changed, so the action is reported
+    as ``unknown`` rather than claiming ``installed``.
+    """
+
+    def __init__(self, slug: str, path) -> None:
+        self.slug = slug
+        self.name = slug
+        self.path = path
+        self.version = None
+        self.action = "unknown"
+        self.error = None
+
+
 @skills_app.command(name="uninstall")
 def skills_uninstall(
-    slug: str = typer.Argument(..., help="The skill slug to uninstall"),
+    slug: str = typer.Argument(..., help="The skill slug (or installed name) to uninstall"),
     target: SkillTargetOption = typer.Option(
         SkillTargetOption.ALL,
         "--target",
         "-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.
 
-    By default, uninstalls from all supported tools.
+    By default, uninstalls from all supported tools. Accepts the registry slug
+    or the installed directory name.
     """
 
     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()
@@ -281,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}")
 
@@ -293,16 +384,45 @@ 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."""
+    """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()
-        if target:
-            return {target.value: client.list_installed_skills(target=target.value)}
-        return client.list_all_installed_skills()
+        install_path = _Path(path).expanduser() if path else None
+        if hasattr(client, "list_all_installed_skills_detailed"):
+            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 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 {
+            name: [{"name": skill, "slug": skill, "version": None} for skill in skills]
+            for name, skills in listed.items()
+        }
 
     console = Console()
 
@@ -320,13 +440,23 @@ def skills_installed(
         for target_name, skills in results.items():
             if skills:
                 console.print(f"[cyan]{target_name}[/cyan]:")
-                for skill_slug in skills:
-                    console.print(f"  • {skill_slug}")
+                for entry in skills:
+                    slug_note = (
+                        f" [dim]({entry['slug']})[/dim]"
+                        if entry.get("slug") and entry["slug"] != entry["name"]
+                        else ""
+                    )
+                    version = f" v{entry['version']}" if entry.get("version") else ""
+                    console.print(f"  • {entry['name']}{slug_note}{version}")
             else:
                 console.print(f"[dim]{target_name}: (none)[/dim]")
 
         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}")
 
@@ -334,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()
@@ -361,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.0 → 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.0
+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.0 → 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