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

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

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

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

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

@@ -22,6 +22,7 @@ from .shim_probe import (
     parse_protect_json_stdout,
     protect_evaluator_evidence,
 )
+from .sqlite_tuning import SQLITE_CONNECT_TIMEOUT_SECONDS
 from .stable_digest import stable_digest_hex
 
 
@@ -61,6 +62,7 @@ _PACKAGE_SHIM_COMMANDS = {
 _PACKAGE_SHIM_MANIFEST = "manifest.json"
 _GUARD_PROFILE_MARKER = "# HOL Guard harness launchers"
 _PACKAGE_PROFILE_MARKER = "# HOL Guard package manager shims"
+_PACKAGE_SHIM_PROBE_TIMEOUT_SECONDS = int(SQLITE_CONNECT_TIMEOUT_SECONDS) + 5
 # Path fragments that indicate a shim dir lives in an ephemeral location (a test
 # temp dir, the system temp root, etc.). Such paths must never be written into a
 # long-lived shell profile: they vanish and leave broken PATH entries behind.
@@ -1275,7 +1277,7 @@ def probe_package_shim_intercepts(
                 cwd=target_workspace,
                 env=probe_env,
                 text=True,
-                timeout=15,
+                timeout=_PACKAGE_SHIM_PROBE_TIMEOUT_SECONDS,
             )
         except (subprocess.TimeoutExpired, OSError):
             manager_results.append(

plugin_scanner-2.0.845/src/codex_plugin_scanner/guard/sqlite_tuning.py

@@ -0,0 +1,7 @@
+"""Shared SQLite timing configuration for Guard local storage."""
+
+from __future__ import annotations
+
+SQLITE_CONNECT_TIMEOUT_SECONDS = 30.0
+SQLITE_BUSY_TIMEOUT_MS = int(SQLITE_CONNECT_TIMEOUT_SECONDS * 1000)
+SQLITE_WAL_BUSY_TIMEOUT_MS = 1000

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

@@ -53,6 +53,7 @@ from .policy_integrity import (
 from .runtime.actions import GuardActionEnvelope
 from .runtime.scanner_cache import scanner_cache_key
 from .schemas.guard_event_v1 import GuardEventV1
+from .sqlite_tuning import SQLITE_BUSY_TIMEOUT_MS, SQLITE_CONNECT_TIMEOUT_SECONDS, SQLITE_WAL_BUSY_TIMEOUT_MS
 from .store_approvals import (
     _json_object,
     _json_object_list,
@@ -270,7 +271,6 @@ _REMOTE_POLICY_SOURCE_PARAMS = tuple(sorted(REMOTE_POLICY_SOURCES))
 _REMOTE_POLICY_SOURCE_PLACEHOLDERS = "(" + ",".join("?" for _ in _REMOTE_POLICY_SOURCE_PARAMS) + ")"
 _POLICY_SCOPES = frozenset({"artifact", "workspace", "publisher", "harness", "global"})
 _SLOW_STORE_WARNING_ENV = "HOL_GUARD_WARN_SLOW_STORE"
-_SQLITE_CONNECT_TIMEOUT_SECONDS = 30.0
 _SQLITE_LOCK_RETRY_ATTEMPTS = 5
 _SQLITE_LOCK_RETRY_DELAY_SECONDS = 0.1
 _SECRET_FINGERPRINT_PREFIX = "scrypt$"
@@ -1870,11 +1870,11 @@ class GuardStore:
 
     @contextmanager
     def _connect(self) -> Iterator[sqlite3.Connection]:
-        connection = sqlite3.connect(self.path, timeout=_SQLITE_CONNECT_TIMEOUT_SECONDS)
+        connection = sqlite3.connect(self.path, timeout=SQLITE_CONNECT_TIMEOUT_SECONDS)
         connection.row_factory = sqlite3.Row
         start = time.monotonic()
         try:
-            connection.execute("pragma busy_timeout=10000")
+            connection.execute(f"pragma busy_timeout={SQLITE_BUSY_TIMEOUT_MS}")
             yield connection
             connection.commit()
         finally:
@@ -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,
@@ -2335,14 +2354,21 @@ class GuardStore:
 
     @staticmethod
     def _enable_wal_mode(connection: sqlite3.Connection) -> None:
-        for attempt in range(_SQLITE_LOCK_RETRY_ATTEMPTS):
-            try:
-                connection.execute("pragma journal_mode=WAL")
-                return
-            except sqlite3.OperationalError as exc:
-                if "database is locked" not in str(exc).lower() or attempt == _SQLITE_LOCK_RETRY_ATTEMPTS - 1:
-                    raise
-                time.sleep(_SQLITE_LOCK_RETRY_DELAY_SECONDS)
+        original_busy_timeout_row = connection.execute("pragma busy_timeout").fetchone()
+        original_busy_timeout_ms = int(original_busy_timeout_row[0]) if original_busy_timeout_row else 0
+        wal_busy_timeout_ms = min(original_busy_timeout_ms, SQLITE_WAL_BUSY_TIMEOUT_MS)
+        connection.execute(f"pragma busy_timeout={wal_busy_timeout_ms}")
+        try:
+            for attempt in range(_SQLITE_LOCK_RETRY_ATTEMPTS):
+                try:
+                    connection.execute("pragma journal_mode=WAL")
+                    return
+                except sqlite3.OperationalError as exc:
+                    if "database is locked" not in str(exc).lower() or attempt == _SQLITE_LOCK_RETRY_ATTEMPTS - 1:
+                        raise
+                    time.sleep(_SQLITE_LOCK_RETRY_DELAY_SECONDS)
+        finally:
+            connection.execute(f"pragma busy_timeout={original_busy_timeout_ms}")
 
     @staticmethod
     def _ensure_policy_column(connection: sqlite3.Connection, column_name: str, column_type: str) -> None:
@@ -3161,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,
@@ -3226,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=(
@@ -4453,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,
         *,
@@ -5179,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,
@@ -6928,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.843 → 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.843"
+__version__ = "2.0.845"