plugin-scanner 2.0.835__tar.gz → 2.0.837__tar.gz

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/PKG-INFO

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

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

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.835"
+version = "2.0.837"
 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.835 → plugin_scanner-2.0.837}/src/codex_plugin_scanner/guard/cli/commands_dispatch_trust.py

@@ -5,13 +5,16 @@ from __future__ import annotations
 import argparse
 import importlib.metadata
 import json
+import re
 import sys
+from datetime import datetime
 from pathlib import Path
 from typing import TextIO
 
+from ...version import __version__
 from ..adapters.base import HarnessContext
 from ..config import GuardConfig
-from ..daemon.manager import _guard_daemon_url_port, load_guard_daemon_url, read_approval_center_locator
+from ..daemon.manager import _guard_daemon_url_port, _load_state, load_guard_daemon_url, read_approval_center_locator
 from ..local_trust_contract import TrustStatus
 from ..local_trust_controller import macos_native_backend_supported, resolve_passive_trust_state
 from ..policy_integrity import is_remote_policy_source
@@ -19,6 +22,80 @@ from ..store import GuardStore
 from .commands_support_interaction import _emit
 from .update_commands import build_guard_install_surface_payload
 
+_TRUST_SECRET_ASSIGNMENT_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(
+        r"(?i)\b[a-z0-9_.-]*(?:token|secret|api[-_]?key|password|credential)[a-z0-9_.-]*\s*=\s*"
+        r"(?:'[^']*'|\"[^\"]*\"|[^\s]+)"
+    ),
+    re.compile(
+        r"(?i)\b[a-z0-9_.-]*(?:token|secret|api[-_]?key|password|credential)[a-z0-9_.-]*\s*:\s*"
+        r"(?:bearer\s+[^\s,;]+|[a-f0-9]{16,}|[a-z0-9._-]{24,})"
+    ),
+)
+
+
+def _parse_iso8601(value: str | None) -> datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    normalized = value.strip()
+    if normalized.endswith("Z"):
+        normalized = f"{normalized[:-1]}+00:00"
+    try:
+        return datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+
+
+def _approval_center_locator_is_fresh(
+    locator_pid: int,
+    locator_url: str,
+    locator_started_at: str,
+    state: dict[str, object] | None,
+) -> bool:
+    if not isinstance(state, dict):
+        return True
+    state_pid = state.get("pid")
+    state_port = state.get("port")
+    locator_port = _guard_daemon_url_port(locator_url)
+    if isinstance(state_pid, int) and state_pid != locator_pid:
+        return False
+    if isinstance(state_port, int) and isinstance(locator_port, int) and locator_port != state_port:
+        return False
+    raw_started_at = state.get("started_at")
+    state_started_at = _parse_iso8601(raw_started_at if isinstance(raw_started_at, str) else None)
+    locator_started_at_dt = _parse_iso8601(locator_started_at)
+    if state_started_at is None or locator_started_at_dt is None:
+        return True
+    try:
+        return locator_started_at_dt >= state_started_at
+    except TypeError:
+        return True
+
+
+def _sanitize_trust_text(value: str) -> str:
+    sanitized = value
+    for pattern in _TRUST_SECRET_ASSIGNMENT_PATTERNS:
+        sanitized = pattern.sub("credential redacted", sanitized)
+    return sanitized
+
+
+def _sanitize_trust_value(value: object) -> object:
+    if isinstance(value, dict):
+        return {key: _sanitize_trust_value(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_sanitize_trust_value(item) for item in value]
+    if isinstance(value, str):
+        return _sanitize_trust_text(value)
+    return value
+
+
+def _sanitize_trust_payload(payload: dict[str, object]) -> dict[str, object]:
+    return {key: _sanitize_trust_value(value) for key, value in payload.items()}
+
+
+def _emit_trust_payload(command: str, payload: dict[str, object], as_json: bool) -> None:
+    _emit(command, _sanitize_trust_payload(payload), as_json)
+
 
 def _now() -> str:
     from ._commands_shared import _now as _shared_now
@@ -143,8 +220,22 @@ def _installed_trust_cli_payload() -> dict[str, object]:
 
 
 def _approval_center_status_payload(guard_home: Path) -> dict[str, object]:
+    state = _load_state(guard_home)
+    daemon_package_version = state.get("package_version") if isinstance(state, dict) else None
+    restart_required = isinstance(daemon_package_version, str) and daemon_package_version != __version__
     locator = read_approval_center_locator(guard_home)
-    if locator is not None:
+    if locator is not None and _approval_center_locator_is_fresh(
+        locator.pid,
+        locator.daemon_url,
+        locator.started_at,
+        state,
+    ):
+        detail = None
+        if restart_required:
+            detail = (
+                f"Guard daemon is still serving hol-guard {daemon_package_version}. "
+                f"Restart it so browser approvals use hol-guard {__version__}."
+            )
         return {
             "active": True,
             "approval_url_base": locator.approval_url_base,
@@ -156,19 +247,35 @@ def _approval_center_status_payload(guard_home: Path) -> dict[str, object]:
             ),
             "started_at": locator.started_at,
             "pid": locator.pid,
+            "snapshot_fresh": True,
+            "restart_required": restart_required,
+            "daemon_package_version": daemon_package_version,
+            "detail": detail,
         }
     daemon_url = load_guard_daemon_url(guard_home)
     if isinstance(daemon_url, str) and daemon_url.strip():
