plugin-scanner 2.0.844__tar.gz → 2.0.845__tar.gz

{plugin_scanner-2.0.844 → plugin_scanner-2.0.845}/PKG-INFO

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

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

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

@@ -378,17 +378,41 @@ def apply_approval_resolution(
         now=resolved_at,
     )
     persisted_rule = persist_policy is True or (persist_policy is None and scope != "artifact")
+    local_once_fallback = False
     if persisted_rule:
+        store.ensure_policy_integrity_ready_for_write(
+            harness=decision.harness if decision.harness != "*" else None,
+            approval_gate_grant=resolved_gate_grant,
+            now=resolved_at,
+        )
         store.upsert_policy(decision, resolved_at, approval_gate_grant=resolved_gate_grant)
+        if action == "allow" and _should_record_local_once_replay(request):
+            local_once_fallback = _record_local_once_approval(
+                store,
+                request_id=request_id,
+                decision=decision,
+                harness=str(request["harness"]),
+                created_at=resolved_at,
+            )
     elif persist_policy is None and scope == "artifact":
+        once_decision = replace(
+            decision,
+            expires_at=_approval_once_policy_expires_at(resolved_at),
+        )
         store.upsert_policy(
-            replace(
-                decision,
-                expires_at=_approval_once_policy_expires_at(resolved_at),
-            ),
+            once_decision,
             resolved_at,
             approval_gate_grant=resolved_gate_grant,
         )
