plugin-scanner 2.0.993__tar.gz → 2.0.995__tar.gz

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.993
+Version: 2.0.995
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.993"
+version = "2.0.995"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.993"
+version = "2.0.995"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/src/codex_plugin_scanner/cli.py

@@ -11,6 +11,7 @@ from .argparse_utils import FriendlyArgumentParser, should_default_to_scan_targe
 from .cli_ui import build_cli_epilog, build_plain_text, build_scan_help_epilog
 from .ecosystems.registry import list_supported_ecosystems
 from .guard.cli import add_guard_parser, add_guard_root_parser, run_guard_command
+from .guard.product_model import SUPPORTED_HARNESS_VALUES
 from .reporting import format_json as render_json
 from .rules import get_rule_spec
 from .version import __version__
@@ -212,7 +213,8 @@ def _resolve_legacy_args(
         is_hol_guard_default_doctor = _is_hol_guard_program(program_name) and (
             len(argv) == 1 or "-h" in argv[1:] or "--help" in argv[1:]
         )
-        if has_guard_doctor_flag or is_hol_guard_default_doctor:
+        has_harness_arg = len(argv) >= 2 and not argv[1].startswith("-") and argv[1] in SUPPORTED_HARNESS_VALUES
+        if has_guard_doctor_flag or is_hol_guard_default_doctor or has_harness_arg:
             return ["guard", *argv]
     known_commands = {
         "scan",

plugin_scanner-2.0.995/src/codex_plugin_scanner/guard/adapters/pi_extension_approval_source.py

@@ -0,0 +1,148 @@
+"""Generated Pi managed extension approval-resume helper source."""
+
+# ruff: noqa: E501
+
+from __future__ import annotations
+
+APPROVAL_RESUME_HELPERS_SOURCE = r"""function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function approvalRequestId(response: GuardResponse): string | null {
+  if (typeof response.approval_request_id !== 'string') return null;
+  const requestId = response.approval_request_id.trim();
+  if (!requestId) return null;
+  return requestId;
+}
+
+function approvalPollPath(response: GuardResponse, requestId: string): string {
+  const rawPath = typeof response.resume_poll_path === 'string' ? response.resume_poll_path.trim() : '';
+  if (rawPath.startsWith('/v1/requests/')) return rawPath;
+  return `/v1/requests/${encodeURIComponent(requestId)}`;
+}
+
+function approvalUrlFromResponse(response: GuardResponse): string | null {
+  if (typeof response.approval_url !== 'string') return null;
+  const approvalUrl = response.approval_url.trim();
+  if (!approvalUrl) return null;
+  return approvalUrl;
+}
+
+function approvalBlockedReason(response: GuardResponse, fallbackReason: string): string {
+  const reason = fallbackReason.trim() || 'Blocked by HOL Guard.';
+  const approvalUrl = approvalUrlFromResponse(response);
+  if (!approvalUrl) return reason;
+  const urlLine = `HOL Guard approval page: ${approvalUrl}`;
+  const waitLine = 'HOL Guard is already waiting for this approval and will resume this Pi session automatically after the user approves.';
+  const noAskLine = 'Do not call ask for this HOL Guard approval as the approval mechanism; HOL Guard is already polling the request.';
+  const askFallbackLine = `If you are already showing a broader recovery menu, include an option labeled "I've approved this request in HOL Guard" and include this exact URL: ${approvalUrl}`;
+  const additions = [urlLine, waitLine, noAskLine, askFallbackLine].filter(line => !reason.includes(line));
+  if (additions.length === 0) return reason;
+  return `${reason}\n\n${additions.join('\n')}`;
+}
+
+function trySpawnOpen(command: string, args: string[]): Promise<boolean> {
+  return new Promise(resolve => {
+    let settled = false;
+    const settle = (opened: boolean) => {
+      if (settled) return;
+      settled = true;
+      resolve(opened);
+    };
+    try {
+      const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+      child.once('spawn', () => {
+        child.unref();
+        settle(true);
+      });
+      child.once('error', () => settle(false));
+    } catch {
+      settle(false);
+    }
+  });
+}
+
+async function openApprovalUrl(response: GuardResponse, openedApprovalUrls: Set<string>): Promise<void> {
+  const approvalUrl = approvalUrlFromResponse(response);
+  if (!approvalUrl || openedApprovalUrls.has(approvalUrl)) return;
+  openedApprovalUrls.add(approvalUrl);
+  const platform = process.platform;
+  let commands: Array<[string, string[]]>;
+  if (platform === 'darwin') {
+    commands = [['open', [approvalUrl]]];
+  } else if (platform === 'win32') {
+    commands = [['cmd', ['/c', 'start', '', approvalUrl]]];
+  } else {
+    commands = [
+      ['xdg-open', [approvalUrl]],
+      ['gio', ['open', approvalUrl]],
+      ['exo-open', [approvalUrl]],
+      ['sensible-browser', [approvalUrl]],
+    ];
+  }
+  for (const [command, args] of commands) {
+    if (await trySpawnOpen(command, args)) return;
+  }
+}
+
+function approvalResumeMessage(details: {
+  kind: 'input' | 'tool_call';
+  requestId: string;
+  prompt?: string;
+  toolName?: string;
+}): string {
+  if (details.kind === 'input') {
+    return [
+      'HOL Guard approved the Pi user prompt that was blocked in this session.',
+      'Continue with the approved request now; do not ask the user to retry it manually.',
+      details.prompt ? `Approved prompt:\n${details.prompt}` : '',
+    ].filter(Boolean).join('\n\n');
+  }
+  const toolPart = details.toolName ? ` for ${details.toolName}` : '';
+  return [
+    `HOL Guard approved the blocked Pi tool call${toolPart}.`,
+    'Continue the original user task now. Retry that tool call once if it is still required; '
+      + 'the saved HOL Guard approval should allow it.',
+    'Do not ask the user to retry the same action manually.',
+  ].join('\n\n');
+}
+
+async function pollApprovalResolution(
+  requestId: string,
+  pollPath: string,
+): Promise<'allow' | 'block' | null> {
+  if (typeof fetch !== 'function') return null;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= GUARD_APPROVAL_RESUME_MAX_WAIT_MS) {
+    const connection = loadGuardDaemonConnection();
+    if (!connection) return null;
+    const controller = typeof AbortController === 'function' ? new AbortController() : undefined;
+    const timeoutHandle = setTimeout(
+      () => controller?.abort(),
+      GUARD_APPROVAL_RESUME_FETCH_TIMEOUT_MS,
+    );
+    try {
+      const response = await fetch(`http://127.0.0.1:${connection.port}${pollPath}`, {
+        method: 'GET',
+        headers: { 'X-Guard-Token': connection.authToken },
+        signal: controller?.signal,
+      });
+      if (response.status === 404) return null;
+      if (response.ok) {
+        const item = (await response.json()) as { status?: unknown; resolution_action?: unknown };
+        if (item.status === 'resolved') {
+          if (item.resolution_action === 'allow') return 'allow';
+          if (item.resolution_action === 'block') return 'block';
+          return null;
+        }
+      }
+    } catch {
+    } finally {
+      clearTimeout(timeoutHandle);
+    }
+    await sleep(GUARD_APPROVAL_RESUME_POLL_INTERVAL_MS);
+  }
+  return null;
+}
+
+"""

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/src/codex_plugin_scanner/guard/adapters/pi_extension_source.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
+from .pi_extension_approval_source import APPROVAL_RESUME_HELPERS_SOURCE
 from .pi_extension_content_source import CONTENT_REVIEW_HELPERS_SOURCE
 
 GUARD_HOOK_TIMEOUT_MS = 10_000
@@ -25,7 +26,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
     home_dir_is_default_json = "true" if home_dir.resolve() == Path.home().resolve() else "false"
     config_path_json = json.dumps(str(settings_path))
     return (
-        'import { spawnSync } from "node:child_process";\n'
+        'import { spawn, spawnSync } from "node:child_process";\n'
         'import { createCipheriv, createHash, randomBytes } from "node:crypto";\n'
         'import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";\n'
         'import { tmpdir } from "node:os";\n'
@@ -249,85 +250,10 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "  if (isError) result.isError = true;\n"
         "  return result;\n"
         "}\n"
-        "\n"
-        "function sleep(ms: number): Promise<void> {\n"
-        "  return new Promise(resolve => setTimeout(resolve, ms));\n"
-        "}\n"
-        "\n"
-        "function approvalRequestId(response: GuardResponse): string | null {\n"
-        "  return typeof response.approval_request_id === 'string' && response.approval_request_id.trim()\n"
-        "    ? response.approval_request_id.trim()\n"
-        "    : null;\n"
-        "}\n"
-        "\n"
-        "function approvalPollPath(response: GuardResponse, requestId: string): string {\n"
-        "  const rawPath = typeof response.resume_poll_path === 'string' ? response.resume_poll_path.trim() : '';\n"
-        "  return rawPath.startsWith('/v1/requests/') ? rawPath : `/v1/requests/${encodeURIComponent(requestId)}`;\n"
-        "}\n"
-        "\n"
-        "function approvalResumeMessage(details: {\n"
-        "  kind: 'input' | 'tool_call';\n"
-        "  requestId: string;\n"
-        "  prompt?: string;\n"
-        "  toolName?: string;\n"
-        "}): string {\n"
-        "  if (details.kind === 'input') {\n"
-        "    return [\n"
-        "      'HOL Guard approved the Pi user prompt that was blocked in this session.',\n"
-        "      'Continue with the approved request now; do not ask the user to retry it manually.',\n"
-        "      details.prompt ? `Approved prompt:\\n${details.prompt}` : '',\n"
-        "    ].filter(Boolean).join('\\n\\n');\n"
-        "  }\n"
-        "  const toolPart = details.toolName ? ` for ${details.toolName}` : '';\n"
-        "  return [\n"
-        "    `HOL Guard approved the blocked Pi tool call${toolPart}.`,\n"
-        "    'Continue the original user task now. Retry that tool call once if it is still required; '\n"
-        "      + 'the saved HOL Guard approval should allow it.',\n"
-        "    'Do not ask the user to retry the same action manually.',\n"
-        "  ].join('\\n\\n');\n"
-        "}\n"
-        "\n"
-        "async function pollApprovalResolution(\n"
-        "  requestId: string,\n"
-        "  pollPath: string,\n"
-        "): Promise<'allow' | 'block' | null> {\n"
-        "  if (typeof fetch !== 'function') return null;\n"
-        "  const startedAt = Date.now();\n"
-        "  while (Date.now() - startedAt <= GUARD_APPROVAL_RESUME_MAX_WAIT_MS) {\n"
-        "    const connection = loadGuardDaemonConnection();\n"
-        "    if (!connection) return null;\n"
-        "    const controller = typeof AbortController === 'function' ? new AbortController() : undefined;\n"
-        "    const timeoutHandle = setTimeout(\n"
-        "      () => controller?.abort(),\n"
-        "      GUARD_APPROVAL_RESUME_FETCH_TIMEOUT_MS,\n"
-        "    );\n"
-        "    try {\n"
-        "      const response = await fetch(`http://127.0.0.1:${connection.port}${pollPath}`, {\n"
-        "        method: 'GET',\n"
-        "        headers: { 'X-Guard-Token': connection.authToken },\n"
-        "        signal: controller?.signal,\n"
-        "      });\n"
-        "      if (response.status === 404) return null;\n"
-        "      if (response.ok) {\n"
-        "        const item = (await response.json()) as { status?: unknown; resolution_action?: unknown };\n"
-        "        if (item.status === 'resolved') {\n"
-        "          if (item.resolution_action === 'allow') return 'allow';\n"
-        "          if (item.resolution_action === 'block') return 'block';\n"
-        "          return null;\n"
-        "        }\n"
-        "      }\n"
-        "    } catch {\n"
-        "    } finally {\n"
-        "      clearTimeout(timeoutHandle);\n"
-        "    }\n"
-        "    await sleep(GUARD_APPROVAL_RESUME_POLL_INTERVAL_MS);\n"
-        "  }\n"
-        "  return null;\n"
-        "}\n"
-        "\n"
-        "export default function (pi: ExtensionAPI) {\n"
+        "\n" + APPROVAL_RESUME_HELPERS_SOURCE + "export default function (pi: ExtensionAPI) {\n"
         "  const blockedToolResults = new Map<string, string>();\n"
         "  const pendingApprovalResumes = new Set<string>();\n"
+        "  const openedApprovalUrls = new Set<string>();\n"
         "  function scheduleApprovalResume(\n"
         "    response: GuardResponse,\n"
         "    ctx: { ui: { notify(message: string, kind?: 'info' | 'warning'): void } },\n"
@@ -336,6 +262,7 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "    const requestId = approvalRequestId(response);\n"
         "    if (!requestId || pendingApprovalResumes.has(requestId)) return;\n"
         "    pendingApprovalResumes.add(requestId);\n"
+        "    void openApprovalUrl(response, openedApprovalUrls);\n"
         "    const pollPath = approvalPollPath(response, requestId);\n"
         "    void (async () => {\n"
         "      try {\n"
@@ -367,8 +294,9 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "      ctx.cwd,\n"
         "    );\n"
         '    if (response.decision === "deny") {\n'
+        '      const reason = approvalBlockedReason(response, response.reason ?? "Blocked by HOL Guard.");\n'
         "      scheduleApprovalResume(response, ctx, { kind: 'input', prompt: event.text });\n"
-        '      ctx.ui.notify(response.reason ?? "Blocked by HOL Guard.", "warning");\n'
+        '      ctx.ui.notify(reason, "warning");\n'
         '      return { action: "handled", handled: true };\n'
         "    }\n"
         '    return { action: "continue" };\n'
@@ -389,9 +317,10 @@ def managed_extension_source(*, guard_home: Path, home_dir: Path, settings_path:
         "      ctx.cwd,\n"
         "    );\n"
         '    if (response.decision === "deny") {\n'
+        '      const reason = approvalBlockedReason(response, response.reason ?? "Blocked by HOL Guard.");\n'
         "      scheduleApprovalResume(response, ctx, { kind: 'tool_call', toolName: event.toolName });\n"
-        '      ctx.ui.notify(response.reason ?? "Blocked by HOL Guard.", "warning");\n'
-        '      return { block: true, reason: response.reason ?? "Blocked by HOL Guard." };\n'
+        '      ctx.ui.notify(reason, "warning");\n'
+        "      return { block: true, reason };\n"
         "    }\n"
         "    return undefined;\n"
         "  });\n"

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.0.993"
+__version__ = "2.0.995"

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/tests/test_guard_policy_integrity.py

@@ -3166,6 +3166,26 @@ def test_trust_cli_bare_combined_command_routes_to_guard() -> None:
     ]
 
 
+def test_doctor_harness_arg_routes_to_guard() -> None:
+    """Regression: hol-guard doctor codex (without --json) must route to guard doctor codex,
+    not fall through to the scanner-level doctor command which treats 'codex' as a
+    plugin directory path and fails with 'is not a directory'."""
+    for harness in ("codex", "claude-code", "cursor", "opencode", "gemini"):
+        assert _resolve_legacy_args(["doctor", harness], program_mode="combined", program_name="hol-guard") == [
+            "guard",
+            "doctor",
+            harness,
+        ]
+
+
+def test_doctor_non_harness_path_stays_scanner_level() -> None:
+    """doctor /path/to/plugin should still route to scanner-level doctor, not guard."""
+    assert _resolve_legacy_args(["doctor", "/path/to/plugin"], program_mode="combined", program_name="hol-guard") == [
+        "doctor",
+        "/path/to/plugin",
+    ]
+
+
 def test_trust_cli_no_ui_probe_requires_no_ui_flag(tmp_path: Path, capsys) -> None:
     home_dir = tmp_path / "home"
 

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/tests/test_pi_adapter.py

@@ -256,6 +256,12 @@ class TestPiInstall:
         assert "daemon-auth-token" in text
         assert "/v1/hooks/pi?" in text
         assert "approval_request_id?: string" in text
+        assert "approvalBlockedReason" in text
+        assert "Do not call ask for this HOL Guard approval" in text
+        assert 'option labeled "I\'ve approved this request in HOL Guard"' in text
+        assert "void openApprovalUrl(response, openedApprovalUrls)" in text
+        assert "trySpawnOpen(command, args)" in text
+        assert "child.once('error', () => settle(false))" in text
         assert "pollApprovalResolution" in text
         assert "GUARD_APPROVAL_RESUME_FETCH_TIMEOUT_MS" in text
         assert "controller?.abort()" in text

{plugin_scanner-2.0.993 → plugin_scanner-2.0.995}/uv.lock

@@ -1162,7 +1162,7 @@ wheels = [
 
 [[package]]
 name = "hol-guard"
-version = "2.0.993"
+version = "2.0.995"
 source = { editable = "." }
 dependencies = [
     { name = "cisco-ai-skill-scanner", marker = "python_full_version < '3.14'" },