+        detail = "Guard daemon is healthy, but the browser approval locator has not been refreshed yet."
+        if restart_required:
+            detail = (
+                f"Guard daemon is still serving hol-guard {daemon_package_version}. "
+                f"Restart it so browser approvals use hol-guard {__version__}."
+            )
         return {
             "active": True,
             "approval_url_base": daemon_url,
             "daemon_url": daemon_url,
             "port": _guard_daemon_url_port(daemon_url),
-            "detail": "Guard daemon is healthy, but the browser approval locator has not been refreshed yet.",
+            "detail": detail,
+            "snapshot_fresh": False,
+            "restart_required": restart_required,
+            "daemon_package_version": daemon_package_version,
         }
     return {
         "active": False,
         "detail": "No active Guard approval center daemon detected.",
+        "snapshot_fresh": False,
+        "restart_required": False,
+        "daemon_package_version": daemon_package_version,
     }
 
 
@@ -202,6 +309,7 @@ def build_trust_doctor_payload(store: GuardStore, *, backend: str = "auto") -> d
         "local_rules_protected": remembered_rules == "enforced",
         "cloud_policy_available": payload.get("cloud_policy_status") == "available",
         "approval_center_active": bool(approval_center.get("active")),
+        "approval_center_route_current": bool(approval_center.get("snapshot_fresh")),
         "official_install_verified": bool(install_info.get("official_install_verified")),
     }
     payload["recommended_actions"] = (
@@ -220,6 +328,14 @@ def build_trust_doctor_payload(store: GuardStore, *, backend: str = "auto") -> d
         payload["recommended_actions"].append(
             "Run `hol-guard dashboard` if browser approvals are unavailable and Guard needs a fresh local route."
         )
+    elif bool(approval_center.get("restart_required")):
+        payload["recommended_actions"].append(
+            "Run `hol-guard daemon repair` or restart the Guard daemon so browser approvals reconnect to this install."
+        )
+    elif not bool(approval_center.get("snapshot_fresh")):
+        payload["recommended_actions"].append(
+            "Run `hol-guard dashboard` once to refresh the local browser approval route for the active daemon."
+        )
     if bool(install_info.get("editable_install")):
         payload["recommended_actions"].append(
             "Use the official pipx install before relying on packaged update and daemon lifecycle checks."
@@ -330,22 +446,22 @@ def _run_guard_trust_command(
         else _trust_status_payload(store, command=trust_command, backend=backend)
     )
     if trust_command in {"status", "doctor"}:
-        _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
+        _emit_trust_payload(f"trust.{trust_command}", payload, getattr(args, "json", False))
         return 0
     if trust_command == "test":
         if not bool(getattr(args, "no_ui", False)):
             payload["error"] = "Use --no-ui so Guard can prove this probe will not open an OS credential prompt."
-            _emit("trust.test", payload, getattr(args, "json", False))
+            _emit_trust_payload("trust.test", payload, getattr(args, "json", False))
             return 2
         payload["probe"] = "passive_no_ui"
         payload["ok"] = payload["passive_prompt_allowed"] is False and payload.get("mode") != "unsupported"
         payload["trust_health"] = str(payload.get("mode") or "degraded_safe")
-        _emit("trust.test", payload, getattr(args, "json", False))
+        _emit_trust_payload("trust.test", payload, getattr(args, "json", False))
         return 0
     if trust_command == "explain":
         rule_id = getattr(args, "rule", None)
         if not isinstance(rule_id, int) or isinstance(rule_id, bool):
-            _emit(
+            _emit_trust_payload(
                 "trust.explain",
                 {
                     "generated_at": _now(),
@@ -356,7 +472,7 @@ def _run_guard_trust_command(
             )
             return 2
         payload = build_trust_explain_payload(store, rule_id=rule_id, backend=backend)
-        _emit("trust.explain", payload, getattr(args, "json", False))
+        _emit_trust_payload("trust.explain", payload, getattr(args, "json", False))
         return 0 if "error" not in payload else 2
     if trust_command in {"setup", "reset"}:
         if backend == "degraded-safe":
@@ -370,7 +486,7 @@ def _run_guard_trust_command(
                 if trust_command == "setup"
                 else "Nothing changed."
             )
-            _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
+            _emit_trust_payload(f"trust.{trust_command}", payload, getattr(args, "json", False))
             return 2
         if sys.platform != "darwin":
             payload["error"] = (
@@ -383,7 +499,7 @@ def _run_guard_trust_command(
                 if trust_command == "setup"
                 else "Nothing changed."
             )
-            _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
+            _emit_trust_payload(f"trust.{trust_command}", payload, getattr(args, "json", False))
             return 2
         if not macos_native_backend_supported(store):
             payload["error"] = (
@@ -391,7 +507,7 @@ def _run_guard_trust_command(
                 "Guard will not fall back to a prompt-capable backend."
             )
             payload["next_action"] = "Use one-time approvals or Guard Cloud policies until native setup is available."
-            _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
+            _emit_trust_payload(f"trust.{trust_command}", payload, getattr(args, "json", False))
             return 2
         result = (
             store.setup_policy_integrity(now=_now())
@@ -425,7 +541,7 @@ def _run_guard_trust_command(
             )
             if not payload["ok"]:
                 payload["next_action"] = "Keep using one-time approvals, then run trust doctor for the degraded reason."
-                _emit("trust.setup", payload, getattr(args, "json", False))
+                _emit_trust_payload("trust.setup", payload, getattr(args, "json", False))
                 return 2
         else:
             payload["message"] = (
@@ -435,9 +551,13 @@ def _run_guard_trust_command(
             payload["next_action"] = (
                 "Run `hol-guard guard trust setup --backend macos-native --json` to protect local rules again."
             )
-        _emit(f"trust.{trust_command}", payload, getattr(args, "json", False))
+        _emit_trust_payload(f"trust.{trust_command}", payload, getattr(args, "json", False))
         return 0
-    _emit("trust", {"error": "Use: hol-guard guard trust status|doctor|test|setup|reset"}, getattr(args, "json", False))
+    _emit_trust_payload(
+        "trust",
+        {"error": "Use: hol-guard guard trust status|doctor|test|setup|reset"},
+        getattr(args, "json", False),
+    )
     return 2
 
 

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/src/codex_plugin_scanner/guard/cli/render.py

@@ -215,6 +215,9 @@ _SENSITIVE_STRING_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
         r"\1*****",
     ),
 )
+_TRUST_SENSITIVE_STRING_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = tuple(
+    item for item in _SENSITIVE_STRING_PATTERNS if item[0].pattern != r"(?i)(api[-_ ]?key:\s*)[^\s,;]+"
+)
 
 
 def emit_guard_payload(command: str, payload: PayloadDict, as_json: bool) -> None:
@@ -226,7 +229,7 @@ def emit_guard_payload(command: str, payload: PayloadDict, as_json: bool) -> Non
         sys.stdout.write("\n")
         return
 
-    redacted_payload = _coerce_object_dict(_redact_payload(payload))
+    redacted_payload = _coerce_object_dict(_sanitize_payload_for_output(payload, command=command))
     if not _RICH_AVAILABLE:
         plain_renderer = _PLAIN_TEXT_RENDERERS.get(command)
         if plain_renderer is None:
@@ -242,9 +245,12 @@ def emit_guard_payload(command: str, payload: PayloadDict, as_json: bool) -> Non
     renderer(console, redacted_payload)
 
 
-def _redact_payload(value: object, *, key: str | None = None) -> object:
+def _redact_payload(value: object, *, key: str | None = None, command: str | None = None) -> object:
     if key in _NON_SECRET_STRUCTURED_KEYS and isinstance(value, dict):
-        return {item_key: _redact_payload(item_value, key=item_key) for item_key, item_value in value.items()}
+        return {
+            item_key: _redact_payload(item_value, key=item_key, command=command)
+            for item_key, item_value in value.items()
+        }
     if (
         key is not None
         and key not in _NON_SECRET_STRUCTURED_KEYS
@@ -254,12 +260,20 @@ def _redact_payload(value: object, *, key: str | None = None) -> object:
             return value
         return "*****"
     if isinstance(value, dict):
-        return {item_key: _redact_payload(item_value, key=item_key) for item_key, item_value in value.items()}
+        return {
+            item_key: _redact_payload(item_value, key=item_key, command=command)
+            for item_key, item_value in value.items()
+        }
     if isinstance(value, list):
-        return [_redact_payload(item) for item in value]
+        return [_redact_payload(item, command=command) for item in value]
     if isinstance(value, str):
         redacted = value
-        for pattern, replacement in _SENSITIVE_STRING_PATTERNS:
+        patterns = (
+            _TRUST_SENSITIVE_STRING_PATTERNS
+            if isinstance(command, str) and command.startswith("trust.")
+            else _SENSITIVE_STRING_PATTERNS
+        )
+        for pattern, replacement in patterns:
             redacted = pattern.sub(replacement, redacted)
         return redact_local_path(redacted)
     return value
@@ -273,7 +287,7 @@ def _render_redacted_json_payload(redacted_payload: object) -> str:
 
 def _safe_json_output_text(command: str, payload: PayloadDict) -> str:
     json_payload = _json_payload_for_command(command, payload)
-    sanitized_payload = _sanitize_payload_for_output(json_payload)
+    sanitized_payload = _coerce_object_dict(_sanitize_payload_for_output(json_payload, command=command))
     return _render_redacted_json_payload(sanitized_payload)
 
 
@@ -330,8 +344,8 @@ def _plain_text_protect(payload: PayloadDict) -> str:
     return "\n".join(lines)
 
 
-def _sanitize_payload_for_output(value: object) -> object:
-    return _redact_payload(value)
+def _sanitize_payload_for_output(value: object, *, command: str | None = None) -> object:
+    return _redact_payload(value, command=command)
 
 
 def _json_payload_for_command(command: str, payload: PayloadDict) -> PayloadDict:

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/src/codex_plugin_scanner/guard/proxy/runtime_mcp.py

@@ -802,7 +802,7 @@ class RuntimeMcpGuardProxy:
                 now=_now(),
             )
         request_id = str(queued[0]["request_id"]) if queued else "stored-block"
-        review_url = first_approval_url(queued) or approval_center_url
+        review_url = first_approval_url(queued, approval_center_url=approval_center_url) or approval_center_url
         self._maybe_open_approval_center(
             approval_center_url=approval_center_url,
             review_url=review_url,
@@ -1169,7 +1169,7 @@ class RuntimeMcpGuardProxy:
             risk_categories=tool_call_risk_categories(artifact, params.get("arguments")),
         )
         request_id = str(queued[0]["request_id"]) if queued else "unknown"
-        review_url = first_approval_url(queued) or approval_center_url
+        review_url = first_approval_url(queued, approval_center_url=approval_center_url) or approval_center_url
         self._maybe_open_approval_center(
             approval_center_url=approval_center_url,
             review_url=review_url,

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/src/codex_plugin_scanner/guard/proxy/stdio.py

@@ -466,7 +466,13 @@ class StdioGuardProxy:
                         )
                         event["approval_center_url"] = self.approval_center_url
                         event["approval_delivery"] = approval_delivery_payload(approval_flow)
-                        review_url = first_approval_url(event["approval_requests"]) or self.approval_center_url
+                        review_url = (
+                            first_approval_url(
+                                event["approval_requests"],
+                                approval_center_url=self.approval_center_url,
+                            )
+                            or self.approval_center_url
+                        )
                         request_id = next(
                             (
                                 str(item["request_id"])

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.835 → plugin_scanner-2.0.837}/tests/test_guard_opencode_proxy.py

@@ -141,6 +141,56 @@ def test_runtime_guard_proxy_queue_block_includes_request_url(tmp_path, monkeypa
     assert opened_urls == []
 
 
+def test_runtime_guard_proxy_rewrites_stale_request_url_to_active_approval_center(tmp_path, monkeypatch):
+    context = _context(tmp_path)
+    store = GuardStore(context.guard_home)
+    config = GuardConfig(guard_home=context.guard_home, workspace=context.workspace_dir)
+    marker_path = tmp_path / "dangerous-call.json"
+    monkeypatch.setattr(runtime_mcp_module, "ensure_guard_daemon", lambda _guard_home: "http://127.0.0.1:4455")
+    monkeypatch.setattr(runtime_mcp_module, "load_guard_daemon_auth_token", lambda _guard_home: "secret-token")
+    monkeypatch.setattr(runtime_mcp_module.webbrowser, "open", lambda _url: True)
+    monkeypatch.setattr(
+        runtime_mcp_module,
+        "queue_blocked_approvals",
+        lambda **_kwargs: [
+            {
+                "request_id": "stale-port-request",
+                "approval_url": "http://127.0.0.1:4833/requests/stale-port-request",
+            }
+        ],
+    )
+    proxy = RuntimeMcpGuardProxy(
+        harness="hermes",
+        server_name="danger_lab",
+        command=_child_command(marker_path),
+        context=context,
+        store=store,
+        config=config,
+        source_scope="project",
+        config_path=str(context.workspace_dir / "hermes.json"),
+        transport="local",
+    )
+
+    result = proxy.run_session(
+        [
+            {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"capabilities": {}}},
+            {
+                "jsonrpc": "2.0",
+                "id": 2,
+                "method": "tools/call",
+                "params": {"name": "dangerous_delete", "arguments": {"target": ".env.guard-proof"}},
+            },
+        ]
+    )
+
+    error = result["responses"][1]["error"]
+
+    assert error["data"]["approvalCenterUrl"] == "http://127.0.0.1:4455"
+    assert error["data"]["approvalRequests"][0]["approval_url"] == "http://127.0.0.1:4833/requests/stale-port-request"
+    assert error["data"]["reviewUrl"] == "http://127.0.0.1:4455/requests/stale-port-request"
+    assert error["data"]["reviewUrl"] in error["message"]
+
+
 def test_runtime_guard_proxy_respects_native_only_approval_surface_policy(tmp_path, monkeypatch):
     context = _context(tmp_path)
     store = GuardStore(context.guard_home)