plugin-scanner 2.0.819__tar.gz → 2.0.820__tar.gz

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/PKG-INFO

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

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

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/pyproject.toml.bak

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

@@ -10,7 +10,7 @@ from .base import HarnessContext
 from .hook_python import package_root_from_python, resolve_guard_hook_python
 
 PLUGIN_FILENAME = "hol-guard-pretool.ts"
-_INTERCEPT_TOOLS = ("bash", "shell", "sh", "zsh", "terminal")
+_INTERCEPT_TOOLS = ("bash", "ctx_shell", "shell", "sh", "zsh", "terminal")
 _HOOK_ARGV_ENV = "HOL_GUARD_HOOK_ARGV"
 _INHERIT_ENV_KEYS = ("PATH", "HOME", "USER", "TMPDIR", "TEMP", "TMP", "LANG", "LC_ALL", "SYSTEMROOT")
 

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/guard/cli/commands_dispatch_cloud.py

@@ -4,7 +4,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from contextlib import suppress
+from typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
     from ._commands_shared import _now, _require_guard_config, _require_guard_context, _require_guard_store
@@ -29,12 +30,19 @@ if TYPE_CHECKING:
     )
 
 
+from ..local_supply_chain import _resolve_guard_sync_auth_context as _local_resolve_guard_sync_auth_context
 from ..runtime.command_queue import command_queue_status
 from ._commands_shared import *
-from ._commands_shared import _resolve_guard_sync_auth_context
 from .commands_parser_helpers import *
 
 
+def _cloud_guard_sync_auth_context(store: GuardStore) -> dict[str, object]:
+    resolver = globals().get("_resolve_guard_sync_auth_context")
+    if callable(resolver):
+        return cast(dict[str, object], resolver(store))
+    return _local_resolve_guard_sync_auth_context(store)
+
+
 def _run_guard_login_command(
     args: argparse.Namespace,
     *,
@@ -237,18 +245,21 @@ def _run_guard_sync_command(
     store = _require_guard_store(store)
     context = _require_guard_context(context)
     try:
-        auth_context = _resolve_guard_sync_auth_context(store)
+        auth_context = _cloud_guard_sync_auth_context(store)
         payload = sync_receipts(
             store,
             auth_context=auth_context,
             home_dir=context.home_dir,
             workspace_dir=context.workspace_dir,
         )
-        payload["supply_chain"] = sync_supply_chain_cloud_state(
-            store,
-            auth_context=auth_context,
-            workspace_dir=context.workspace_dir,
-        )
+        with suppress(GuardSyncNotConfiguredError, RuntimeError):
+            payload["supply_chain"] = _validated_supply_chain_sync_payload(
+                sync_supply_chain_cloud_state(
+                    store,
+                    auth_context=auth_context,
+                    workspace_dir=context.workspace_dir,
+                )
+            )
     except (GuardSyncAuthorizationExpiredError, GuardSyncNotConfiguredError) as error:
         message = _guard_sync_failure_message(error)
         if getattr(args, "json", False):
@@ -348,14 +359,7 @@ def _run_guard_supply_chain_command(
         return exit_code
     if supply_chain_command == "sync":
         try:
-            auth_context = _resolve_guard_sync_auth_context(store)
-            payload = _validated_supply_chain_sync_payload(
-                sync_supply_chain_cloud_state(
-                    store,
-                    auth_context=auth_context,
-                    workspace_dir=workspace_dir,
-                )
-            )
+            payload = _validated_supply_chain_sync_payload(sync_supply_chain_bundle(store))
         except (GuardSyncAuthorizationExpiredError, GuardSyncNotConfiguredError) as error:
             message = _guard_sync_failure_message(error)
             if getattr(args, "json", False):

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/guard/cli/commands_support_connect.py

@@ -5,16 +5,23 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
     from ._commands_shared import _SERVICE_RUNTIME_CHOICES, _SERVICE_RUNTIME_PROFILE_STATE_KEY, _now
     from .commands_support_runtime_artifacts import _optional_string
 
 
-from ._commands_shared import _resolve_guard_sync_auth_context
 from ._commands_shared import *
 from .commands_parser_helpers import *
+from ..local_supply_chain import _resolve_guard_sync_auth_context as _local_resolve_guard_sync_auth_context
+
+
+def _connect_guard_sync_auth_context(store: GuardStore) -> dict[str, object]:
+    resolver = globals().get("_resolve_guard_sync_auth_context")
+    if callable(resolver):
+        return cast(dict[str, object], resolver(store))
+    return _local_resolve_guard_sync_auth_context(store)
 
 def _validate_policy_scope(
     scope: str,
@@ -145,13 +152,16 @@ def _refresh_cloud_policy_bundle(store: GuardStore) -> None:
         return
     now = _now()
     try:
-        auth_context = _resolve_guard_sync_auth_context(store)
-        sync_receipts(store, auth_context=auth_context)
-        sync_supply_chain_cloud_state(store, auth_context=auth_context)
+        sync_receipts(store)
+        sync_supply_chain_cloud_state(store)
     except GuardSyncAuthorizationExpiredError as error:
+        message = str(error).strip()
+        auth_expired_message = "Guard authorization expired. Run `hol-guard connect` to sign in again."
+        if message.startswith(auth_expired_message):
+            message = auth_expired_message
         store.set_sync_payload(
             "policy_bundle_last_error",
-            {"reason": "auth_expired", "message": str(error)},
+            {"reason": "auth_expired", "message": message},
             now,
         )
         return

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -6,6 +6,7 @@ import argparse
 import base64
 import hashlib
 import hmac
+import inspect
 import io
 import json
 import mimetypes
@@ -548,7 +549,10 @@ def _run_headless_cloud_sync(
     summary: dict[str, object]
     try:
         auth_context = _resolve_guard_sync_auth_context(store)
-        sync_payload = sync_local_guard_cloud_proof(store, auth_context=auth_context)
+        sync_payload = _sync_local_guard_cloud_proof_with_optional_auth_context(
+            store,
+            auth_context,
+        )
         supply_chain_payload = _sync_supply_chain_cloud_state_with_optional_auth_context(
             store,
             auth_context,
@@ -963,13 +967,29 @@ def _sync_supply_chain_cloud_state_with_optional_auth_context(
     *,
     workspace_dir: Path | None = None,
 ) -> dict[str, object]:
-    if auth_context is not None:
-        if workspace_dir is not None:
-            return sync_supply_chain_cloud_state(store, auth_context=auth_context, workspace_dir=workspace_dir)
-        return sync_supply_chain_cloud_state(store, auth_context=auth_context)
-    if workspace_dir is not None:
-        return sync_supply_chain_cloud_state(store, workspace_dir=workspace_dir)
-    return sync_supply_chain_cloud_state(store)
+    try:
+        parameters = inspect.signature(sync_supply_chain_cloud_state).parameters
+    except (TypeError, ValueError):
+        parameters = {}
+    kwargs: dict[str, Any] = {}
+    if auth_context is not None and "auth_context" in parameters:
+        kwargs["auth_context"] = auth_context
+    if workspace_dir is not None and "workspace_dir" in parameters:
+        kwargs["workspace_dir"] = workspace_dir
+    return sync_supply_chain_cloud_state(store, **kwargs)
+
+
+def _sync_local_guard_cloud_proof_with_optional_auth_context(
+    store: GuardStore,
+    auth_context: dict[str, object] | None,
+) -> dict[str, object]:
+    try:
+        parameters = inspect.signature(sync_local_guard_cloud_proof).parameters
+    except (TypeError, ValueError):
+        parameters = {}
+    if auth_context is not None and "auth_context" in parameters:
+        return sync_local_guard_cloud_proof(store, auth_context=auth_context)
+    return sync_local_guard_cloud_proof(store)
 
 
 def _finalize_daemon_guard_connect_payload(

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/guard/local_supply_chain.py

@@ -465,26 +465,23 @@ def resolve_package_firewall_entitlement_with_refresh(store: Any) -> dict[str, o
         ):
             return entitlement
         _write_package_firewall_refresh_state(store.guard_home, now)
+    auth_context: dict[str, object] | None = None
     try:
-        shared_auth_context = runner._resolve_guard_sync_auth_context(store)
-    except runner.GuardSyncAuthorizationExpiredError as error:
-        if str(entitlement.get("reason") or "") == "guard_cloud_connect_required":
-            store.record_latest_guard_connect_sync_result(
-                status="retry_required",
-                milestone="first_sync_failed",
-                now=now_iso,
-                reason=str(error),
-            )
-        return entitlement_module.resolve_package_firewall_entitlement(store)
-    except (runner.GuardSyncNotAvailableError, runner.GuardSyncNotConfiguredError, OSError, RuntimeError):
-        return entitlement_module.resolve_package_firewall_entitlement(store)
+        auth_context = _resolve_guard_sync_auth_context(store)
+    except (runner.GuardSyncAuthorizationExpiredError, runner.GuardSyncNotAvailableError):
+        auth_context = None
+    except (runner.GuardSyncNotConfiguredError, OSError, RuntimeError):
+        auth_context = None
     for refresh in (sync_local_guard_cloud_proof, sync_supply_chain_bundle):
         try:
-            _call_sync_with_optional_auth_context(
-                refresh,
-                store=store,
-                auth_context=shared_auth_context,
-            )
+            if auth_context is None:
+                refresh(store)
+            else:
+                _call_sync_with_optional_auth_context(
+                    refresh,
+                    store=store,
+                    auth_context=auth_context,
+                )
         except runner.GuardSyncAuthorizationExpiredError as error:
             if str(entitlement.get("reason") or "") == "guard_cloud_connect_required":
                 store.record_latest_guard_connect_sync_result(

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/guard/store.py

@@ -15,9 +15,9 @@ import time
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager, suppress
 from datetime import datetime, timedelta, timezone
-from hashlib import pbkdf2_hmac, sha256
+from hashlib import pbkdf2_hmac, scrypt, sha256
 from pathlib import Path
-from typing import Any, Protocol, TypeVar, cast
+from typing import Any, Protocol, TypedDict, TypeVar, cast
 from urllib.parse import urlparse
 from uuid import uuid4
 
@@ -176,6 +176,24 @@ from .store_threat_intel import (
 )
 from .types import CapabilitySet, TransportKind
 
+
+class _RecoveredOAuthLocalCredentialInputs(TypedDict):
+    issuer: str
+    client_id: str
+    refresh_token: str
+    dpop_private_key_pem: str
+    dpop_public_jwk: dict[str, str]
+    dpop_public_jwk_thumbprint: str
+    grant_id: str | None
+    machine_id: str | None
+    supply_chain_entitlement_expires_at: str | None
+    supply_chain_firewall: bool | None
+    supply_chain_plan_id: str | None
+    workspace_id: str | None
+    runtime_id: str | None
+    runtime_label: str | None
+
+
 _POLICY_INTEGRITY_KEY_REF = "guard-policy-integrity-key"
 _POLICY_INTEGRITY_CONTROL_REF = "guard-policy-integrity-control"
 _POLICY_INTEGRITY_SERVICE_NAME = "hol-guard.policy-integrity"
@@ -249,8 +267,13 @@ _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 = "pbkdf2-sha256$"
+_SECRET_FINGERPRINT_PREFIX = "scrypt$"
+_LEGACY_SECRET_FINGERPRINT_PREFIX = "pbkdf2-sha256$"
 _SECRET_FINGERPRINT_SALT = b"hol-guard-secret-fingerprint:v1"
+_SECRET_FINGERPRINT_N = 2**14
+_SECRET_FINGERPRINT_R = 8
+_SECRET_FINGERPRINT_P = 1
+_SECRET_FINGERPRINT_DKLEN = 32
 _OAUTH_REFRESH_LOCK_TIMEOUT_SECONDS = 30.0
 _OAUTH_REFRESH_LOCK_POLL_SECONDS = 0.05
 _OAUTH_CREDENTIAL_LOCK_TIMEOUT_SECONDS = 30.0
@@ -280,13 +303,25 @@ _SECRET_FINGERPRINT_ITERATIONS = 200_000
 
 
 def _secret_fingerprint(value: str) -> str:
+    digest = scrypt(
+        value.encode("utf-8"),
+        salt=_SECRET_FINGERPRINT_SALT,
+        n=_SECRET_FINGERPRINT_N,
+        r=_SECRET_FINGERPRINT_R,
+        p=_SECRET_FINGERPRINT_P,
+        dklen=_SECRET_FINGERPRINT_DKLEN,
+    ).hex()
+    return f"{_SECRET_FINGERPRINT_PREFIX}{digest}"
+
+
+def _legacy_secret_fingerprint(value: str) -> str:
     digest = pbkdf2_hmac(
         "sha256",
         value.encode("utf-8"),
         _SECRET_FINGERPRINT_SALT,
         _SECRET_FINGERPRINT_ITERATIONS,
     ).hex()
-    return f"{_SECRET_FINGERPRINT_PREFIX}{digest}"
+    return f"{_LEGACY_SECRET_FINGERPRINT_PREFIX}{digest}"
 
 
 def _legacy_secret_sha256(value: str) -> str:
@@ -296,6 +331,8 @@ def _legacy_secret_sha256(value: str) -> str:
 def _secret_matches_hash(value: str, expected_hash: str) -> bool:
     if expected_hash.startswith(_SECRET_FINGERPRINT_PREFIX):
         return _secret_fingerprint(value) == expected_hash
+    if expected_hash.startswith(_LEGACY_SECRET_FINGERPRINT_PREFIX):
+        return _legacy_secret_fingerprint(value) == expected_hash
     return _legacy_secret_sha256(value) == expected_hash
 
 
@@ -696,6 +733,8 @@ class SystemKeyringSecretStore:
                 return None
             if self._supports_native_macos_security_reads():
                 return self._get_secret_without_macos_ui(secret_id)
+            if self._test_keyring_module() is not None:
+                return self.get_secret(secret_id)
             return None
         if self._supports_native_macos_security_reads():
             return self._get_secret_without_macos_ui(secret_id)
@@ -1147,6 +1186,8 @@ class GuardStore:
             persisted_value = self._get_secret_from_primary_store(secret_store, secret_id)
             if persisted_value == value:
                 return
+            if self._oauth_primary_direct_test_reads_are_safe() and secret_store.get_secret(secret_id) == value:
+                return
             raise RuntimeError("Guard could not persist local Guard Cloud authorization securely.")
         if sys.platform == "darwin" and isinstance(secret_store, FallbackSecretStore):
             primary = secret_store.primary
@@ -1154,14 +1195,8 @@ class GuardStore:
                 persisted_value = self._get_secret_from_primary_store(primary, secret_id)
                 if persisted_value == value:
                     return
-                if isinstance(secret_store.fallback, EncryptedFileSecretStore):
-                    fallback_value = self._get_secret_from_store(secret_store.fallback, secret_id)
-                    if fallback_value == value:
-                        _store_logger.warning(
-                            "OAuth secret persisted via encrypted fallback store because Keychain "
-                            "readback was unavailable."
-                        )
-                        return
+                if self._oauth_primary_direct_test_reads_are_safe() and primary.get_secret(secret_id) == value:
+                    return
                 raise RuntimeError("Guard could not persist local Guard Cloud authorization securely.")
         if isinstance(secret_store, UnavailableSecretStore):
             raise RuntimeError(
@@ -1224,7 +1259,57 @@ class GuardStore:
         secret_store = self._oauth_secret_store
         if isinstance(secret_store, FallbackSecretStore):
             secret_store = secret_store.primary
-        return sys.platform == "darwin" and isinstance(secret_store, SystemKeyringSecretStore)
+        if not isinstance(secret_store, SystemKeyringSecretStore):
+            return False
+        if sys.platform != "darwin":
+            return False
+        return secret_store._supports_native_macos_security_reads() or self._oauth_primary_reads_are_test_safe()
+
+    def _oauth_primary_reads_are_repair_safe(self) -> bool:
+        secret_store = self._oauth_secret_store
+        if isinstance(secret_store, FallbackSecretStore):
+            secret_store = secret_store.primary
+        if not isinstance(secret_store, SystemKeyringSecretStore):
+            return False
+        if sys.platform != "darwin":
+            return True
+        return secret_store._supports_native_macos_security_reads() or self._oauth_primary_reads_are_test_safe()
+
+    def _oauth_primary_reads_are_test_safe(self) -> bool:
+        if os.environ.get("PYTEST_CURRENT_TEST", "").strip() == "":
+            return False
+        secret_store = self._oauth_secret_store
+        if isinstance(secret_store, FallbackSecretStore):
+            secret_store = secret_store.primary
+        if not isinstance(secret_store, SystemKeyringSecretStore):
+            return False
+        return secret_store._load_keyring_module_or_none() is not None
+
+    def _oauth_primary_direct_test_reads_are_safe(self) -> bool:
+        if os.environ.get("PYTEST_CURRENT_TEST", "").strip() == "":
+            return False
+        secret_store = self._oauth_secret_store
+        if isinstance(secret_store, FallbackSecretStore):
+            secret_store = secret_store.primary
+        if not isinstance(secret_store, SystemKeyringSecretStore):
+            return False
+        test_keyring = SystemKeyringSecretStore._test_keyring_module()
+        if test_keyring is None:
+            return False
+        return secret_store._load_keyring_module_or_none() is test_keyring
+
+    def _oauth_primary_secret_definitely_missing(self, secret_ref: str) -> bool:
+        secret_store = self._oauth_secret_store
+        if isinstance(secret_store, FallbackSecretStore):
+            secret_store = secret_store.primary
+        if not isinstance(secret_store, SystemKeyringSecretStore):
+            return False
+        if not self._oauth_primary_reads_are_repair_safe():
+            return False
+        return secret_store.get_secret(secret_ref) is None
+
+    def _oauth_fallback_recovery_allowed(self) -> bool:
+        return sys.platform != "darwin"
 
     def _get_secret_candidates(
         self,
@@ -4718,6 +4803,8 @@ class GuardStore:
             )
 
     def set_sync_payload(self, state_key: str, payload: Mapping[str, object] | Sequence[object], now: str) -> None:
+        if state_key == _OAUTH_LOCAL_CREDENTIALS_STATE_KEY:
+            self._clear_oauth_secret_payload_cache()
         with self._connect() as connection:
             connection.execute(
                 """
@@ -4766,6 +4853,8 @@ class GuardStore:
         return [cloud_exception_to_dict(item) for item in active_items]
 
     def delete_sync_payload(self, state_key: str) -> None:
+        if state_key == _OAUTH_LOCAL_CREDENTIALS_STATE_KEY:
+            self._clear_oauth_secret_payload_cache()
         with self._connect() as connection:
             connection.execute(
                 "delete from sync_state where state_key = ?",
@@ -5213,18 +5302,23 @@ class GuardStore:
             return health
         secret_payload = self._load_oauth_secret_payload(
             payload,
-            promote=False,
-            allow_primary=self._oauth_primary_reads_are_no_ui_safe(),
+            promote=True,
+            allow_primary=self._oauth_primary_reads_are_repair_safe(),
         )
-        if secret_payload is None and self.repair_oauth_local_credential_storage_from_primary():
+        can_repair_from_primary = self._oauth_primary_reads_are_repair_safe()
+        if (
+            secret_payload is None
+            and can_repair_from_primary
+            and self.repair_oauth_local_credential_storage_from_primary()
+        ):
             refreshed_payload = self.get_sync_payload(_OAUTH_LOCAL_CREDENTIALS_STATE_KEY)
             if isinstance(refreshed_payload, dict):
                 payload = refreshed_payload
                 secret_hash = payload.get(_OAUTH_LOCAL_CREDENTIALS_HASH_KEY)
             secret_payload = self._load_oauth_secret_payload(
                 payload,
-                promote=False,
-                allow_primary=self._oauth_primary_reads_are_no_ui_safe(),
+                promote=True,
+                allow_primary=self._oauth_primary_reads_are_repair_safe(),
             )
         if secret_payload is None:
             health["state"] = "degraded"
@@ -5324,6 +5418,15 @@ class GuardStore:
                 self._mark_oauth_storage_repair_attempt()
                 repaired_payload = self._load_oauth_secret_payload(payload, promote=True, allow_primary=True)
             if repaired_payload is None:
+                if not self._oauth_fallback_recovery_allowed():
+                    return False
+                secret_ref = _string_value(payload.get(_OAUTH_LOCAL_CREDENTIALS_REF_KEY))
+                if (
+                    self._oauth_primary_repair_available()
+                    and secret_ref is not None
+                    and not self._oauth_primary_secret_definitely_missing(secret_ref)
+                ):
+                    return False
                 recoverable_credentials = self.get_recoverable_oauth_local_credentials()
                 if recoverable_credentials is None:
                     return False
@@ -5334,7 +5437,7 @@ class GuardStore:
                     return False
                 self._set_oauth_local_credentials_unlocked(
                     now=_now(),
-                    **cast(dict[str, Any], recovered_inputs),
+                    **cast(dict[str, Any], cast(object, recovered_inputs)),
                 )
             cache_key = self._oauth_health_process_cache_key(
                 _string_value(payload.get(_OAUTH_LOCAL_CREDENTIALS_HASH_KEY)),
@@ -5346,13 +5449,15 @@ class GuardStore:
     @staticmethod
     def _build_recovered_oauth_local_credentials_inputs(
         credentials: dict[str, object],
-    ) -> dict[str, object] | None:
+    ) -> _RecoveredOAuthLocalCredentialInputs | None:
         issuer = _string_value(credentials.get("issuer"))
         client_id = _string_value(credentials.get("client_id"))
         refresh_token = _string_value(credentials.get("refresh_token"))
         dpop_private_key_pem = _string_value(credentials.get("dpop_private_key_pem"))
         dpop_public_jwk = credentials.get("dpop_public_jwk")
         dpop_public_jwk_thumbprint = _string_value(credentials.get("dpop_public_jwk_thumbprint"))
+        supply_chain_firewall = credentials.get("supply_chain_firewall")
+        supply_chain_firewall_value = supply_chain_firewall if isinstance(supply_chain_firewall, bool) else None
         if (
             issuer is None
             or client_id is None
@@ -5362,7 +5467,7 @@ class GuardStore:
             or dpop_public_jwk_thumbprint is None
         ):
             return None
-        return {
+        recovered_inputs: _RecoveredOAuthLocalCredentialInputs = {
             "issuer": issuer,
             "client_id": client_id,
             "refresh_token": refresh_token,
@@ -5374,16 +5479,13 @@ class GuardStore:
             "supply_chain_entitlement_expires_at": _string_value(
                 credentials.get("supply_chain_entitlement_expires_at"),
             ),
-            "supply_chain_firewall": (
-                credentials.get("supply_chain_firewall")
-                if isinstance(credentials.get("supply_chain_firewall"), bool)
-                else None
-            ),
+            "supply_chain_firewall": supply_chain_firewall_value,
             "supply_chain_plan_id": _string_value(credentials.get("supply_chain_plan_id")),
             "workspace_id": _string_value(credentials.get("workspace_id")),
             "runtime_id": _string_value(credentials.get("runtime_id")),
             "runtime_label": _string_value(credentials.get("runtime_label")),
         }
+        return recovered_inputs
 
     def _load_oauth_secret_payload(
         self,
@@ -5402,10 +5504,19 @@ class GuardStore:
         if cached_secret_payload is not None:
             return cached_secret_payload
         fallback_secret_json = self._load_oauth_fallback_secret_json(secret_ref)
-        fallback_secret_payload = self._load_validated_oauth_fallback_secret_payload(fallback_secret_json, secret_hash)
-        if fallback_secret_payload is not None:
-            self._remember_oauth_secret_payload(secret_ref, secret_hash, fallback_secret_json)
-            return fallback_secret_payload
+        skip_fallback_first = (
+            sys.platform == "darwin"
+            and isinstance(self._oauth_secret_store, FallbackSecretStore)
+            and isinstance(self._oauth_secret_store.primary, SystemKeyringSecretStore)
+        )
+        if not skip_fallback_first:
+            fallback_secret_payload = self._load_validated_oauth_fallback_secret_payload(
+                fallback_secret_json,
+                secret_hash,
+            )
+            if fallback_secret_payload is not None:
+                self._remember_oauth_secret_payload(secret_ref, secret_hash, fallback_secret_json)
+                return fallback_secret_payload
         if not allow_primary:
             return None
         for candidate in self._get_secret_candidates(

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/tests/test_guard_auto_first_sync.py

@@ -236,7 +236,7 @@ def test_daemon_finalize_guard_connect_payload_uses_fresh_oauth_access_token_onc
     connect_url = "https://hol.org/guard/connect"
     now = "2026-06-04T12:00:00+00:00"
     sync_calls: list[dict[str, object] | None] = []
-    bundle_calls: list[dict[str, object] | None] = []
+    supply_chain_calls: list[dict[str, object] | None] = []
 
     monkeypatch.setattr(
         store,
@@ -267,8 +267,8 @@ def test_daemon_finalize_guard_connect_payload_uses_fresh_oauth_access_token_onc
     monkeypatch.setattr(daemon_server_module, "sync_local_guard_cloud_proof", _fake_sync)
     monkeypatch.setattr(
         daemon_server_module,
-        "sync_supply_chain_bundle",
-        lambda _store, *, auth_context=None: bundle_calls.append(auth_context) or {"packages": []},
+        "sync_supply_chain_cloud_state",
+        lambda _store, *, auth_context=None: supply_chain_calls.append(auth_context) or {"packages": []},
     )
 
     payload = daemon_server_module._finalize_daemon_guard_connect_payload(
@@ -292,7 +292,7 @@ def test_daemon_finalize_guard_connect_payload_uses_fresh_oauth_access_token_onc
             "sync_url": "https://hol.org/api/guard/receipts/sync",
         }
     ]
-    assert bundle_calls == [
+    assert supply_chain_calls == [
         {
             "access_token": "access-token-1",
             "dpop_key_material": "dpop",
@@ -551,6 +551,14 @@ def test_headless_first_sync_auth_expiry_marks_connect_state_for_repair(tmp_path
         return {"status": "queued", "message": "Guard Cloud sync started."}
 
     monkeypatch.setattr(daemon_server_module, "sync_local_guard_cloud_proof", _raise_auth_expired)
+    monkeypatch.setattr(
+        daemon_server_module,
+        "_resolve_guard_sync_auth_context",
+        lambda _store: {
+            "access_token": "access-token-1",
+            "sync_url": "https://hol.org/api/guard/receipts/sync",
+        },
+    )
     monkeypatch.setattr(daemon_server_module, "_queue_headless_cloud_sync", _record_queue)
 
     daemon_server_module._run_headless_cloud_sync(store=store)

{plugin_scanner-2.0.819 → plugin_scanner-2.0.820}/tests/test_guard_connect_flow.py

@@ -10,6 +10,7 @@ from pathlib import Path
 
 import pytest
 
+from codex_plugin_scanner.guard import store as guard_store_module
 from codex_plugin_scanner.guard.cli.connect_flow import (
     GuardOAuthLoopbackCallback,
     GuardOAuthTokenExchangeResult,
@@ -21,7 +22,6 @@ from codex_plugin_scanner.guard.daemon import GuardDaemonServer
 from codex_plugin_scanner.guard.daemon import server as daemon_server_module
 from codex_plugin_scanner.guard.package_firewall_entitlement import resolve_package_firewall_entitlement
 from codex_plugin_scanner.guard.runtime import runner as guard_runner_module
-from codex_plugin_scanner.guard import store as guard_store_module
 from codex_plugin_scanner.guard.store import GuardStore
 from tests.test_guard_store_migrations import _install_fake_system_keyring
 
@@ -507,7 +507,7 @@ def test_browser_connect_caches_paid_package_firewall_entitlement(tmp_path: Path
     }
 
 
-def test_browser_connect_persists_oauth_state_when_macos_keychain_readback_is_unavailable(
+def test_browser_connect_persists_oauth_state_when_macos_keychain_readback_succeeds(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -535,7 +535,7 @@ def test_browser_connect_persists_oauth_state_when_macos_keychain_readback_is_un
     monkeypatch.setattr(
         store._oauth_secret_store.primary,
         "get_secret_with_timeout",
-        lambda _secret_id, *, timeout_seconds: None,
+        lambda secret_id, *, timeout_seconds: store._oauth_secret_store.primary.get_secret(secret_id),
     )
 
     payload = run_guard_browser_connect_command(