plugin-scanner 2.0.612__tar.gz → 2.0.614__tar.gz

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.612
+Version: 2.0.614
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.612"
+version = "2.0.614"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/pyproject.toml.bak

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

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/src/codex_plugin_scanner/guard/adapters/opencode_pretool.py

@@ -72,23 +72,92 @@ async function runGuardHook(directory: string, payload: Record<string, unknown>)
   return { exitCode, stdout, stderr };
 }
 
-function guardBlockMessage(stdout: string, stderr: string): string {
-  try {
-    const payload = JSON.parse(stdout) as {
-      review_hint?: string;
-      decision_v2_json?: { harness_message?: string; retry_instruction?: string };
-    };
-    const decision = payload.decision_v2_json;
-    return (
-      payload.review_hint ||
-      decision?.retry_instruction ||
-      decision?.harness_message ||
-      stderr.trim() ||
-      "HOL Guard blocked this OpenCode action."
-    );
-  } catch {
+function parseGuardPayload(stdout: string): Record<string, unknown> | null {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const parseCandidate = (candidate: string): Record<string, unknown> | null => {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {}
+    return null;
+  };
+  const direct = parseCandidate(trimmed);
+  if (direct !== null) {
+    return direct;
+  }
+  const lines = trimmed.split(/\\r?\\n/);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const candidate = lines[index]?.trim();
+    if (!candidate) {
+      continue;
+    }
+    const parsed = parseCandidate(candidate);
+    if (parsed !== null) {
+      return parsed;
+    }
+  }
+  return null;
+}
+
+function guardReviewUrl(payload: Record<string, unknown>): string | null {
+  const primary = typeof payload.primary_approval_url === "string" ? payload.primary_approval_url.trim() : "";
+  if (primary) {
+    return primary;
+  }
+  const reviewUrl = typeof payload.review_url === "string" ? payload.review_url.trim() : "";
+  if (reviewUrl) {
+    return reviewUrl;
+  }
+  const queued = payload.approval_requests;
+  if (Array.isArray(queued)) {
+    for (const item of queued) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      const approvalUrl = (item as { approval_url?: unknown }).approval_url;
+      if (typeof approvalUrl === "string" && approvalUrl.trim()) {
+        return approvalUrl.trim().replace(/\\/approvals\\//g, "/requests/");
+      }
+    }
+  }
+  const center = typeof payload.approval_center_url === "string" ? payload.approval_center_url.trim() : "";
+  return center || null;
+}
+
+export function guardBlockMessage(stdout: string, stderr: string): string {
+  const payload = parseGuardPayload(stdout);
+  if (payload === null) {
     return stderr.trim() || "HOL Guard blocked this OpenCode action.";
   }
+  const decision = payload.decision_v2_json;
+  const decisionPayload =
+    decision && typeof decision === "object"
+      ? (decision as { harness_message?: unknown; retry_instruction?: unknown })
+      : null;
+  const reviewHint = typeof payload.review_hint === "string" ? payload.review_hint.trim() : "";
+  const retryInstruction =
+    typeof decisionPayload?.retry_instruction === "string" ? decisionPayload.retry_instruction.trim() : "";
+  const harnessMessage =
+    typeof decisionPayload?.harness_message === "string" ? decisionPayload.harness_message.trim() : "";
+  const baseMessage =
+    reviewHint ||
+    retryInstruction ||
+    harnessMessage ||
+    stderr.trim() ||
+    "HOL Guard blocked this OpenCode action.";
+  const reviewUrl = guardReviewUrl(payload);
+  if (!reviewUrl || baseMessage.includes(reviewUrl)) {
+    return baseMessage;
+  }
+  return (
+    `${baseMessage} Open HOL Guard to approve or keep this blocked: ${reviewUrl}. `
+    + "After you choose, retry the same OpenCode action."
+  );
 }
 
 export const HolGuardPretoolPlugin = async ({

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/src/codex_plugin_scanner/guard/store.py

@@ -295,23 +295,7 @@ class KeychainSecretStore:
     def set_secret(self, secret_id: str, value: str) -> None:
         if not self._is_available():
             raise RuntimeError("macOS keychain command is not available")
-        prompt_payload = f"{value}\n{value}\n"
-        subprocess.run(
-            [
-                "/usr/bin/security",
-                "add-generic-password",
-                "-a",
-                secret_id,
-                "-s",
-                self.service_name,
-                "-U",
-                "-w",
-            ],
-            check=True,
-            capture_output=True,
-            text=True,
-            input=prompt_payload,
-        )
+        raise RuntimeError("macOS security CLI does not support noninteractive secret writes without argv exposure")
 
     def get_secret(self, secret_id: str) -> str | None:
         if not self._is_available():

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/tests/test_guard_store_migrations.py

@@ -581,6 +581,25 @@ def _install_fake_sync_keychain(monkeypatch) -> dict[tuple[str, str], str]:
     return secrets
 
 
+def test_keychain_secret_store_rejects_cli_secret_writes(monkeypatch):
+    monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: True))
+
+    def fake_run(
+        args: list[str],
+        *,
+        check: bool,
+        capture_output: bool,
+        text: bool,
+        **kwargs: object,
+    ) -> subprocess.CompletedProcess[str]:
+        raise AssertionError("keychain writes must not shell out with secret material")
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    with pytest.raises(RuntimeError, match="argv exposure"):
+        KeychainSecretStore("hol-guard.sync").set_secret("guard-token", "secret-value")
+
+
 def test_secret_store_prefers_encrypted_file_backend_when_keychain_is_available_outside_macos(tmp_path, monkeypatch):
     guard_home = tmp_path / "guard-home"
     monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: True))
