plugin-scanner 2.0.712__tar.gz → 2.0.714__tar.gz

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.712
+Version: 2.0.714
 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.712 → plugin_scanner-2.0.714}/pyproject.toml

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

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.712"
+version = "2.0.714"
 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.712 → plugin_scanner-2.0.714}/src/codex_plugin_scanner/guard/adapters/opencode_pretool.py

@@ -44,6 +44,57 @@ function normalizeCommand(command: unknown): string | null {
   return null;
 }
 
+async function spawnGuardProcess(options: {
+  command: string[];
+  cwd: string;
+  env: Record<string, string>;
+  stdin: string;
+}): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  const bun = (globalThis as { Bun?: { spawn?: Function } }).Bun;
+  if (typeof bun?.spawn === "function") {
+    const proc = bun.spawn(options.command, {
+      cwd: options.cwd,
+      env: options.env,
+      stdin: new Blob([options.stdin]),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const stdoutPromise = new Response(proc.stdout).text();
+    const stderrPromise = new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    return {
+      exitCode,
+      stdout: await stdoutPromise,
+      stderr: await stderrPromise,
+    };
+  }
+
+  const { spawn } = await import("node:child_process");
+  return new Promise((resolve, reject) => {
+    const proc = spawn(options.command[0], options.command.slice(1), {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    proc.stderr?.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    proc.on("error", reject);
+    proc.on("close", (code: number | null) => {
+      resolve({ exitCode: code ?? 1, stdout, stderr });
+    });
+    proc.stdin?.on("error", () => {});
+    proc.stdin?.end(options.stdin);
+  });
+}
+
 async function runGuardHook(directory: string, payload: Record<string, unknown>) {
   const workspace = directory?.trim() || process.cwd();
   const guardArgv = [
@@ -57,19 +108,12 @@ async function runGuardHook(directory: string, payload: Record<string, unknown>)
     workspace,
     "--json",
   ];
-  const proc = Bun.spawn([GUARD_PYTHON, "-c", GUARD_HOOK_LAUNCHER], {
+  return spawnGuardProcess({
+    command: [GUARD_PYTHON, "-c", GUARD_HOOK_LAUNCHER],
     cwd: GUARD_HOME,
     env: hookProcessEnv(guardArgv),
-    stdin: new Blob([JSON.stringify(payload)]),
-    stdout: "pipe",
-    stderr: "pipe",
+    stdin: JSON.stringify(payload),
   });
-  const stdoutPromise = new Response(proc.stdout).text();
-  const stderrPromise = new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-  const stdout = await stdoutPromise;
-  const stderr = await stderrPromise;
-  return { exitCode, stdout, stderr };
 }
 
 function parseGuardPayload(stdout: string): Record<string, unknown> | null {

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/src/codex_plugin_scanner/guard/runtime/supply_chain_bundle.py

@@ -14,6 +14,7 @@ from .supply_chain_bundle_base import (
 from .supply_chain_bundle_models import (
     SupplyChainBundle,
     SupplyChainBundleAdvisory,
+    SupplyChainBundleEmergencyDeny,
     SupplyChainBundlePackage,
     SupplyChainBundlePolicyRule,
     SupplyChainBundleResponse,
@@ -36,6 +37,7 @@ __all__ = [
     "OfflineSupplyChainDecision",
     "SupplyChainBundle",
     "SupplyChainBundleAdvisory",
+    "SupplyChainBundleEmergencyDeny",
     "SupplyChainBundleError",
     "SupplyChainBundleExpiredError",
     "SupplyChainBundleKeyringError",

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/src/codex_plugin_scanner/guard/runtime/supply_chain_bundle_models.py

@@ -259,6 +259,39 @@ class SupplyChainBundlePolicyRule:
         )
 
 
+@dataclass(frozen=True, slots=True)
+class SupplyChainBundleEmergencyDeny:
+    """Emergency denylist entry inside the supply-chain bundle."""
+
+    ecosystem: str
+    name: str
+    namespace: str | None
+    reason: str
+    recommended_fix_version: str | None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "ecosystem": self.ecosystem,
+            "name": self.name,
+            "namespace": self.namespace,
+            "reason": self.reason,
+            "recommendedFixVersion": self.recommended_fix_version,
+        }
+
+    @staticmethod
+    def from_dict(data: dict[str, object]) -> SupplyChainBundleEmergencyDeny:
+        reason = _require_string(data, "reason")
+        if reason not in {"critical_active_exploit", "known_exploited", "known_malware"}:
+            raise SupplyChainBundleMalformedError(f"Unsupported emergency deny reason: {reason!r}")
+        return SupplyChainBundleEmergencyDeny(
+            ecosystem=_require_string(data, "ecosystem"),
+            name=_require_string(data, "name"),
+            namespace=_optional_string(data, "namespace"),
+            reason=reason,
+            recommended_fix_version=_optional_string(data, "recommendedFixVersion"),
+        )
+
+
 @dataclass(frozen=True, slots=True)
 class SupplyChainBundleSourceHash:
     """Source-hash metadata inside the supply-chain bundle."""
@@ -293,6 +326,7 @@ class SupplyChainBundle:
 
     advisories: tuple[SupplyChainBundleAdvisory, ...]
     bundle_version: str
+    emergency_denylist: tuple[SupplyChainBundleEmergencyDeny, ...]
     expires_at: str
     feed_snapshot_hash: str
     generated_at: str
@@ -321,6 +355,7 @@ class SupplyChainBundle:
         return {
             "advisories": [item.to_dict() for item in self.advisories],
             "bundleVersion": self.bundle_version,
+            "emergencyDenylist": [item.to_dict() for item in self.emergency_denylist],
             "expiresAt": self.expires_at,
             "feedSnapshotHash": self.feed_snapshot_hash,
             "generatedAt": self.generated_at,
@@ -337,11 +372,16 @@ class SupplyChainBundle:
     @staticmethod
     def from_dict(data: dict[str, object]) -> SupplyChainBundle:
         raw_advisories = data.get("advisories")
+        raw_emergency_denylist = data.get("emergencyDenylist")
         raw_packages = data.get("packages")
         raw_policy_rules = data.get("policyRules")
         raw_source_hashes = data.get("sourceHashes")
         if not isinstance(raw_advisories, list):
             raise SupplyChainBundleMalformedError("Bundle advisories must be a list")
+        if raw_emergency_denylist is None:
+            raw_emergency_denylist = []
+        if not isinstance(raw_emergency_denylist, list):
+            raise SupplyChainBundleMalformedError("Bundle emergencyDenylist must be a list")
         if not isinstance(raw_packages, list):
             raise SupplyChainBundleMalformedError("Bundle packages must be a list")
         if not isinstance(raw_policy_rules, list):
@@ -353,6 +393,11 @@ class SupplyChainBundle:
                 SupplyChainBundleAdvisory.from_dict(item) for item in raw_advisories if isinstance(item, dict)
             ),
             bundle_version=_require_string(data, "bundleVersion"),
+            emergency_denylist=tuple(
+                SupplyChainBundleEmergencyDeny.from_dict(item)
+                for item in raw_emergency_denylist
+                if isinstance(item, dict)
+            ),
             expires_at=_require_string(data, "expiresAt"),
             feed_snapshot_hash=_require_string(data, "feedSnapshotHash"),
             generated_at=_require_string(data, "generatedAt"),
@@ -371,6 +416,8 @@ class SupplyChainBundle:
         )
         if len(bundle.advisories) != len(raw_advisories):
             raise SupplyChainBundleMalformedError("Bundle advisories must contain only objects")
+        if len(bundle.emergency_denylist) != len(raw_emergency_denylist):
+            raise SupplyChainBundleMalformedError("Bundle emergencyDenylist must contain only objects")
         if len(bundle.packages) != len(raw_packages):
             raise SupplyChainBundleMalformedError("Bundle packages must contain only objects")
         if len(bundle.policy_rules) != len(raw_policy_rules):
@@ -390,6 +437,8 @@ class SupplyChainBundleResponse:
     """Signed supply-chain bundle response from Guard Cloud."""
 
     bundle: SupplyChainBundle
+    # Preserves the exact bundle JSON from Guard Cloud for hash/signature verification.
+    signed_bundle: dict[str, object]
     payload_hash: str
     signature: str
     signature_algorithm: str
@@ -397,7 +446,7 @@ class SupplyChainBundleResponse:
 
     def to_dict(self) -> dict[str, object]:
         return {
-            "bundle": self.bundle.to_dict(),
+            "bundle": dict(self.signed_bundle),
             "payloadHash": self.payload_hash,
             "signature": self.signature,
             "signatureAlgorithm": self.signature_algorithm,

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/src/codex_plugin_scanner/guard/runtime/supply_chain_bundle_runtime.py

@@ -95,6 +95,7 @@ def load_supply_chain_bundle_response(raw_json: str | dict[str, object]) -> Supp
         raise SupplyChainBundleMalformedError("Bundle response must include verification keys")
     return SupplyChainBundleResponse(
         bundle=SupplyChainBundle.from_dict(raw_bundle),
+        signed_bundle=raw_bundle,
         payload_hash=_require_string(data, "payloadHash"),
         signature=_require_string(data, "signature"),
         signature_algorithm=signature_algorithm,
@@ -156,7 +157,7 @@ def verify_supply_chain_bundle_response(
 ) -> None:
     """Verify payload hash, freshness, rollback, keyring anchor, and RSA-PSS signature."""
 
-    canonical_payload = canonical_supply_chain_bundle_payload(response.bundle)
+    canonical_payload = canonical_supply_chain_bundle_payload(response.signed_bundle)
     if hashlib.sha256(canonical_payload).hexdigest() != response.payload_hash:
         raise SupplyChainBundlePayloadHashError("Bundle payloadHash does not match the canonical payload")
     if cached_bundle_version is not None:

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/tests/test_guard_supply_chain_bundle.py

@@ -369,6 +369,38 @@ def test_supply_chain_bundle_offline_evaluation_blocks_high_confidence_and_monit
     assert stale_decision.reason == "stale_low_confidence"
 
 
+def test_supply_chain_bundle_verifies_portal_signed_payload_with_emergency_denylist() -> None:
+    private_key, _public_key = _generate_key_pair()
+    bundle = _bundle_dict()
+    bundle["emergencyDenylist"] = [
+        {
+            "ecosystem": "npm",
+            "name": "minimist",
+            "namespace": None,
+            "reason": "known_malware",
+            "recommendedFixVersion": "1.2.9",
+        }
+    ]
+    response = load_supply_chain_bundle_response(
+        json.dumps(_sign_bundle_response(bundle, private_key_pem=private_key))
+    )
+
+    verify_supply_chain_bundle_response(response, now=response.bundle.generated_at_timestamp + 5)
+    assert len(response.bundle.emergency_denylist) == 1
+    assert response.bundle.emergency_denylist[0].reason == "known_malware"
+
+
+def test_supply_chain_bundle_verifies_portal_signed_payload_with_sparse_policy_rules() -> None:
+    private_key, _public_key = _generate_key_pair()
+    bundle = _bundle_dict()
+    bundle["policyRules"] = [{"action": "block", "ruleId": "rule-1"}]
+    response = load_supply_chain_bundle_response(
+        json.dumps(_sign_bundle_response(bundle, private_key_pem=private_key))
+    )
+
+    verify_supply_chain_bundle_response(response, now=response.bundle.generated_at_timestamp + 5)
+
+
 def test_supply_chain_bundle_offline_evaluation_does_not_match_scoped_entries_from_unscoped_names() -> None:
     private_key, _public_key = _generate_key_pair()
     bundle = _bundle_dict()

{plugin_scanner-2.0.712 → plugin_scanner-2.0.714}/tests/test_opencode_pretool.py

@@ -73,10 +73,14 @@ def test_pretool_plugin_source_embeds_guard_paths(tmp_path: Path) -> None:
     source = pretool_plugin_source(ctx)
     assert str(ctx.guard_home.resolve()) in source
     assert "tool.execute.before" in source
-    assert "stdin: new Blob([JSON.stringify(payload)])" in source
+    assert "spawnGuardProcess" in source
+    assert "node:child_process" in source
     assert "normalizeCommand" in source
-    assert '.stream()' not in source.split("Bun.spawn", 1)[1].split("});", 1)[0]
-    assert "stdoutPromise" in source
+    spawn_block = source.split("async function spawnGuardProcess", 1)[1].split("async function runGuardHook", 1)[0]
+    assert "globalThis" in spawn_block
+    assert "Bun" in spawn_block
+    assert "stdin: new Blob([options.stdin])" in spawn_block
+    assert '.stream()' not in spawn_block
     assert "try {" in source
     assert 'source_scope: directory?.trim() ? "project" : "global"' in source
     assert "GUARD_HOOK_LAUNCHER" in source
@@ -84,8 +88,8 @@ def test_pretool_plugin_source_embeds_guard_paths(tmp_path: Path) -> None:
     assert "GUARD_INHERIT_ENV_KEYS" in source
     assert "HOL_GUARD_HOOK_ARGV" in source
     assert "cwd: GUARD_HOME" in source
-    spawn_block = source.split("Bun.spawn(", 1)[1].split("});", 1)[0]
-    assert "cwd: workspace" not in spawn_block
+    run_block = source.split("async function runGuardHook", 1)[1].split("function parseGuardPayload", 1)[0]
+    assert "cwd: workspace" not in run_block
     assert '"-m",' not in source
     assert '-m",' not in source
 
@@ -175,10 +179,22 @@ def test_pretool_hook_env_blocks_workspace_import_shadowing(tmp_path: Path) -> N
 
 def test_pretool_plugin_source_does_not_spawn_python_m_module(tmp_path: Path) -> None:
     source = pretool_plugin_source(_ctx(tmp_path))
-    spawn_block = source.split("Bun.spawn(", 1)[1].split("});", 1)[0]
-    assert "codex_plugin_scanner.cli" not in spawn_block
-    assert '"-c"' in spawn_block or "'-c'" in spawn_block or "-c" in spawn_block
-    assert "GUARD_HOOK_LAUNCHER" in spawn_block
+    run_block = source.split("return spawnGuardProcess({", 1)[1].split("});", 1)[0]
+    assert "codex_plugin_scanner.cli" not in run_block
+    assert '"-c"' in run_block or "'-c'" in run_block or "-c" in run_block
+    assert "GUARD_HOOK_LAUNCHER" in run_block
+
+
+def test_pretool_plugin_source_includes_node_spawn_fallback(tmp_path: Path) -> None:
+    spawn_block = pretool_plugin_source(_ctx(tmp_path)).split("async function spawnGuardProcess", 1)[1].split(
+        "async function runGuardHook",
+        1,
+    )[0]
+    assert "typeof bun?.spawn === \"function\"" in spawn_block
+    assert 'await import("node:child_process")' in spawn_block
+    assert 'proc.stdout?.setEncoding("utf8")' in spawn_block
+    assert 'proc.stdin?.on("error", () => {})' in spawn_block
+    assert "proc.stdin?.end(options.stdin)" in spawn_block
 
 
 def test_install_pretool_plugin_writes_managed_and_global_copies(tmp_path: Path) -> None: