plugin-scanner 2.0.893__tar.gz → 2.0.895__tar.gz

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.893"
+version = "2.0.895"
 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.893 → plugin_scanner-2.0.895}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.893"
+version = "2.0.895"
 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.893 → plugin_scanner-2.0.895}/src/codex_plugin_scanner/guard/config.py

@@ -178,8 +178,11 @@ EDITABLE_GUARD_SETTING_KEYS = frozenset(
         "telemetry",
         "sync",
         "billing",
+        "receipt_redaction_level",
     }
 )
+VALID_RECEIPT_REDACTION_LEVELS = frozenset({"full", "partial", "none"})
+
 VALID_APPROVAL_SURFACE_POLICIES = {"auto-open-once", "native-only", "approval-center"}
 BARE_TOML_KEY = re.compile(r"^[A-Za-z0-9_-]+$")
 WORKSPACE_BLOCKED_POLICY_KEYS = frozenset(
@@ -275,6 +278,7 @@ class GuardConfig:
     desktop_notifications: bool = True
     telemetry: bool = False
     sync: bool = False
+    receipt_redaction_level: str = "full"
     billing: bool = False
     runtime_detector_registry: bool = False
     runtime_detector_timeout_ms: int = 50
@@ -336,6 +340,12 @@ def _read_toml(path: Path) -> dict[str, object]:
         return {}
 
 
+def _coerce_loaded_receipt_redaction_level(value: object) -> str:
+    if isinstance(value, str) and value in VALID_RECEIPT_REDACTION_LEVELS:
+        return value
+    return "full"
+
+
 def load_guard_config(guard_home: Path, workspace: Path | None = None) -> GuardConfig:
     """Load Guard config from home and workspace overrides."""
 
@@ -404,6 +414,7 @@ def editable_guard_settings(config: GuardConfig) -> dict[str, object]:
         "desktop_notifications": config.desktop_notifications,
         "telemetry": config.telemetry,
         "sync": config.sync,
+        "receipt_redaction_level": config.receipt_redaction_level,
         "billing": config.billing,
         "approval_gate": public_config(config.guard_home).to_dict(),
     }
@@ -479,6 +490,10 @@ def _coerce_editable_setting(key: str, value: object) -> object:
         if isinstance(value, bool):
             return value
         raise ValueError(f"{key} must be true or false.")
+    if key == "receipt_redaction_level":
+        if isinstance(value, str) and value in VALID_RECEIPT_REDACTION_LEVELS:
+            return value
+        raise ValueError(f"Invalid receipt redaction level: {value!r}")
     raise ValueError(f"Unsupported Guard setting: {key}")
 
 
@@ -691,6 +706,7 @@ def overlay_synced_guard_policy(
         config.subprocess_action,
     )
     sync_enabled = payload.get("syncEnabled")