@@ -654,11 +673,10 @@ def test_sync_credentials_do_not_shell_out_to_keychain_when_file_store_is_availa
     GuardStore(guard_home)
 
 
-def test_sync_credentials_write_to_keychain_primary_on_macos(tmp_path, monkeypatch):
+def test_sync_credentials_fall_back_when_keychain_cli_rejects_writes_on_macos(tmp_path, monkeypatch):
     guard_home = tmp_path / "guard-home"
     monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: True))
     monkeypatch.setattr(guard_store_module.sys, "platform", "darwin", raising=False)
-    sync_keychain = _install_fake_sync_keychain(monkeypatch)
     store = GuardStore(guard_home)
 
     store.set_sync_credentials(
@@ -668,14 +686,16 @@ def test_sync_credentials_write_to_keychain_primary_on_macos(tmp_path, monkeypat
         workspace_id="workspace-123",
     )
 
-    assert sync_keychain[("hol-guard.sync", store._sync_token_ref)] == "access-secret-value"
     assert store.get_sync_credentials() == {
         "sync_url": "https://hol.org/api/guard/receipts/sync",
         "token": "access-secret-value",
     }
 
 
-def test_get_sync_credentials_promotes_legacy_file_secret_into_keychain_on_macos(tmp_path, monkeypatch):
+def test_get_sync_credentials_keeps_legacy_file_secret_when_keychain_cli_rejects_writes_on_macos(
+    tmp_path,
+    monkeypatch,
+):
     guard_home = tmp_path / "guard-home"
     monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: False))
     legacy_store = GuardStore(guard_home)
@@ -688,14 +708,12 @@ def test_get_sync_credentials_promotes_legacy_file_secret_into_keychain_on_macos
 
     monkeypatch.setattr(KeychainSecretStore, "_is_available", staticmethod(lambda: True))
     monkeypatch.setattr(guard_store_module.sys, "platform", "darwin", raising=False)
-    sync_keychain = _install_fake_sync_keychain(monkeypatch)
     migrated_store = GuardStore(guard_home)
 
     assert migrated_store.get_sync_credentials() == {
         "sync_url": "https://hol.org/api/guard/receipts/sync",
         "token": "legacy-access-secret",
     }
-    assert sync_keychain[("hol-guard.sync", migrated_store._sync_token_ref)] == "legacy-access-secret"
 
 
 def test_oauth_local_credentials_do_not_shell_out_to_keychain_when_system_keyring_is_available(tmp_path, monkeypatch):

{plugin_scanner-2.0.612 → plugin_scanner-2.0.614}/tests/test_opencode_pretool.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
+import subprocess
 import sys
 from pathlib import Path
 
@@ -39,6 +41,33 @@ def _ctx(tmp_path: Path, *, workspace: bool = False) -> HarnessContext:
     )
 
 
+def _run_generated_guard_block_message(tmp_path: Path, *, stdout: str, stderr: str = "") -> str:
+    bun = shutil.which("bun")
+    if bun is None:
+        pytest.skip("bun not installed")
+    source = pretool_plugin_source(_ctx(tmp_path))
+    plugin_path = tmp_path / "guard-block-plugin.ts"
+    plugin_path.write_text(source, encoding="utf-8")
+    script_path = tmp_path / "guard-block-runner.ts"
+    script_path.write_text(
+        "import { guardBlockMessage } from './guard-block-plugin';\n"
+        + "console.log(guardBlockMessage("
+        + json.dumps(stdout)
+        + ", "
+        + json.dumps(stderr)
+        + "));\n",
+        encoding="utf-8",
+    )
+    completed = subprocess.run(
+        [bun, str(script_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stderr
+    return completed.stdout.strip()
+
+
 def test_pretool_plugin_source_embeds_guard_paths(tmp_path: Path) -> None:
     ctx = _ctx(tmp_path)
     source = pretool_plugin_source(ctx)
@@ -66,6 +95,39 @@ def test_pretool_plugin_source_normalizes_argv_array_commands(tmp_path: Path) ->
     assert "Array.isArray(command)" in source
 
 
+def test_pretool_plugin_guard_block_message_appends_primary_approval_url(tmp_path: Path) -> None:
+    message = _run_generated_guard_block_message(
+        tmp_path,
+        stdout=json.dumps(
+            {
+                "decision_v2_json": {
+                    "harness_message": "HOL Guard blocked this OpenCode action.",
+                },
+                "primary_approval_url": "http://127.0.0.1:4455/requests/req-opencode",
+            }
+        ),
+    )
+    assert "http://127.0.0.1:4455/requests/req-opencode" in message
+    assert "Open HOL Guard to approve or keep this blocked" in message
+
+
+def test_pretool_plugin_guard_block_message_recovers_last_json_line(tmp_path: Path) -> None:
+    message = _run_generated_guard_block_message(
+        tmp_path,
+        stdout="Guard queued approval request\n"
+        + json.dumps(
+            {
+                "review_hint": "HOL Guard queued this OpenCode action for review.",
+                "approval_requests": [
+                    {"approval_url": "http://127.0.0.1:4455/approvals/req-opencode"},
+                ],
+            }
+        ),
+    )
+    assert "http://127.0.0.1:4455/requests/req-opencode" in message
+    assert message.count("http://127.0.0.1:4455/requests/req-opencode") == 1
+
+
 def test_pretool_hook_launcher_ignores_workspace_package_hijack(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,