+        if action == "allow" and _should_record_local_once_replay(request):
+            local_once_fallback = _record_local_once_approval(
+                store,
+                request_id=request_id,
+                decision=once_decision,
+                harness=str(request["harness"]),
+                created_at=resolved_at,
+            )
+
     resolution_harness = None if scope == "global" else str(request["harness"])
     if return_queue_result:
         result = store.resolve_request_with_queue_result(
@@ -431,6 +455,7 @@ def apply_approval_resolution(
             scope,
             resolved_at,
             persisted_rule=persisted_rule,
+            local_once_fallback=local_once_fallback,
         )
         return result
     resolved_ids: list[str] = []
@@ -470,6 +495,7 @@ def apply_approval_resolution(
         scope,
         resolved_at,
         persisted_rule=persisted_rule,
+        local_once_fallback=local_once_fallback,
     )
     return updated
 
@@ -591,15 +617,27 @@ def _record_resolution_event(
     resolved_at: str,
     *,
     persisted_rule: bool,
+    local_once_fallback: bool = False,
 ) -> None:
     store.add_event(
         "approval.resolved",
-        {"request_id": request_id, "action": action, "scope": scope, "persisted_rule": persisted_rule},
+        {
+            "request_id": request_id,
+            "action": action,
+            "scope": scope,
+            "persisted_rule": persisted_rule,
+            "local_once_fallback": local_once_fallback,
+        },
         resolved_at,
     )
     store.add_event(
         "rule.remembered.local" if persisted_rule else "approval.once",
-        {"request_id": request_id, "action": action, "scope": scope},
+        {
+            "request_id": request_id,
+            "action": action,
+            "scope": scope,
+            "local_once_fallback": local_once_fallback,
+        },
         resolved_at,
     )
 
@@ -1014,6 +1052,41 @@ def _approval_once_policy_expires_at(resolved_at: str) -> str:
     return (parsed + _APPROVAL_ONCE_POLICY_TTL).isoformat()
 
 
+def _should_record_local_once_replay(request: Mapping[str, object]) -> bool:
+    artifact_type = request.get("artifact_type")
+    if artifact_type == "package_request":
+        return True
+    artifact_id = request.get("artifact_id")
+    if isinstance(artifact_id, str) and ":package-request:" in artifact_id:
+        return True
+    launch_target = request.get("launch_target")
+    if not isinstance(launch_target, str):
+        return False
+    return launch_target.startswith(("npm ", "npx ", "pnpm ", "yarn ", "bun "))
+
+
+def _record_local_once_approval(
+    store: GuardStore,
+    *,
+    request_id: str,
+    decision: PolicyDecision,
+    harness: str,
+    created_at: str,
+) -> bool:
+    approval_id = store.record_local_once_approval(
+        request_id=request_id,
+        harness=harness,
+        artifact_id=decision.artifact_id,
+        artifact_hash=decision.artifact_hash,
+        workspace=decision.workspace,
+        publisher=decision.publisher,
+        action=decision.action,
+        created_at=created_at,
+        expires_at=decision.expires_at or _approval_once_policy_expires_at(created_at),
+    )
+    return approval_id is not None
+
+
 def _build_runtime_cloud_context(
     store: GuardStore,
     latest_connect_state: dict[str, object] | None,

{plugin_scanner-2.0.844 → plugin_scanner-2.0.845}/src/codex_plugin_scanner/guard/store.py

@@ -2136,6 +2136,25 @@ class GuardStore:
             )
             """,
             """
+            create table if not exists guard_local_once_approvals (
+              approval_id text primary key,
+              request_id text not null,
+              harness text not null,
+              artifact_id text not null,
+              artifact_hash text not null,
+              workspace text,
+              publisher text,
+              action text not null,
+              created_at text not null,
+              expires_at text not null,
+              claimed_at text
+            )
+            """,
+            """
+            create index if not exists idx_guard_local_once_approvals_lookup
+            on guard_local_once_approvals (claimed_at, harness, artifact_id, artifact_hash, expires_at)
+            """,
+            """
             create table if not exists guard_cloud_events (
               event_id text primary key,
               idempotency_key text not null unique,
@@ -3168,6 +3187,35 @@ class GuardStore:
             state = self._refresh_policy_integrity_state(connection, now=current_time, create_key=True)
             trust_status = TrustStatus.from_policy_integrity_state(state).to_dict()
             key, key_id = self._policy_integrity_secret_material(create=True)
+            local_once_decision = None
+            local_once_hashes = tuple(
+                dict.fromkeys(hash_value for hash_value in (artifact_hash, runtime_exact_match_key) if hash_value)
+            )
+            for local_once_hash in local_once_hashes:
+                local_once_decision = self._claim_local_once_approval_locked(
+                    connection,
+                    harness=harness,
+                    artifact_id=artifact_id,
+                    artifact_hash=local_once_hash,
+                    workspace=workspace,
+                    publisher=publisher,
+                    now=current_time,
+                )
+                if local_once_decision is not None:
+                    break
+            if local_once_decision is not None:
+                selected_payload = local_once_decision
+                events.append(
+                    (
+                        "approval.local_once_applied",
+                        {
+                            "approval_id": local_once_decision.get("approval_id"),
+                            "request_id": local_once_decision.get("request_id"),
+                            "harness": harness,
+                            "artifact_id": artifact_id,
+                        },
+                    )
+                )
             rows = connection.execute(
                 """
                 select decision_id, harness, scope, artifact_id, action, artifact_hash, workspace, publisher, source,
@@ -3233,13 +3281,13 @@ class GuardStore:
                     current_time,
                 ),
             ).fetchall()
-            if not rows:
+            if not rows and selected_payload is None:
                 return {
                     "decision": None,
                     "ignored_local_integrity": None,
                     "trust_status": trust_status,
                 }
-            for candidate in rows:
+            for candidate in rows if selected_payload is None else ():
                 if _scoped_runtime_row_requires_exact_match(
                     scope=str(candidate["scope"]),
                     stored_artifact_id=(
@@ -4460,6 +4508,61 @@ class GuardStore:
             "items": invalid_items,
         }
 
+    def ensure_policy_integrity_ready_for_write(
+        self,
+        *,
+        harness: str | None = None,
+        approval_gate_grant: ApprovalGateGrant | None = None,
+        now: str | None = None,
+    ) -> dict[str, object]:
+        current_time = now or _now()
+        before = self.get_policy_integrity_status(harness=harness)
+        if _policy_integrity_ready_for_local_write(before):
+            before["autorepair"] = {"attempted": False, "cleared": 0}
+            return before
+
+        attempts: list[dict[str, object]] = []
+        try:
+            setup = self.setup_policy_integrity(harness=harness, now=current_time)
+            attempts.append({"step": "setup", "mode": setup.get("mode"), "counts": setup.get("counts")})
+            if _policy_integrity_ready_for_local_write(setup):
+                setup["autorepair"] = {"attempted": True, "cleared": 0, "steps": attempts}
+                self.add_event("policy_integrity.autorepaired", {"steps": attempts}, current_time)
+                return setup
+        except Exception as error:  # pragma: no cover - exercised through final degraded status assertions.
+            attempts.append({"step": "setup", "error": type(error).__name__})
+
+        try:
+            repair = self.repair_policy_integrity(
+                clear_invalid=True,
+                harness=harness,
+                approval_gate_grant=approval_gate_grant,
+                now=current_time,
+            )
+            attempts.append(
+                {
+                    "step": "clear_invalid",
+                    "cleared": repair.get("cleared"),
+                    "mode": repair.get("mode"),
+                    "counts": repair.get("counts"),
+                }
+            )
+            if _policy_integrity_ready_for_local_write(repair):
+                repair["autorepair"] = {
+                    "attempted": True,
+                    "cleared": repair.get("cleared", 0),
+                    "steps": attempts,
+                }
+                self.add_event("policy_integrity.autorepaired", {"steps": attempts}, current_time)
+                return repair
+        except Exception as error:
+            attempts.append({"step": "clear_invalid", "error": type(error).__name__})
+
+        final = self.get_policy_integrity_status(harness=harness)
+        final["autorepair"] = {"attempted": True, "cleared": 0, "steps": attempts}
+        self.add_event("policy_integrity.autorepair_failed", {"steps": attempts}, current_time)
+        return final
+
     def repair_policy_integrity(
         self,
         *,
@@ -5186,6 +5289,104 @@ class GuardStore:
                 (event_name, json.dumps(payload), now),
             )
 
+    def record_local_once_approval(
+        self,
+        *,
+        request_id: str,
+        harness: str,
+        artifact_id: str | None,
+        artifact_hash: str | None,
+        workspace: str | None,
+        publisher: str | None,
+        action: str,
+        created_at: str,
+        expires_at: str,
+    ) -> str | None:
+        if not artifact_id or not artifact_hash:
+            return None
+        approval_id = uuid4().hex
+        workspace_key = _workspace_policy_key(workspace)
+        with self._connect() as connection:
+            connection.execute(
+                """
+                insert into guard_local_once_approvals (
+                  approval_id, request_id, harness, artifact_id, artifact_hash, workspace, publisher, action,
+                  created_at, expires_at, claimed_at
+                )
+                values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, null)
+                """,
+                (
+                    approval_id,
+                    request_id,
+                    harness,
+                    artifact_id,
+                    artifact_hash,
+                    workspace_key,
+                    publisher,
+                    action,
+                    created_at,
+                    expires_at,
+                ),
+            )
+        return approval_id
+
+    @staticmethod
+    def _claim_local_once_approval_locked(
+        connection: sqlite3.Connection,
+        *,
+        harness: str,
+        artifact_id: str | None,
+        artifact_hash: str | None,
+        workspace: str | None,
+        publisher: str | None,
+        now: str,
+    ) -> dict[str, object] | None:
+        if not artifact_id or not artifact_hash:
+            return None
+        workspace_key = _workspace_policy_key(workspace)
+        row = connection.execute(
+            """
+            select approval_id, request_id, harness, artifact_id, artifact_hash, workspace, publisher, action,
+                   created_at, expires_at
+            from guard_local_once_approvals
+            where claimed_at is null
+              and harness = ?
+              and artifact_id = ?
+              and artifact_hash = ?
+              and expires_at > ?
+              and (workspace is null or workspace = ?)
+              and (publisher is null or publisher = ?)
+            order by created_at desc
+            limit 1
+            """,
+            (harness, artifact_id, artifact_hash, now, workspace_key, publisher),
+        ).fetchone()
+        if row is None:
+            return None
+        claim_cursor = connection.execute(
+            "update guard_local_once_approvals set claimed_at = ? where approval_id = ? and claimed_at is null",
+            (now, str(row["approval_id"])),
+        )
+        if claim_cursor.rowcount != 1:
+            return None
+        return {
+            "action": str(row["action"]),
+            "approval_id": str(row["approval_id"]),
+            "artifact_hash": row["artifact_hash"],
+            "artifact_id": row["artifact_id"],
+            "decision_id": None,
+            "expires_at": row["expires_at"],
+            "harness": str(row["harness"]),
+            "owner": None,
+            "publisher": row["publisher"],
+            "reason": "approved once in review",
+            "request_id": str(row["request_id"]),
+            "scope": "artifact",
+            "source": "approval-gate-once",
+            "updated_at": str(row["created_at"]),
+            "workspace": row["workspace"],
+        }
+
     def claim_remote_once_receipt(
         self,
         receipt_id: str,
@@ -6935,6 +7136,13 @@ def _warn_only_policy_integrity_status(status: str, state: Mapping[str, object],
     return all(isinstance(reason, str) and reason in allowed_reasons for reason in reasons)
 
 
+def _policy_integrity_ready_for_local_write(payload: Mapping[str, object]) -> bool:
+    trust = payload.get("trust_status")
+    if not isinstance(trust, Mapping):
+        return False
+    return payload.get("mode") == "protected" and trust.get("remembered_rules") == "enforced"
+
+
 def _family_key_value(family_key: str) -> str:
     if family_key.startswith("family:"):
         return family_key.removeprefix("family:")

{plugin_scanner-2.0.844 → plugin_scanner-2.0.845}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.844 → plugin_scanner-2.0.845}/tests/test_guard_approvals.py

@@ -975,6 +975,199 @@ class TestGuardApprovals:
         assert pending == []
         assert decisions[0]["harness"] == "*"
 
+    def test_guard_artifact_approval_once_uses_transient_exact_replay(self, tmp_path):
+        store = GuardStore(tmp_path / "guard-home")
+        artifact_id = "guard-cli:project:package-request:impeccable"
+        artifact_hash = "hash-impeccable"
+        store.add_approval_request(
+            GuardApprovalRequest(
+                request_id="req-package-once",
+                harness="guard-cli",
+                artifact_id=artifact_id,
+                artifact_name="impeccable",
+                artifact_type="package_request",
+                artifact_hash=artifact_hash,
+                policy_action="require-reapproval",
+                recommended_scope="artifact",
+                changed_fields=("package_request",),
+                source_scope="project",
+                config_path=str(tmp_path / "workspace" / "hol-guard.toml"),
+                workspace=str(tmp_path / "workspace"),
+                launch_target="npx impeccable update",
+                review_command="hol-guard approvals approve req-package-once",
+                approval_url="http://127.0.0.1:4455/approvals/req-package-once",
+            ),
+            "2026-04-11T00:00:00+00:00",
+        )
+
+        resolved = apply_approval_resolution(
+            store=store,
+            request_id="req-package-once",
+            action="allow",
+            scope="artifact",
+            workspace=None,
+            reason="approved once",
+            now="2026-04-11T00:02:00+00:00",
+        )
+
+        with store._connect() as connection:
+            policy_count = connection.execute("select count(*) from policy_decisions").fetchone()[0]
+        assert policy_count == 1
+        store._policy_integrity_secret_store = None
+        first_retry = store.resolve_policy_decision(
+            "guard-cli",
+            artifact_id,
+            artifact_hash,
+            str(tmp_path / "workspace"),
+            now="2026-04-11T00:03:00+00:00",
+        )
+        second_retry = store.resolve_policy_decision(
+            "guard-cli",
+            artifact_id,
+            artifact_hash,
+            str(tmp_path / "workspace"),
+            now="2026-04-11T00:04:00+00:00",
+        )
+
+        assert resolved["status"] == "resolved"
+        assert first_retry is not None
+        assert first_retry["action"] == "allow"
+        assert second_retry is None
+
+    def test_guard_saved_scope_repairs_integrity_before_policy_write(self, tmp_path, monkeypatch):
+        store = GuardStore(tmp_path / "guard-home")
+        calls = []
+
+        def fake_repair(**kwargs):
+            calls.append(kwargs)
+            return {"mode": "protected", "trust_status": {"remembered_rules": "enforced"}}
+
+        monkeypatch.setattr(store, "ensure_policy_integrity_ready_for_write", fake_repair)
+        store.add_approval_request(
+            GuardApprovalRequest(
+                request_id="req-package-save",
+                harness="guard-cli",
+                artifact_id="guard-cli:project:package-request:impeccable",
+                artifact_name="impeccable",
+                artifact_type="package_request",
+                artifact_hash="hash-impeccable",
+                policy_action="require-reapproval",
+                recommended_scope="global",
+                changed_fields=("package_request",),
+                source_scope="project",
+                config_path=str(tmp_path / "workspace" / "hol-guard.toml"),
+                workspace=str(tmp_path / "workspace"),
+                launch_target="npx impeccable update",
+                review_command="hol-guard approvals approve req-package-save",
+                approval_url="http://127.0.0.1:4455/approvals/req-package-save",
+            ),
+            "2026-04-11T00:00:00+00:00",
+        )
+
+        apply_approval_resolution(
+            store=store,
+            request_id="req-package-save",
+            action="allow",
+            scope="global",
+            workspace=None,
+            reason="remember globally",
+            now="2026-04-11T00:02:00+00:00",
+        )
+
+        decisions = store.list_policy_decisions()
+        assert calls
+        assert decisions[0]["harness"] == "*"
+        assert decisions[0]["scope"] == "global"
+
+    def test_guard_saved_scope_falls_back_to_once_when_integrity_repair_fails(self, tmp_path, monkeypatch):
+        store = GuardStore(tmp_path / "guard-home")
+        workspace = str(tmp_path / "workspace")
+        artifact_id = "guard-cli:project:package-request:impeccable"
+        store.add_approval_request(
+            GuardApprovalRequest(
+                request_id="req-package-degraded",
+                harness="guard-cli",
+                artifact_id=artifact_id,
+                artifact_name="impeccable",
+                artifact_type="package_request",
+                artifact_hash="hash-impeccable",
+                policy_action="require-reapproval",
+                recommended_scope="global",
+                changed_fields=("package_request",),
+                source_scope="project",
+                config_path=str(tmp_path / "workspace" / "hol-guard.toml"),
+                workspace=workspace,
+                launch_target="npx impeccable update",
+                review_command="hol-guard approvals approve req-package-degraded",
+                approval_url="http://127.0.0.1:4455/approvals/req-package-degraded",
+            ),
+            "2026-04-11T00:00:00+00:00",
+        )
+        monkeypatch.setattr(
+            store,
+            "ensure_policy_integrity_ready_for_write",
+            lambda **_kwargs: {"mode": "degraded", "trust_status": {"remembered_rules": "disabled_degraded"}},
+        )
+
+        apply_approval_resolution(
+            store=store,
+            request_id="req-package-degraded",
+            action="allow",
+            scope="global",
+            workspace=None,
+            reason="remember globally",
+            now="2026-04-11T00:02:00+00:00",
+        )
+
+        first_retry = store.resolve_policy_decision(
+            "guard-cli",
+            artifact_id,
+            "hash-impeccable",
+            workspace,
+            now="2026-04-11T00:03:00+00:00",
+        )
+
+        decisions = store.list_policy_decisions()
+        assert decisions[0]["scope"] == "global"
+        assert first_retry is not None
+        assert first_retry["action"] == "allow"
+
+    def test_guard_local_once_claim_returns_none_when_update_loses_race(self):
+        class FakeCursor:
+            rowcount = 0
+
+        class FakeConnection:
+            def execute(self, query, _params=()):
+                if query.lstrip().startswith("select"):
+                    return self
+                return FakeCursor()
+
+            def fetchone(self):
+                return {
+                    "action": "allow",
+                    "approval_id": "approval-race",
+                    "artifact_hash": "hash-impeccable",
+                    "artifact_id": "guard-cli:project:package-request:impeccable",
+                    "created_at": "2026-04-11T00:00:00+00:00",
+                    "expires_at": "2026-04-11T00:05:00+00:00",
+                    "harness": "guard-cli",
+                    "publisher": None,
+                    "request_id": "req-race",
+                    "workspace": None,
+                }
+
+        claimed = GuardStore._claim_local_once_approval_locked(
+            FakeConnection(),
+            harness="guard-cli",
+            artifact_id="guard-cli:project:package-request:impeccable",
+            artifact_hash="hash-impeccable",
+            workspace=None,
+            publisher=None,
+            now="2026-04-11T00:01:00+00:00",
+        )
+
+        assert claimed is None
+
     def test_guard_broad_scope_resolution_clears_more_than_default_pending_page(self, tmp_path):
         store = GuardStore(tmp_path / "guard-home")
         for index in range(520):
@@ -1013,25 +1206,25 @@ class TestGuardApprovals:
 
     def test_guard_store_ignores_expired_policy_decisions(self, tmp_path):
         store = GuardStore(tmp_path / "guard-home")
-        store.upsert_policy(
-            PolicyDecision(
-                harness="codex",
-                scope="artifact",
-                action="allow",
-                artifact_id="codex:project:workspace_skill",
-                artifact_hash="hash-123",
-                expires_at="2026-04-11T01:00:00+00:00",
-            ),
-            "2026-04-11T00:00:00+00:00",
+        store.record_local_once_approval(
+            request_id="req-expiring-once",
+            harness="codex",
+            artifact_id="codex:project:workspace_skill",
+            artifact_hash="hash-123",
+            workspace=None,
+            publisher=None,
+            action="allow",
+            created_at="2026-04-11T00:00:00+00:00",
+            expires_at="2026-04-11T01:00:00+00:00",
         )
 
-        before_expiry = store.resolve_policy(
+        before_expiry = store.resolve_policy_decision(
             "codex",
             "codex:project:workspace_skill",
             "hash-123",
             now="2026-04-11T00:30:00+00:00",
         )
-        after_expiry = store.resolve_policy(
+        after_expiry = store.resolve_policy_decision(
             "codex",
             "codex:project:workspace_skill",
             "hash-123",
@@ -1039,10 +1232,10 @@ class TestGuardApprovals:
         )
         decisions = store.list_policy_decisions()
 
-        assert before_expiry == "allow"
+        assert before_expiry is not None
+        assert before_expiry["action"] == "allow"
         assert after_expiry is None
-        assert decisions[0]["expires_at"] == "2026-04-11T01:00:00+00:00"
-        assert decisions[0]["source"] == "local"
+        assert decisions == []
 
     def test_guard_pending_request_payload_lists_supported_scopes(self, tmp_path):
         store = GuardStore(tmp_path / "guard-home")
@@ -3178,6 +3371,7 @@ class TestGuardApprovals:
                 "guard-cli:project:package-request:a",
                 "hash-package-a",
                 str(workspace_dir),
+                now="2026-04-11T00:03:00+00:00",
             )["action"]
             == "allow"
         )