plugin-scanner 2.0.616__tar.gz → 2.0.618__tar.gz

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/PKG-INFO

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

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

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/pyproject.toml.bak

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

@@ -270,8 +270,7 @@ def apply_approval_resolution(
     request_artifact_id = _string_or_none(request.get("artifact_id"))
     request_artifact_hash = _string_or_none(request.get("artifact_hash"))
     request_publisher = _string_or_none(request.get("publisher"))
-    harness_artifact_id = request_artifact_id if scope == "harness" else None
-    scoped_artifact_id = request_artifact_id if scope == "artifact" else workspace_artifact_id or harness_artifact_id
+    scoped_artifact_id = request_artifact_id if scope in {"artifact", "harness", "global"} else workspace_artifact_id
     decision = PolicyDecision(
         harness="*" if scope == "global" else str(request["harness"]),
         scope=scope,

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/guard/cli/commands_dispatch_admin.py

@@ -262,6 +262,38 @@ def _run_guard_doctor_command(
         }
     if getattr(args, "perf", False):
         payload["detector_perf"] = _runtime_detector_perf_payload(config)
+    package_shims_payload = package_shim_status(context)
+    package_shim_issues = [
+        {
+            "kind": "package_shim_integrity",
+            "manager": str(detail.get("manager")),
+            "integrity": str(detail.get("integrity")),
+            "repair": "Run `hol-guard doctor --repair` to regenerate package-manager shims.",
+        }
+        for detail in package_shims_payload.get("manager_details", [])
+        if isinstance(detail, dict) and detail.get("integrity") in {"missing", "stale", "tampered"}
+    ]
+    if not bool(package_shims_payload.get("path_active")) and package_shims_payload.get("installed_managers"):
+        package_shim_issues.append(
+            {
+                "kind": "package_shim_path",
+                "repair": "Run `hol-guard doctor --repair`, then open a new shell if PATH changed.",
+            }
+        )
+    if getattr(args, "repair", False):
+        installed_managers = tuple(
+            str(manager)
+            for manager in package_shims_payload.get("installed_managers", [])
+            if isinstance(manager, str) and manager.strip()
+        )
+        if installed_managers:
+            repair_payload = activate_package_shims(context, managers=installed_managers, repair=True)
+            package_shims_payload["repair"] = repair_payload
+            package_shims_payload["after_repair"] = repair_payload["package_shims"]
+        else:
+            package_shims_payload["repair"] = {"nothing_to_repair": True, "repaired": [], "repaired_count": 0}
+    package_shims_payload["issues"] = package_shim_issues
+    payload["package_shims"] = package_shims_payload
     payload["supply_chain"] = build_local_supply_chain_posture(store, config, now=_now())
     payload["aibom"] = build_aibom_status_payload(store, context, generated_at=_now())
     _emit("doctor", payload, getattr(args, "json", False))

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/guard/cli/commands_parser_policy.py

@@ -229,6 +229,12 @@ def _configure_guard_policy_parsers(
         help="List all supported harnesses with their protection contract",
     )
     doctor_parser.add_argument("--perf", action="store_true", help="Include detector performance timings")
+    doctor_parser.add_argument(
+        "--repair",
+        "--fix",
+        action="store_true",
+        help="Repair common local Guard issues such as stale package-manager shims",
+    )
     doctor_parser.add_argument(
         "--notifications",
         action="store_true",

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/guard/cli/commands_support_runtime_policy.py

@@ -211,13 +211,16 @@ def _runtime_stored_policy_action(
         and scope in {"workspace", "publisher", "harness", "global"}
         and _runtime_artifact_risk_classes(artifact)
     ):
+        decision_artifact_id = _optional_string(decision.get("artifact_id"))
         if scope == "workspace":
-            decision_artifact_id = _optional_string(decision.get("artifact_id"))
             decision_artifact_hash = _optional_string(decision.get("artifact_hash"))
             if decision_artifact_id == artifact_id and (
                 decision_artifact_hash is None or decision_artifact_hash == artifact_hash
             ):
                 return action
+            return None
+        if scope in {"harness", "global"}:
+            return action if decision_artifact_id is not None else None
         return None
     return action
 

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/guard/shims.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import ast
 import hashlib
 import json
 import os
@@ -200,6 +201,60 @@ def build_shim_content_hash(content: bytes) -> str:
     return hashlib.sha256(content).hexdigest()
 
 
+def _normalized_package_shim_content(content: bytes) -> str:
+    """Return generated-shim content with install-specific paths masked."""
+    try:
+        text = content.decode("utf-8")
+    except UnicodeDecodeError:
+        return ""
+    normalized_lines: list[str] = []
+    for line in text.splitlines():
+        if line.startswith("#!"):
+            normalized_lines.append("#!<python>")
+            continue
+        if line.startswith("base_command = "):
+            normalized_lines.append(f"base_command = {_normalized_base_command_repr(line)}")
+            continue
+        if line.startswith("guard_cwd = "):
+            normalized_lines.append("guard_cwd = '<path>'")
+            continue
+        if line.startswith("guard_has_explicit_workspace = "):
+            normalized_lines.append("guard_has_explicit_workspace = <workspace-mode>")
+            continue
+        if line.startswith("shim_dir = "):
+            normalized_lines.append("shim_dir = '<path>'")
+            continue
+        normalized_lines.append(line)
+    return "\n".join(normalized_lines)
+
+
+def _normalized_base_command_repr(line: str) -> str:
+    raw_value = line.split("=", 1)[1].strip()
+    try:
+        value = ast.literal_eval(raw_value)
+    except (SyntaxError, ValueError):
+        return raw_value
+    if not isinstance(value, list):
+        return raw_value
+    normalized: list[object] = []
+    skip_path_after: str | None = None
+    for index, item in enumerate(value):
+        if index == 0 and isinstance(item, str):
+            normalized.append("<python>")
+            continue
+        if isinstance(item, str) and index + 1 < len(value) and value[index + 1] == "codex_plugin_scanner.cli":
+            normalized.append("<import-root>")
+            continue
+        if skip_path_after is not None:
+            normalized.append(f"<{skip_path_after}>")
+            skip_path_after = None
+            continue
+        normalized.append(item)
+        if item in {"--guard-home", "--home", "--workspace"}:
+            skip_path_after = str(item).lstrip("-")
+    return repr(normalized)
+
+
 def get_real_binary_info(
     binary_path: str,
     *,
@@ -428,12 +483,19 @@ def package_shim_status(context: HarnessContext) -> dict[str, object]:
         path_status = get_path_order_status(context, manager=manager)
         if exists:
             active_managers.append(manager)
-            current_hash = build_shim_content_hash(shim_path.read_bytes())
+            current_content = shim_path.read_bytes()
+            current_hash = build_shim_content_hash(current_content)
             stored_hash = stored_hashes.get(manager)
-            if stored_hash is None:
-                integrity = "unknown"
-            elif current_hash == stored_hash:
+            expected_content = _build_package_manager_python_shim(context, command).encode("utf-8")
+            expected_hash = build_shim_content_hash(expected_content)
+            if current_hash == expected_hash or _normalized_package_shim_content(
+                current_content
+            ) == _normalized_package_shim_content(expected_content):
                 integrity = "ok"
+            elif stored_hash == current_hash:
+                integrity = "stale"
+            elif stored_hash is None:
+                integrity = "unknown"
             else:
                 integrity = "tampered"
         else:
@@ -589,7 +651,7 @@ def repair_package_shims(
             continue
         if selected_managers is not None and manager not in selected_managers:
             continue
-        if detail.get("integrity") in ("missing", "tampered"):
+        if detail.get("integrity") in ("missing", "stale", "tampered"):
             managers_to_repair.append(manager)
         elif not bool(detail.get("path_active")):
             path_repair_required.append(manager)

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/guard/store.py

@@ -2085,12 +2085,21 @@ class GuardStore:
                       artifact_id is null or artifact_id = ?
                     )
                   )
-                  or scope = 'global'
+                    or (
+                      scope = 'global' and (
+                        artifact_id is null
+                        or artifact_id = ?
+                        or artifact_id = ?
+                      )
+                    )
                 )
                 and (expires_at is null or expires_at > ?)
                 order by case scope when 'artifact' then 0 when 'workspace' then 1 when 'publisher' then 2
-                          when 'harness' then 3 else 4 end,
-                         case when scope = 'workspace' and artifact_id is not null then 0 else 1 end,
+                         when 'harness' then 3 else 4 end,
+                         case
+                           when scope in ('workspace', 'harness', 'global') and artifact_id is not null then 0
+                           else 1
+                         end,
                          updated_at desc
                 """,
                 (
@@ -2105,6 +2114,8 @@ class GuardStore:
                     artifact_hash,
                     publisher,
                     action_family_key,
+                    artifact_id,
+                    action_family_key,
                     current_time,
                 ),
             ).fetchall()
@@ -2124,7 +2135,7 @@ class GuardStore:
 
     @staticmethod
     def _normalized_policy_keys(decision: PolicyDecision) -> tuple[str | None, str | None, str | None, str | None]:
-        if decision.scope == "harness":
+        if decision.scope in {"harness", "global"}:
             artifact_id = _artifact_family_key(decision.artifact_id)
         else:
             artifact_id = decision.artifact_id if decision.scope in {"artifact", "workspace"} else None

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/tests/test_guard_package_shims.py

@@ -21,12 +21,12 @@ from codex_plugin_scanner.cli import main
 from codex_plugin_scanner.guard import shims as guard_shims_module
 from codex_plugin_scanner.guard.adapters.base import HarnessContext
 from codex_plugin_scanner.guard.approvals import apply_approval_resolution
-from codex_plugin_scanner.guard.models import PolicyDecision
 from codex_plugin_scanner.guard.cli import commands as guard_commands_module
+from codex_plugin_scanner.guard.models import PolicyDecision
 from codex_plugin_scanner.guard.protect import build_protect_payload
 from codex_plugin_scanner.guard.runtime import supply_chain_package_eval as supply_chain_package_eval_module
 from codex_plugin_scanner.guard.shim_probe import SHIM_PROBE_ENV_VALUE, SHIM_PROBE_ENV_VAR
-from codex_plugin_scanner.guard.shims import install_package_shims, package_shim_status
+from codex_plugin_scanner.guard.shims import build_shim_content_hash, install_package_shims, package_shim_status
 from codex_plugin_scanner.guard.store import GuardStore
 from tests.shim_execution_helpers import write_fake_manager_script
 from tests.test_guard_protect import _seed_bundle_cache_only, _SyncAndEvaluateHandler
@@ -593,6 +593,91 @@ def test_guard_package_shims_repair_command_restores_selected_manager(tmp_path:
     assert not (shim_dir / "pip").exists()
 
 
+def test_guard_package_shims_repair_command_regenerates_stale_manager(tmp_path: Path, capsys) -> None:
+    home_dir = tmp_path / "guard-home"
+    workspace_dir = tmp_path / "workspace"
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+    _seed_paid_bundle_entitlement(home_dir)
+
+    install_rc = main(
+        [
+            "guard",
+            "package-shims",
+            "install",
+            "--home",
+            str(home_dir),
+            "--workspace",
+            str(workspace_dir),
+            "--manager",
+            "npm",
+            "--json",
+        ]
+    )
+    install_payload = json.loads(capsys.readouterr().out)
+    assert install_rc == 0
+    shim_path = Path(str(install_payload["shim_dir"])) / "npm"
+    manifest_path = Path(str(install_payload["manifest_path"]))
+    current_content = shim_path.read_text(encoding="utf-8")
+    stale_content = '#!/bin/sh\nexec npm "$@"\n'
+    shim_path.write_text(stale_content, encoding="utf-8")
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["content_hashes"]["npm"] = build_shim_content_hash(stale_content.encode("utf-8"))
+    manifest_path.write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+
+    status_rc = main(
+        [
+            "guard",
+            "package-shims",
+            "status",
+            "--home",
+            str(home_dir),
+            "--workspace",
+            str(workspace_dir),
+            "--json",
+        ]
+    )
+    status_payload = json.loads(capsys.readouterr().out)
+    repair_rc = main(
+        [
+            "guard",
+            "package-shims",
+            "repair",
+            "--home",
+            str(home_dir),
+            "--workspace",
+            str(workspace_dir),
+            "--manager",
+            "npm",
+            "--json",
+        ]
+    )
+    repair_payload = json.loads(capsys.readouterr().out)
+
+    assert status_rc == 0
+    assert status_payload["manager_details"][0]["integrity"] == "stale"
+    assert repair_rc == 0
+    assert repair_payload["repaired"] == ["npm"]
+    assert shim_path.read_text(encoding="utf-8") == current_content
+
+
+def test_guard_package_shims_status_ignores_dynamic_generated_paths(tmp_path: Path) -> None:
+    home_dir = tmp_path / "guard-home"
+    install_workspace = tmp_path / "workspace-a"
+    status_workspace = tmp_path / "workspace-b"
+    install_workspace.mkdir(parents=True, exist_ok=True)
+    status_workspace.mkdir(parents=True, exist_ok=True)
+    install_package_shims(
+        HarnessContext(home_dir=home_dir, workspace_dir=install_workspace, guard_home=home_dir),
+        managers=("npm",),
+    )
+
+    status = package_shim_status(
+        HarnessContext(home_dir=home_dir, workspace_dir=status_workspace, guard_home=home_dir),
+    )
+
+    assert status["manager_details"][0]["integrity"] == "ok"
+
+
 def test_guard_package_shims_install_does_not_mutate_path_environment(
     tmp_path: Path,
     capsys,

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/tests/test_guard_package_shims_cli.py

@@ -11,7 +11,7 @@ from codex_plugin_scanner.cli import main
 from codex_plugin_scanner.guard import local_supply_chain as local_supply_chain_module
 from codex_plugin_scanner.guard.adapters.base import HarnessContext
 from codex_plugin_scanner.guard.approval_gate import update_settings as update_approval_gate_settings
-from codex_plugin_scanner.guard.shims import install_package_shims
+from codex_plugin_scanner.guard.shims import build_shim_content_hash, install_package_shims
 from codex_plugin_scanner.guard.store import GuardStore
 
 
@@ -409,6 +409,58 @@ def test_package_shims_repair_runs_without_guard_cloud_connect(
     assert str(guard_home / "package-shims" / "bin") in profile_path.read_text(encoding="utf-8")
 
 
+def test_guard_doctor_repair_regenerates_stale_package_shim(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    home_dir = tmp_path / "home"
+    home_dir.mkdir()
+    monkeypatch.setenv("HOME", str(home_dir))
+    monkeypatch.setenv("SHELL", "/bin/zsh")
+    guard_home = tmp_path / "guard-home"
+    _install_local_package_shim(guard_home, home_dir, "npm")
+    shim_path = guard_home / "package-shims" / "bin" / "npm"
+    current_content = shim_path.read_text(encoding="utf-8")
+    stale_content = '#!/bin/sh\nexec npm "$@"\n'
+    shim_path.write_text(stale_content, encoding="utf-8")
+    manifest_path = guard_home / "package-shims" / "manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["content_hashes"]["npm"] = build_shim_content_hash(stale_content.encode("utf-8"))
+    manifest_path.write_text(json.dumps(manifest, sort_keys=True), encoding="utf-8")
+
+    rc = main(
+        [
+            "guard",
+            "doctor",
+            "--repair",
+            "--home",
+            str(home_dir),
+            "--guard-home",
+            str(guard_home),
+            "--json",
+        ]
+    )
+
+    payload = json.loads(capsys.readouterr().out)
+    assert rc == 0
+    assert payload["package_shims"]["issues"] == [
+        {
+            "kind": "package_shim_integrity",
+            "manager": "npm",
+            "integrity": "stale",
+            "repair": "Run `hol-guard doctor --repair` to regenerate package-manager shims.",
+        },
+        {
+            "kind": "package_shim_path",
+            "repair": "Run `hol-guard doctor --repair`, then open a new shell if PATH changed.",
+        },
+    ]
+    assert payload["package_shims"]["repair"]["repaired"] == ["npm"]
+    assert payload["package_shims"]["after_repair"]["manager_details"][0]["integrity"] == "ok"
+    assert shim_path.read_text(encoding="utf-8") == current_content
+
+
 def test_package_shims_uninstall_runs_without_guard_cloud_connect(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,

{plugin_scanner-2.0.616 → plugin_scanner-2.0.618}/tests/test_guard_runtime.py

@@ -14157,6 +14157,93 @@ def test_guard_runtime_tool_action_policy_uses_network_egress_when_stricter(tmp_
     assert guard_commands_module._runtime_artifact_policy_action(config, artifact, "codex") == "block"
 
 
+@pytest.mark.parametrize(
+    "scope",
+    [
+        "harness",
+        "global",
+    ],
+)
+def test_guard_runtime_honors_broader_saved_allows_for_risky_tool_actions(
+    tmp_path: Path,
+    scope: str,
+) -> None:
+    store = GuardStore(tmp_path / "guard-home")
+    workspace = tmp_path / "workspace"
+    request = GuardApprovalRequest(
+        request_id=f"req-opencode-{scope}",
+        harness="opencode",
+        artifact_id="opencode:project:tool-action:docker-compose-postgres",
+        artifact_name="Bash docker-sensitive command",
+        artifact_type="tool_action_request",
+        artifact_hash="hash-request",
+        publisher=None,
+        policy_action="require-reapproval",
+        recommended_scope="artifact",
+        changed_fields=("tool_action_request",),
+        source_scope="project",
+        config_path=str(workspace / "opencode.json"),
+        workspace=str(workspace),
+        launch_target="docker compose -f scripts/guard-cloud/docker-lab/docker-compose.yml up -d postgres",
+        review_command=f"hol-guard approvals approve req-opencode-{scope}",
+        approval_url=f"http://127.0.0.1:5474/requests/req-opencode-{scope}",
+        action_envelope_json={
+            "schema_version": 1,
+            "action_id": f"req-opencode-{scope}",
+            "harness": "opencode",
+            "event_name": "PreToolUse",
+            "action_type": "shell_command",
+            "workspace": str(workspace),
+            "workspace_hash": "workspace-hash",
+            "tool_name": "Bash",
+            "command": "docker compose -f scripts/guard-cloud/docker-lab/docker-compose.yml up -d postgres",
+            "prompt_excerpt": None,
+            "target_paths": [],
+            "network_hosts": [],
+            "mcp_server": None,
+            "mcp_tool": None,
+            "package_manager": None,
+            "package_name": None,
+            "script_name": None,
+            "raw_payload_redacted": {"tool_name": "Bash"},
+        },
+    )
+    store.add_approval_request(request, "2026-06-12T00:00:00+00:00")
+
+    apply_approval_resolution(
+        store=store,
+        request_id=request.request_id,
+        action="allow",
+        scope=scope,
+        workspace=request.workspace,
+        reason=f"saved for {scope}",
+        now="2026-06-12T00:01:00+00:00",
+    )
+
+    runtime_artifact = GuardArtifact(
+        artifact_id=request.artifact_id,
+        name=request.artifact_name,
+        harness="opencode",
+        artifact_type="tool_action_request",
+        source_scope="project",
+        config_path=request.config_path,
+        publisher=None,
+        metadata={"action_class": "docker-sensitive command"},
+    )
+
+    assert (
+        guard_commands_module._runtime_stored_policy_action(
+            store=store,
+            harness="opencode",
+            artifact=runtime_artifact,
+            artifact_id=runtime_artifact.artifact_id,
+            artifact_hash="hash-retry",
+            workspace=str(workspace),
+        )
+        == "allow"
+    )
+
+
 def test_guard_runtime_tool_action_policy_prefers_configured_risk_action_over_default(tmp_path):
     artifact = GuardArtifact(
         artifact_id="codex:test:tool-action:upload",
@@ -17070,10 +17157,13 @@ def test_policy_bundle_version_persists_after_store_reopen(tmp_path):
 
 
 def test_policy_bundle_downgrade_check_ignores_mixed_timezone_formats():
-    assert guard_runner_module._policy_bundle_is_version_downgrade(
-        {"issuedAt": "2026-06-05T13:30:00+00:00"},
-        {"issuedAt": "2026-06-05T13:29:00"},
-    ) is False
+    assert (
+        guard_runner_module._policy_bundle_is_version_downgrade(
+            {"issuedAt": "2026-06-05T13:30:00+00:00"},
+            {"issuedAt": "2026-06-05T13:29:00"},
+        )
+        is False
+    )
 
 
 def test_sync_receipts_uploads_policy_bundle_acknowledgement(tmp_path, monkeypatch):