plugin-scanner 2.0.552__tar.gz → 2.0.554__tar.gz

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/PKG-INFO

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

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

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/pyproject.toml.bak

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

@@ -235,6 +235,12 @@ def _git_run(
         return None
 
 
+def _is_safe_committed_tree_path(path: str) -> bool:
+    if path == "" or path.startswith(("/", "\\")) or "\\" in path or "\0" in path:
+        return False
+    return all(part not in {"", ".", ".."} for part in path.split("/"))
+
+
 def _list_committed_static_files(checkout: Path, static_prefix: str) -> list[str]:
     result = _git_run(checkout, "ls-tree", "-r", "--name-only", "HEAD", "--", static_prefix)
     if result is None or result.returncode != 0:
@@ -243,13 +249,20 @@ def _list_committed_static_files(checkout: Path, static_prefix: str) -> list[str
     prefix = f"{static_prefix.rstrip('/')}/"
     for line in result.stdout.splitlines():
         relative = line.strip()
-        if relative == "" or relative.endswith("/") or not relative.startswith(prefix):
+        if (
+            relative == ""
+            or relative.endswith("/")
+            or not relative.startswith(prefix)
+            or not _is_safe_committed_tree_path(relative)
+        ):
             continue
         files.append(relative)
     return files
 
 
 def _read_committed_file(checkout: Path, relative_path: str) -> bytes | None:
+    if not _is_safe_committed_tree_path(relative_path):
+        return None
     result = _git_run(checkout, "show", f"HEAD:{relative_path}", text=False)
     if result is None or result.returncode != 0:
         return None
@@ -263,7 +276,20 @@ def _relative_static_path(relative_path: str, static_prefix: str) -> Path | None
     normalized_prefix = static_prefix.rstrip("/")
     if not relative_path.startswith(f"{normalized_prefix}/"):
         return None
-    return Path(relative_path.removeprefix(f"{normalized_prefix}/"))
+    suffix = relative_path.removeprefix(f"{normalized_prefix}/")
+    if not _is_safe_committed_tree_path(suffix):
+        return None
+    return Path(suffix)
+
+
+def _resolve_static_export_path(installed_static: Path, relative_to_static: Path) -> Path | None:
+    base = installed_static.resolve()
+    destination = (base / relative_to_static).resolve()
+    try:
+        destination.relative_to(base)
+    except ValueError:
+        return None
+    return destination
 
 
 def _export_committed_static_files(
@@ -280,7 +306,9 @@ def _export_committed_static_files(
         relative_to_static = _relative_static_path(relative_path, static_prefix)
         if relative_to_static is None:
             continue
-        dest = installed_static / relative_to_static
+        dest = _resolve_static_export_path(installed_static, relative_to_static)
+        if dest is None:
+            continue
         dest.parent.mkdir(parents=True, exist_ok=True)
         dest.write_bytes(payload)
         copied_count += 1

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -103,6 +103,7 @@ from ..package_firewall_entitlement import (
     package_firewall_block_details,
     package_firewall_operation_allowed,
 )
+from ..package_shim_status import record_package_shim_audit_result
 from ..receipts.manager import build_receipt
 from ..runtime.runner import (
     GuardSyncAuthorizationExpiredError,
@@ -2027,6 +2028,8 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 workspace_dir=context.workspace_dir,
             )
             audit_payload["exit_code"] = exit_code
+            if exit_code == 0:
+                record_package_shim_audit_result(context, audited_at=now)
             return audit_payload
         if operation == "sync":
             return sync_supply_chain_bundle(self.server.store)  # type: ignore[attr-defined]

plugin_scanner-2.0.554/src/codex_plugin_scanner/guard/package_shim_status.py

@@ -0,0 +1,61 @@
+"""Package shim status enrichment and audit proof persistence."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .adapters.base import HarnessContext
+
+
+def enrich_package_shim_status_payload(
+    status: dict[str, object],
+    manifest: dict[str, object],
+) -> dict[str, object]:
+    bypasses = status.get("bypasses", [])
+    path_broken_managers = sorted(
+        {
+            str(entry["manager"])
+            for entry in bypasses
+            if isinstance(entry, dict) and isinstance(entry.get("manager"), str)
+        }
+    )
+    last_test_at = status.get("last_test_at", {})
+    tested_managers = (
+        sorted(manager for manager in last_test_at if isinstance(manager, str))
+        if isinstance(last_test_at, dict)
+        else []
+    )
+    last_audit_proof_at = manifest.get("last_audit_at")
+    normalized_last_audit = last_audit_proof_at if isinstance(last_audit_proof_at, str) else None
+    normalized_last_tests = last_test_at if isinstance(last_test_at, dict) else {}
+
+    enriched = dict(status)
+    enriched["path_broken_managers"] = path_broken_managers
+    enriched["tested_managers"] = tested_managers
+    enriched["pathBrokenManagers"] = path_broken_managers
+    enriched["testedManagers"] = tested_managers
+    enriched["last_intercept_proof_at"] = normalized_last_tests
+    enriched["lastInterceptProofAt"] = normalized_last_tests
+    enriched["detectedManagers"] = list(status.get("detected_managers", []))
+    enriched["protectedManagers"] = list(status.get("protected_managers", []))
+    enriched["installedManagers"] = list(status.get("installed_managers", []))
+    enriched["activeManagers"] = list(status.get("active_managers", []))
+    enriched["missingManagers"] = list(status.get("missing_managers", []))
+    enriched["undetectedManagers"] = list(status.get("undetected_managers", []))
+    enriched["last_audit_proof_at"] = normalized_last_audit
+    enriched["lastAuditProofAt"] = normalized_last_audit
+    return enriched
+
+
+def record_package_shim_audit_result(
+    context: HarnessContext,
+    *,
+    audited_at: str | None = None,
+) -> None:
+    from .shims import _load_package_shim_manifest, _write_package_shim_manifest
+
+    manifest = _load_package_shim_manifest(context)
+    manifest["last_audit_at"] = audited_at if audited_at is not None else datetime.now(timezone.utc).isoformat()
+    _write_package_shim_manifest(context, manifest)

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/src/codex_plugin_scanner/guard/shims.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from .launcher import merge_guard_launcher_env
+from .package_shim_status import enrich_package_shim_status_payload
 from .shim_probe import (
     SHIM_PROBE_ENV_VALUE,
     SHIM_PROBE_ENV_VAR,
@@ -448,27 +449,30 @@ def package_shim_status(context: HarnessContext) -> dict[str, object]:
         path_contains_shim_dir=path_contains_shim_dir,
         shell_profile_configured=bool(profile_status["shell_profile_configured"]),
     )
-    return {
-        "active_managers": active_managers,
-        "detected_managers": detected_managers,
-        "installed_managers": installed_managers,
-        "last_test_at": normalized_last_tests,
-        "protected_managers": protected_managers,
-        "path_active": bool(installed_managers) and len(protected_managers) == len(installed_managers),
-        "path_contains_shim_dir": path_contains_shim_dir,
-        "path_status": activation_path_status,
-        "bypasses": bypasses,
-        "manager_details": manager_details,
-        "manifest_path": str(_package_shim_manifest_path(context)),
-        "missing_managers": missing_managers,
-        "restart_shell_required": activation_path_status == "restart_required",
-        "shell_profile_configured": bool(profile_status["shell_profile_configured"]),
-        "shell_profile_path": profile_status["shell_profile_path"],
-        "shell_hints": _path_export_hints(shim_dir),
-        "shim_dir": str(shim_dir),
-        "supported_managers": list(package_shim_supported_managers()),
-        "undetected_managers": undetected_managers,
-    }
+    return enrich_package_shim_status_payload(
+        {
+            "active_managers": active_managers,
+            "detected_managers": detected_managers,
+            "installed_managers": installed_managers,
+            "last_test_at": normalized_last_tests,
+            "protected_managers": protected_managers,
+            "path_active": bool(installed_managers) and len(protected_managers) == len(installed_managers),
+            "path_contains_shim_dir": path_contains_shim_dir,
+            "path_status": activation_path_status,
+            "bypasses": bypasses,
+            "manager_details": manager_details,
+            "manifest_path": str(_package_shim_manifest_path(context)),
+            "missing_managers": missing_managers,
+            "restart_shell_required": activation_path_status == "restart_required",
+            "shell_profile_configured": bool(profile_status["shell_profile_configured"]),
+            "shell_profile_path": profile_status["shell_profile_path"],
+            "shell_hints": _path_export_hints(shim_dir),
+            "shim_dir": str(shim_dir),
+            "supported_managers": list(package_shim_supported_managers()),
+            "undetected_managers": undetected_managers,
+        },
+        manifest,
+    )
 
 
 def package_shim_cloud_coverage(

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.552 → plugin_scanner-2.0.554}/tests/test_dashboard_sync_security.py

@@ -5,9 +5,15 @@ from __future__ import annotations
 import subprocess
 from pathlib import Path
 
+import pytest
+
 from codex_plugin_scanner.guard.cli.dashboard_sync import (
+    _export_committed_static_files,
+    _is_safe_committed_tree_path,
     _is_trusted_hol_guard_origin,
+    _list_committed_static_files,
     _normalize_github_repo_slug,
+    _relative_static_path,
     verify_source_checkout,
 )
 
@@ -72,3 +78,88 @@ def test_verify_source_checkout_accepts_canonical_origin(tmp_path: Path) -> None
     )
 
     assert verify_source_checkout(checkout) == checkout
+
+
+@pytest.mark.parametrize(
+    "bad_path",
+    [
+        "src/static/../../evil.py",
+        "src/static/./hidden.js",
+        "/etc/passwd",
+        "src\\static\\evil.py",
+        "src/static/\x00evil.py",
+        "",
+        "src/static//double-slash",
+    ],
+)
+def test_is_safe_committed_tree_path_rejects_unsafe_paths(bad_path: str) -> None:
+    assert _is_safe_committed_tree_path(bad_path) is False
+
+
+def test_relative_static_path_rejects_traversal_suffix() -> None:
+    static_prefix = "src/codex_plugin_scanner/guard/daemon/static"
+    traversal_path = f"{static_prefix}/../../evil.py"
+
+    assert _relative_static_path(traversal_path, static_prefix) is None
+
+
+class _FakeGitLsTreeResult:
+    returncode = 0
+
+    def __init__(self, stdout: str) -> None:
+        self.stdout = stdout
+
+
+def test_list_committed_static_files_skips_unsafe_ls_tree_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "checkout"
+    checkout.mkdir()
+    static_prefix = "src/codex_plugin_scanner/guard/daemon/static"
+    safe_path = f"{static_prefix}/index.html"
+    traversal_path = f"{static_prefix}/../../evil.py"
+
+    monkeypatch.setattr(
+        "codex_plugin_scanner.guard.cli.dashboard_sync._git_run",
+        lambda *_args, **_kwargs: _FakeGitLsTreeResult(f"{safe_path}\n{traversal_path}\n"),
+    )
+
+    assert _list_committed_static_files(checkout, static_prefix) == [safe_path]
+
+
+def test_export_committed_static_files_rejects_traversal_paths(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    checkout = tmp_path / "checkout"
+    checkout.mkdir()
+    static_prefix = "src/codex_plugin_scanner/guard/daemon/static"
+    safe_path = f"{static_prefix}/index.html"
+    traversal_path = f"{static_prefix}/../../evil.py"
+
+    monkeypatch.setattr(
+        "codex_plugin_scanner.guard.cli.dashboard_sync._list_committed_static_files",
+        lambda *_args, **_kwargs: [safe_path, traversal_path],
+    )
+    monkeypatch.setattr(
+        "codex_plugin_scanner.guard.cli.dashboard_sync._read_committed_file",
+        lambda _checkout, path: (
+            b"<html>safe</html>" if path == safe_path else b"malicious"
+        ),
+    )
+
+    installed_static = tmp_path / "installed-static"
+    installed_static.mkdir(parents=True)
+    (installed_static / "index.html").write_text("<html>safe</html>", encoding="utf-8")
+
+    copied_count = _export_committed_static_files(
+        source_checkout=checkout,
+        static_prefix=static_prefix,
+        installed_static=installed_static,
+    )
+
+    assert copied_count == 1
+    assert (installed_static / "index.html").is_file()
+    assert not (tmp_path / "evil.py").exists()
+    assert not (installed_static / "evil.py").exists()

plugin_scanner-2.0.554/tests/test_guard_phase11_package_firewall_status.py

@@ -0,0 +1,97 @@
+"""Phase 11 package firewall status API field proofs."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codex_plugin_scanner.guard.package_shim_status import record_package_shim_audit_result
+from codex_plugin_scanner.guard.shims import (
+    install_package_shims,
+    package_shim_status,
+    probe_package_shim_intercepts,
+)
+from tests.shim_execution_helpers import write_fake_manager_script
+
+
+def _harness_context(tmp_path: Path) -> MagicMock:
+    home_dir = tmp_path / "home"
+    home_dir.mkdir(parents=True, exist_ok=True)
+    guard_home = tmp_path / "guard-home"
+    guard_home.mkdir(parents=True, exist_ok=True)
+    workspace_dir = tmp_path / "workspace"
+    workspace_dir.mkdir(parents=True, exist_ok=True)
+    context = MagicMock()
+    context.home_dir = home_dir
+    context.workspace_dir = workspace_dir
+    context.guard_home = guard_home
+    return context
+
+
+def test_package_shim_status_exposes_phase11_alias_fields(tmp_path: Path) -> None:
+    context = _harness_context(tmp_path)
+    install_package_shims(context, managers=("npm",))
+    status_before = package_shim_status(context)
+    assert status_before["lastAuditProofAt"] is None
+    record_package_shim_audit_result(context, audited_at="2026-06-10T01:00:00+00:00")
+
+    status = package_shim_status(context)
+
+    assert status["detectedManagers"] == status["detected_managers"]
+    assert status["protectedManagers"] == status["protected_managers"]
+    assert status["installedManagers"] == status["installed_managers"]
+    assert status["pathBrokenManagers"] == status["path_broken_managers"]
+    assert status["lastAuditProofAt"] == "2026-06-10T01:00:00+00:00"
+    assert status["last_audit_proof_at"] == "2026-06-10T01:00:00+00:00"
+    assert isinstance(status["lastInterceptProofAt"], dict)
+    assert status["lastInterceptProofAt"] == status["last_intercept_proof_at"] == status["last_test_at"]
+
+
+def test_package_shim_status_lists_tested_managers_after_probe(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    context = _harness_context(tmp_path)
+    install_package_shims(context, managers=("npm",))
+    shim_dir = context.guard_home / "package-shims" / "bin"
+    fake_bin = tmp_path / "fake-bin"
+    fake_bin.mkdir(parents=True)
+    write_fake_manager_script(
+        fake_bin=fake_bin,
+        manager="npm",
+        marker_path=tmp_path / "npm-probe-marker.json",
+        exit_code=0,
+    )
+    monkeypatch.setenv("PATH", os.pathsep.join([str(shim_dir), str(fake_bin)]))
+
+    probe_package_shim_intercepts(context, managers=("npm",), workspace_dir=context.workspace_dir)
+    status = package_shim_status(context)
+
+    assert "npm" in status["testedManagers"]
+    assert status["lastInterceptProofAt"]["npm"] == status["last_test_at"]["npm"]
+
+
+def test_package_shim_status_lists_path_broken_managers_from_bypasses(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    context = _harness_context(tmp_path)
+    install_package_shims(context, managers=("npm",))
+    shim_dir = context.guard_home / "package-shims" / "bin"
+    fake_bin = tmp_path / "fake-bin"
+    fake_bin.mkdir(parents=True)
+    write_fake_manager_script(
+        fake_bin=fake_bin,
+        manager="npm",
+        marker_path=tmp_path / "npm-path-marker.json",
+        exit_code=0,
+    )
+    monkeypatch.setenv("PATH", os.pathsep.join([str(fake_bin), str(shim_dir)]))
+
+    status = package_shim_status(context)
+
+    assert "npm" in status["pathBrokenManagers"]
+    assert status["path_broken_managers"] == status["pathBrokenManagers"]