+    cloud_redaction_level = payload.get("receiptRedactionLevel")
     return replace(
         config,
         mode=next_mode,
@@ -700,6 +716,11 @@ def overlay_synced_guard_policy(
         new_network_domain_action=new_network_domain_action,
         subprocess_action=subprocess_action,
         sync=bool(sync_enabled) if isinstance(sync_enabled, bool) else config.sync,
+        receipt_redaction_level=(
+            cloud_redaction_level
+            if cloud_redaction_level in VALID_RECEIPT_REDACTION_LEVELS
+            else config.receipt_redaction_level
+        ),
     )
 
 

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/src/codex_plugin_scanner/guard/policy_bundle_parser.py

@@ -31,6 +31,11 @@ _POLICY_BUNDLE_CORE_KEYS = (
     "rules",
 )
 
+# receiptRedactionLevel is included in the policy bundle signing payload by the
+# portal (buildPolicyBundleCore), so it must be part of the canonical hash.
+# Older bundles may not have it, so treat it as optional in hash computation.
+_POLICY_BUNDLE_OPTIONAL_CORE_KEYS = ("receiptRedactionLevel",)
+
 _POLICY_BUNDLE_DEFAULT_ACTIONS = frozenset({"allow", "warn", "block"})
 _POLICY_BUNDLE_MODE_VALUES = frozenset({"observe", "prompt", "enforce"})
 _POLICY_BUNDLE_REVIEW_ACTIONS = frozenset({"allow", "review", "block"})
@@ -96,6 +101,9 @@ def computed_policy_bundle_hash(policy_bundle: dict[str, object]) -> str:
         if key not in policy_bundle:
             raise ValueError(f"missing_policy_bundle_key:{key}")
         bundle_core[key] = policy_bundle[key]
+    for key in _POLICY_BUNDLE_OPTIONAL_CORE_KEYS:
+        if key in policy_bundle:
+            bundle_core[key] = policy_bundle[key]
     verifier = bundle_core.get("verifier")
     if isinstance(verifier, dict):
         normalized_verifier = dict(verifier)
@@ -188,9 +196,14 @@ def canonical_policy_bundle_payload(policy_bundle: dict[str, object]) -> bytes:
         if key not in policy_bundle:
             raise ValueError(f"missing_policy_bundle_key:{key}")
         bundle_core[key] = policy_bundle[key]
+    for key in _POLICY_BUNDLE_OPTIONAL_CORE_KEYS:
+        if key in policy_bundle:
+            bundle_core[key] = policy_bundle[key]
     verifier = bundle_core.get("verifier")
     if isinstance(verifier, dict):
         normalized_verifier = dict(verifier)
+        if verifier.get("algorithm") == "rsa-pss-sha256":
+            normalized_verifier["publicKeyPem"] = None
         normalized_verifier["signature"] = None
         bundle_core["verifier"] = normalized_verifier
     workspace_id = policy_bundle.get("workspaceId")
@@ -360,6 +373,9 @@ def validated_policy_bundle_payload(
         "rules": rules,
         "acknowledgements": acknowledgements,
     }
+    receipt_redaction_level = _non_empty_string(policy_bundle.get("receiptRedactionLevel"))
+    if receipt_redaction_level is not None:
+        payload["receiptRedactionLevel"] = receipt_redaction_level
     cloud_exceptions = policy_bundle.get("cloudExceptions")
     if isinstance(cloud_exceptions, list) and cloud_exceptions:
         payload["cloudExceptions"] = cloud_exceptions

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/src/codex_plugin_scanner/guard/receipts/manager.py

@@ -11,9 +11,19 @@ from ..models import GUARD_ACTION_VALUES, GuardAction, GuardReceipt
 from ..runtime.actions import GuardActionEnvelope
 
 
-def _redacted_envelope_dict(envelope: GuardActionEnvelope) -> dict[str, object]:
-    """Return a cloud-safe redacted view of the action envelope."""
-    return {
+def _redacted_envelope_dict(
+    envelope: GuardActionEnvelope,
+    *,
+    redaction_level: str = "full",
+) -> dict[str, object]:
+    """Return a cloud-safe redacted view of the action envelope.
+
+    ``redaction_level`` controls how much command detail is included:
+    - ``full`` (default): command text never leaves the daemon (counts/booleans only)
+    - ``partial``: command text included (already secret-scrubbed via redact_text at source)
+    - ``none``: command text, target paths, network hosts, package name included
+    """
+    base: dict[str, object] = {
         "schema_version": envelope.schema_version,
         "action_id": envelope.action_id,
         "harness": envelope.harness,
@@ -34,6 +44,21 @@ def _redacted_envelope_dict(envelope: GuardActionEnvelope) -> dict[str, object]:
         "script_name": envelope.script_name,
     }
 
+    if redaction_level == "none":
+        if envelope.command is not None:
+            base["command"] = envelope.command
+        if envelope.target_paths:
+            base["target_paths"] = list(envelope.target_paths)
+        if envelope.network_hosts:
+            base["network_hosts"] = list(envelope.network_hosts)
+        if envelope.package_name is not None and len(envelope.package_name) > 0:
+            base["package_name"] = envelope.package_name
+    elif redaction_level == "partial":
+        if envelope.command is not None:
+            base["command"] = envelope.command
+
+    return base
+
 
 def _auto_diff_summary(changed_capabilities: list[str]) -> str:
     """Generate a prose diff summary from the changed capabilities list."""

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/src/codex_plugin_scanner/guard/runtime/runner.py

@@ -42,7 +42,7 @@ from ..cloud_exceptions import (
     dedupe_cloud_exceptions,
     stored_receipt_sync_cloud_exceptions,
 )
-from ..config import GuardConfig
+from ..config import VALID_RECEIPT_REDACTION_LEVELS, GuardConfig, load_guard_config
 from ..edge_events import build_runtime_session_event
 from ..models import GuardArtifact, HarnessDetection, PolicyDecision
 from ..package_firewall_entitlement import (
@@ -1213,6 +1213,7 @@ def sync_receipts(
     team_policy_pack_payload: dict[str, object] | None = None
     remote_decisions: set[PolicyDecision] = set()
     device_id, device_name = _guard_device_metadata(store)
+    redaction_level = _resolve_cloud_receipt_redaction_level(store)
     local_guard_online_at = _now()
     sync_context = _receipt_sync_context(
         store=store,
@@ -1228,6 +1229,7 @@ def sync_receipts(
                     receipt_batch,
                     device_id=device_id,
                     device_name=device_name,
+                    redaction_level=redaction_level,
                 ),
                 "syncContext": sync_context,
             }
@@ -1361,6 +1363,18 @@ def sync_receipts(
                 now,
             )
             store.set_sync_payload("policy_bundle_last_error", {}, now)
+            # Extract cloud-configured receipt redaction level from policy bundle
+            cloud_redaction_level = non_empty_string(
+                validated_policy_bundle.get("receiptRedactionLevel")
+                if isinstance(validated_policy_bundle, dict)
+                else None
+            )
+            if cloud_redaction_level and cloud_redaction_level in VALID_RECEIPT_REDACTION_LEVELS:
+                store.set_sync_payload(
+                    "cloud_receipt_redaction_level",
+                    {"level": cloud_redaction_level, "updated_at": now},
+                    now,
+                )
             remote_decisions.update(
                 _build_policy_bundle_decisions(
                     validated_policy_bundle,
@@ -3585,8 +3599,17 @@ def _cloud_sync_receipts_payload(
     *,
     device_id: str,
     device_name: str,
+    redaction_level: str = "full",
 ) -> list[dict[str, object]]:
-    return [_cloud_sync_receipt_payload(receipt, device_id=device_id, device_name=device_name) for receipt in receipts]
+    return [
+        _cloud_sync_receipt_payload(
+            receipt,
+            device_id=device_id,
+            device_name=device_name,
+            redaction_level=redaction_level,
+        )
+        for receipt in receipts
+    ]
 
 
 def _dedupe_sync_payload_items(items: list[dict[str, object]]) -> list[dict[str, object]]:
@@ -3687,11 +3710,32 @@ def _persist_receipt_sync_cursor(
     store.set_sync_payload("receipt_sync_cursor", payload, synced_at)
 
 
+def _resolve_cloud_receipt_redaction_level(store: GuardStore) -> str:
+    """Resolve the receipt redaction level for cloud sync.
+
+    Priority: cloud-configured level (from policy bundle downlink) >
+    local GuardConfig.receipt_redaction_level > 'full' (safest).
+    """
+    payload = store.get_sync_payload("cloud_receipt_redaction_level")
+    if isinstance(payload, dict):
+        level = payload.get("level")
+        if isinstance(level, str) and level in VALID_RECEIPT_REDACTION_LEVELS:
+            return level
+    try:
+        config = load_guard_config(store.guard_home)
+        if config.receipt_redaction_level in VALID_RECEIPT_REDACTION_LEVELS:
+            return config.receipt_redaction_level
+    except Exception:
+        pass
+    return "full"
+
+
 def _cloud_sync_receipt_payload(
     receipt: dict[str, object],
     *,
     device_id: str,
     device_name: str,
+    redaction_level: str = "full",
 ) -> dict[str, object]:
     receipt_fingerprint = _cloud_sync_receipt_fingerprint(receipt)
     artifact_id = _optional_string(receipt.get("artifact_id")) or f"guard:local-receipt:{receipt_fingerprint[:24]}"
@@ -3743,7 +3787,30 @@ def _cloud_sync_receipt_payload(
         payload["publisher"] = publisher
     redacted_envelope = receipt.get("envelope_redacted_json")
     if isinstance(redacted_envelope, dict) and redacted_envelope:
-        payload["envelopeRedacted"] = redacted_envelope
+        # When redaction level is not "full", enrich the envelope with command text
+        # from the full envelope (already secret-scrubbed at source via redact_text)
+        if redaction_level != "full":
+            full_envelope = receipt.get("action_envelope_json")
+            if isinstance(full_envelope, dict):
+                enriched = dict(redacted_envelope)
+                command = full_envelope.get("command")
+                if isinstance(command, str) and command:
+                    enriched["command"] = command
+                if redaction_level == "none":
+                    target_paths = full_envelope.get("target_paths")
+                    if isinstance(target_paths, list):
+                        enriched["target_paths"] = target_paths
+                    network_hosts = full_envelope.get("network_hosts")
+                    if isinstance(network_hosts, list):
+                        enriched["network_hosts"] = network_hosts
+                    package_name = full_envelope.get("package_name")
+                    if isinstance(package_name, str) and package_name:
+                        enriched["package_name"] = package_name
+                payload["envelopeRedacted"] = enriched
+            else:
+                payload["envelopeRedacted"] = redacted_envelope
+        else:
+            payload["envelopeRedacted"] = redacted_envelope
     return payload
 
 

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.895/tests/test_guard_receipt_redaction_level.py

@@ -0,0 +1,185 @@
+"""Tests for configurable receipt redaction levels."""
+
+from __future__ import annotations
+
+from codex_plugin_scanner.guard.config import (
+    VALID_RECEIPT_REDACTION_LEVELS,
+    _coerce_editable_setting,
+    _coerce_loaded_receipt_redaction_level,
+)
+from codex_plugin_scanner.guard.receipts.manager import _redacted_envelope_dict
+from codex_plugin_scanner.guard.runtime.actions import GuardActionEnvelope
+
+
+def _make_envelope(
+    *,
+    command: str | None = "rm -rf /important-dir",
+    target_paths: tuple[str, ...] = ("/important-dir",),
+    network_hosts: tuple[str, ...] = ("example.com",),
+    package_name: str | None = "evil-package",
+) -> GuardActionEnvelope:
+    """Build a minimal envelope for testing."""
+    return GuardActionEnvelope(
+        schema_version=1,
+        action_id="test-action-001",
+        harness="test-harness",
+        event_name="tool_call",
+        action_type="command-write",
+        workspace="/test",
+        workspace_hash="abc123",
+        tool_name="bash",
+        command=command,
+        prompt_excerpt=None,
+        prompt_text=None,
+        target_paths=target_paths,
+        network_hosts=network_hosts,
+        mcp_server=None,
+        mcp_tool=None,
+        package_manager=None,
+        package_name=package_name,
+        package_intent_kind=None,
+        package_targets=(),
+        pre_execution_result=None,
+        script_name=None,
+    )
+
+
+class TestRedactionLevelConfig:
+    def test_valid_levels(self):
+        assert VALID_RECEIPT_REDACTION_LEVELS == frozenset({"full", "partial", "none"})
+
+    def test_coerce_loaded_default(self):
+        assert _coerce_loaded_receipt_redaction_level(None) == "full"
+        assert _coerce_loaded_receipt_redaction_level("invalid") == "full"
+
+    def test_coerce_loaded_valid(self):
+        assert _coerce_loaded_receipt_redaction_level("full") == "full"
+        assert _coerce_loaded_receipt_redaction_level("partial") == "partial"
+        assert _coerce_loaded_receipt_redaction_level("none") == "none"
+
+    def test_coerce_editable_valid(self):
+        assert _coerce_editable_setting("receipt_redaction_level", "full") == "full"
+        assert _coerce_editable_setting("receipt_redaction_level", "partial") == "partial"
+        assert _coerce_editable_setting("receipt_redaction_level", "none") == "none"
+
+    def test_coerce_editable_invalid(self):
+        try:
+            _coerce_editable_setting("receipt_redaction_level", "invalid")
+            assert False, "Should have raised ValueError"
+        except ValueError as e:
+            assert "receipt redaction level" in str(e).lower()
+
+
+class TestRedactedEnvelopeDictFull:
+    def test_full_level_excludes_command(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="full")
+        assert "command" not in result
+        assert result["command_length"] == len("rm -rf /important-dir")
+
+    def test_full_level_excludes_target_paths(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="full")
+        assert "target_paths" not in result
+        assert result["target_paths_count"] == 1
+
+    def test_full_level_excludes_network_hosts(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="full")
+        assert "network_hosts" not in result
+        assert result["network_hosts_count"] == 1
+
+    def test_full_level_excludes_package_name(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="full")
+        assert "package_name" not in result
+        assert result["has_package_name"] is True
+
+    def test_full_level_default(self):
+        """Default redaction level is 'full'."""
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope)
+        assert "command" not in result
+
+
+class TestRedactedEnvelopeDictPartial:
+    def test_partial_level_includes_command(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert result.get("command") == "rm -rf /important-dir"
+
+    def test_partial_level_excludes_target_paths(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert "target_paths" not in result
+
+    def test_partial_level_excludes_network_hosts(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert "network_hosts" not in result
+
+    def test_partial_level_excludes_package_name(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert "package_name" not in result
+
+    def test_partial_level_includes_metadata(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert result["command_length"] == len("rm -rf /important-dir")
+        assert result["tool_name"] == "bash"
+        assert result["has_package_name"] is True
+
+
+class TestRedactedEnvelopeDictNone:
+    def test_none_level_includes_command(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert result.get("command") == "rm -rf /important-dir"
+
+    def test_none_level_includes_target_paths(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert result.get("target_paths") == ["/important-dir"]
+
+    def test_none_level_includes_network_hosts(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert result.get("network_hosts") == ["example.com"]
+
+    def test_none_level_includes_package_name(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert result.get("package_name") == "evil-package"
+
+    def test_none_level_includes_metadata(self):
+        envelope = _make_envelope()
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert result["command_length"] == len("rm -rf /important-dir")
+        assert result["tool_name"] == "bash"
+
+
+class TestRedactedEnvelopeDictEdgeCases:
+    def test_none_command_with_partial(self):
+        envelope = _make_envelope(command=None)
+        result = _redacted_envelope_dict(envelope, redaction_level="partial")
+        assert "command" not in result
+        assert result["command_length"] == 0
+
+    def test_empty_package_name_with_none(self):
+        envelope = _make_envelope(package_name="")
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert "package_name" not in result
+        assert result["has_package_name"] is False
+
+    def test_empty_target_paths_with_none(self):
+        envelope = _make_envelope(target_paths=())
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert "target_paths" not in result
+        assert result["target_paths_count"] == 0
+
+    def test_empty_network_hosts_with_none(self):
+        envelope = _make_envelope(network_hosts=())
+        result = _redacted_envelope_dict(envelope, redaction_level="none")
+        assert "network_hosts" not in result
+        assert result["network_hosts_count"] == 0

{plugin_scanner-2.0.893 → plugin_scanner-2.0.895}/uv.lock

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