plugin-scanner 2.0.591__tar.gz → 2.0.592__tar.gz

{plugin_scanner-2.0.591 → plugin_scanner-2.0.592}/PKG-INFO

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

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

{plugin_scanner-2.0.591 → plugin_scanner-2.0.592}/pyproject.toml.bak

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

@@ -35,6 +35,7 @@ GUARD_CONNECT_URL = f"{GUARD_DASHBOARD_URL}/connect"
 _WORKSPACE_SCOPED_RUNTIME_ARTIFACT_TYPES = frozenset(
     {
         "file_read_request",
+        "package_request",
         "prompt_request",
         "tool_action_request",
     }

{plugin_scanner-2.0.591 → plugin_scanner-2.0.592}/src/codex_plugin_scanner/guard/cli/commands.py

@@ -229,6 +229,7 @@ from .install_commands import (
     uninstall_confirmation_token,
 )
 from .product import build_guard_start_payload, build_guard_status_payload
+from .protect_approvals import _queue_local_protect_approvals, _suppress_package_shim_allow_output
 from .remote_pair_flow import dispatch_guard_remote_pair_command
 from .update_commands import run_guard_update
 
@@ -558,6 +559,7 @@ def _configure_guard_parser(guard_parser: argparse.ArgumentParser) -> None:
     protect_parser.add_argument("--dry-run", action="store_true")
     protect_parser.add_argument("--unsafe-raw-output", action="store_true")
     protect_parser.add_argument("--json", action="store_true")
+    protect_parser.add_argument("--package-shim-ui", action="store_true", help=argparse.SUPPRESS)
     protect_parser.add_argument("protect_command", nargs=argparse.REMAINDER)
 
     preflight_parser = guard_subparsers.add_parser(
@@ -1990,7 +1992,20 @@ def run_guard_command(
             config=config,
             unsafe_raw_output=bool(getattr(args, "unsafe_raw_output", False)),
         )
-        _emit("protect", payload, getattr(args, "json", False))
+        _queue_local_protect_approvals(
+            payload,
+            store=store,
+            guard_home=guard_home,
+            workspace=workspace or Path.cwd(),
+            ensure_approval_daemon=ensure_guard_daemon,
+            approval_delivery_payload=_approval_delivery_payload,
+            localize_pending_approval_copy=lambda response_payload, harness: _localize_pending_approval_copy(
+                response_payload,
+                harness=harness,
+            ),
+        )
+        if not _suppress_package_shim_allow_output(args, payload):
+            _emit("protect", payload, getattr(args, "json", False))
         return exit_code
 
     if args.guard_command == "start":
@@ -5940,12 +5955,35 @@ def _native_approval_center_context(response_payload: dict[str, object], *, harn
     if not isinstance(approval_center_url, str) or not approval_center_url.strip():
         return None
     review_url = _preferred_approval_review_url(response_payload, harness=harness) or approval_center_url.strip()
+    canonical_harness = _canonical_harness_name(harness)
     harness_label = {
         "claude-code": "Claude Code",
         "codex": "Codex",
         "copilot": "Copilot",
+        "guard-cli": "package install",
         "opencode": "OpenCode",
-    }.get(_canonical_harness_name(harness), "the harness")
+    }.get(canonical_harness, "the harness")
+    if canonical_harness in {
+        "npm",
+        "npx",
+        "pnpm",
+        "yarn",
+        "bun",
+        "pip",
+        "pip3",
+        "pipenv",
+        "pipx",
+        "poetry",
+        "uv",
+        "uvx",
+        "cargo",
+        "go",
+        "composer",
+        "bundle",
+        "mvn",
+        "gradle",
+    }:
+        harness_label = "package install"
     return (
         f"Open HOL Guard to approve or keep this blocked: {review_url}. "
         f"After you choose, retry the same {harness_label} action."

plugin_scanner-2.0.592/src/codex_plugin_scanner/guard/cli/protect_approvals.py

@@ -0,0 +1,269 @@
+"""Protect approval helpers for package-install flows."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shlex
+from collections.abc import Callable
+from pathlib import Path
+
+from ..adapters.base import HarnessContext
+from ..approvals import approval_center_hint, attach_primary_approval_link, queue_blocked_approvals
+from ..models import GuardArtifact, HarnessDetection
+from ..shim_probe import SHIM_PROBE_ENV_VALUE, SHIM_PROBE_ENV_VAR
+from ..store import GuardStore
+
+
+def _queue_local_protect_approvals(
+    response_payload: dict[str, object],
+    *,
+    store: GuardStore,
+    guard_home: Path,
+    workspace: Path,
+    ensure_approval_daemon: Callable[[Path], str],
+    approval_delivery_payload: Callable[[str], dict[str, object]],
+    localize_pending_approval_copy: Callable[[dict[str, object], str], None],
+) -> None:
+    if not _should_queue_local_protect_approval(response_payload):
+        return
+    artifact = _protect_request_artifact(response_payload, workspace=workspace)
+    if artifact is None:
+        return
+    approval_item = _protect_approval_item(response_payload, workspace=workspace, artifact=artifact)
+    if approval_item is None:
+        return
+    try:
+        approval_center_url = ensure_approval_daemon(guard_home)
+    except RuntimeError:
+        return
+    detection = HarnessDetection(
+        harness=artifact.harness,
+        installed=True,
+        command_available=True,
+        config_paths=(artifact.config_path,),
+        artifacts=(artifact,),
+    )
+    queued = queue_blocked_approvals(
+        detection=detection,
+        evaluation={"artifacts": [approval_item]},
+        store=store,
+        approval_center_url=approval_center_url,
+    )
+    if not queued:
+        return
+    response_payload["approval_requests"] = queued
+    response_payload["artifact_id"] = artifact.artifact_id
+    response_payload["approval_request_ids"] = [
+        str(item["request_id"]) for item in queued if isinstance(item, dict) and "request_id" in item
+    ]
+    response_payload["approval_center_url"] = approval_center_url
+    harness = artifact.harness
+    display_harness = _protect_display_harness(response_payload)
+    attach_primary_approval_link(
+        response_payload,
+        harness=harness,
+        approval_center_url=approval_center_url,
+    )
+    response_payload["review_hint"] = approval_center_hint(
+        context=HarnessContext(home_dir=guard_home, workspace_dir=workspace, guard_home=guard_home),
+        harness=display_harness,
+        approval_center_url=approval_center_url,
+        queued=queued,
+        request_id=_optional_string(response_payload.get("primary_approval_request_id")),
+        artifact_id=artifact.artifact_id,
+    )
+    response_payload["approval_delivery"] = approval_delivery_payload(display_harness)
+    localize_pending_approval_copy(response_payload, display_harness)
+    _bind_protect_receipt_approval(response_payload, store=store)
+
+
+def _should_queue_local_protect_approval(response_payload: dict[str, object]) -> bool:
+    if os.environ.get(SHIM_PROBE_ENV_VAR) == SHIM_PROBE_ENV_VALUE:
+        return False
+    return not _protect_has_reason_code(response_payload, "saved_package_block")
+
+
+def _protect_request_artifact(response_payload: dict[str, object], *, workspace: Path) -> GuardArtifact | None:
+    receipt = response_payload.get("receipt")
+    request = response_payload.get("request")
+    if not isinstance(receipt, dict) or not isinstance(request, dict):
+        return None
+    artifact_id = _optional_string(receipt.get("artifact_id"))
+    if artifact_id is None:
+        return None
+    artifact_name = _optional_string(receipt.get("artifact_name")) or artifact_id
+    redacted_command = _optional_string(request.get("redacted_command"))
+    command_tokens = request.get("command")
+    if redacted_command is None and isinstance(command_tokens, list):
+        command_parts = [str(item) for item in command_tokens if isinstance(item, str)]
+        redacted_command = shlex.join(command_parts) if command_parts else None
+    source_scope = _optional_string(receipt.get("source_scope")) or "project"
+    package_manager = (
+        _optional_string(request.get("package_manager")) or _optional_string(request.get("executor")) or "package"
+    )
+    intent_kind = _optional_string(request.get("install_kind")) or "install"
+    config_path = str(workspace / "hol-guard.toml")
+    return GuardArtifact(
+        artifact_id=artifact_id,
+        name=artifact_name,
+        harness=_protect_payload_harness(response_payload),
+        artifact_type="package_request",
+        source_scope=source_scope,
+        config_path=config_path,
+        command=redacted_command,
+        metadata={
+            "package_manager": package_manager,
+            "intent_kind": intent_kind,
+            "targets": request.get("targets") if isinstance(request.get("targets"), list) else [],
+            "manifest_paths": request.get("manifest_paths") if isinstance(request.get("manifest_paths"), list) else [],
+            "lockfile_paths": request.get("lockfile_paths") if isinstance(request.get("lockfile_paths"), list) else [],
+            "redacted_command": redacted_command,
+        },
+    )
+
+
+def _protect_approval_item(
+    response_payload: dict[str, object],
+    *,
+    workspace: Path,
+    artifact: GuardArtifact,
+) -> dict[str, object] | None:
+    del workspace
+    supply_chain_evaluation = response_payload.get("supply_chain_evaluation")
+    receipt = response_payload.get("receipt")
+    verdict = response_payload.get("verdict")
+    if not isinstance(supply_chain_evaluation, dict) or not isinstance(receipt, dict) or not isinstance(verdict, dict):
+        return None
+    policy_action = _protect_policy_action(response_payload)
+    if policy_action not in {"block", "require-reapproval"}:
+        return None
+    user_copy = supply_chain_evaluation.get("user_copy")
+    user_copy_map = user_copy if isinstance(user_copy, dict) else {}
+    return {
+        "artifact_id": artifact.artifact_id,
+        "artifact_name": artifact.name,
+        "artifact_hash": _optional_string(receipt.get("artifact_hash")) or artifact.artifact_id,
+        "artifact_type": artifact.artifact_type,
+        "source_scope": artifact.source_scope,
+        "config_path": artifact.config_path,
+        "policy_action": policy_action,
+        "changed_fields": _protect_target_labels(response_payload),
+        "risk_summary": _optional_string(verdict.get("reason"))
+        or _optional_string(supply_chain_evaluation.get("risk_summary"))
+        or _optional_string(user_copy_map.get("summary")),
+        "risk_signals": _string_list(verdict.get("risk_signals")),
+        "action_envelope_json": (
+            receipt.get("action_envelope_json") if isinstance(receipt.get("action_envelope_json"), dict) else None
+        ),
+        "decision_v2_json": {
+            "action": policy_action,
+            "user_title": _optional_string(user_copy_map.get("title")) or "Review required",
+            "summary": _optional_string(user_copy_map.get("summary")) or _optional_string(verdict.get("reason")) or "",
+            "harness_message": _optional_string(user_copy_map.get("harness_message")) or "",
+        },
+    }
+
+
+def _protect_target_labels(response_payload: dict[str, object]) -> list[str]:
+    request = response_payload.get("request")
+    if not isinstance(request, dict):
+        return []
+    targets = request.get("targets")
+    if not isinstance(targets, list):
+        return []
+    labels: list[str] = []
+    for item in targets:
+        if not isinstance(item, dict):
+            continue
+        candidate = _optional_string(item.get("package_name")) or _optional_string(item.get("raw_spec"))
+        if candidate is not None and candidate not in labels:
+            labels.append(candidate)
+    return labels
+
+
+def _protect_payload_harness(response_payload: dict[str, object]) -> str:
+    request = response_payload.get("request")
+    if isinstance(request, dict):
+        for key in ("harness", "package_manager", "executor"):
+            value = _optional_string(request.get(key))
+            if value is not None:
+                return value
+    receipt = response_payload.get("receipt")
+    if isinstance(receipt, dict):
+        value = _optional_string(receipt.get("harness"))
+        if value is not None:
+            return value
+    return "guard-cli"
+
+
+def _protect_display_harness(response_payload: dict[str, object]) -> str:
+    request = response_payload.get("request")
+    if isinstance(request, dict):
+        for key in ("package_manager", "harness", "executor"):
+            value = _optional_string(request.get(key))
+            if value is not None:
+                return value
+    return _protect_payload_harness(response_payload)
+
+
+def _protect_policy_action(response_payload: dict[str, object]) -> str | None:
+    verdict = response_payload.get("verdict")
+    if isinstance(verdict, dict):
+        action = _optional_string(verdict.get("action"))
+        if action == "block":
+            return "block"
+        if action == "review":
+            return "require-reapproval"
+    supply_chain_evaluation = response_payload.get("supply_chain_evaluation")
+    if not isinstance(supply_chain_evaluation, dict):
+        return None
+    return _optional_string(supply_chain_evaluation.get("policy_action"))
+
+
+def _protect_has_reason_code(response_payload: dict[str, object], reason_code: str) -> bool:
+    supply_chain_evaluation = response_payload.get("supply_chain_evaluation")
+    if not isinstance(supply_chain_evaluation, dict):
+        return False
+    reasons = supply_chain_evaluation.get("reasons")
+    if not isinstance(reasons, list):
+        return False
+    return any(_optional_string(item.get("code")) == reason_code for item in reasons if isinstance(item, dict))
+
+
+def _bind_protect_receipt_approval(response_payload: dict[str, object], *, store: GuardStore) -> None:
+    receipt = response_payload.get("receipt")
+    if not isinstance(receipt, dict):
+        return
+    receipt_id = _optional_string(receipt.get("receipt_id"))
+    approval_request_id = _optional_string(response_payload.get("primary_approval_request_id"))
+    if receipt_id is None or approval_request_id is None:
+        return
+    receipt["approval_source"] = "approval-center"
+    receipt["approval_request_id"] = approval_request_id
+    store.update_receipt_approval_context(
+        receipt_id,
+        approval_source="approval-center",
+        approval_request_id=approval_request_id,
+    )
+
+
+def _suppress_package_shim_allow_output(args: argparse.Namespace, response_payload: dict[str, object]) -> bool:
+    if not bool(getattr(args, "package_shim_ui", False)) or bool(getattr(args, "json", False)):
+        return False
+    verdict = response_payload.get("verdict")
+    action = _optional_string(verdict.get("action")) if isinstance(verdict, dict) else None
+    return action == "allow"
+
+
+def _optional_string(value: object | None) -> str | None:
+    if not isinstance(value, str):
+        return None
+    normalized = value.strip()
+    return normalized or None
+
+
+def _string_list(value: object | None) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [item.strip() for item in value if isinstance(item, str) and item.strip()]

{plugin_scanner-2.0.591 → plugin_scanner-2.0.592}/src/codex_plugin_scanner/guard/cli/render.py

@@ -108,13 +108,23 @@ _SENSITIVE_STRING_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
 def emit_guard_payload(command: str, payload: dict[str, object], as_json: bool) -> None:
     """Render Guard payloads as JSON or human-friendly rich output."""
 
-    if as_json or not _RICH_AVAILABLE:
+    if as_json:
         redacted_output = redact_text(_safe_json_output_text(command, payload))
         sys.stdout.write(redacted_output.text)
         sys.stdout.write("\n")
         return
 
     redacted_payload = _redact_payload(payload)
+    if not _RICH_AVAILABLE:
+        plain_renderer = _PLAIN_TEXT_RENDERERS.get(command)
+        if plain_renderer is None:
+            redacted_output = redact_text(_safe_json_output_text(command, payload))
+            sys.stdout.write(redacted_output.text)
+        else:
+            sys.stdout.write(plain_renderer(redacted_payload))
+        sys.stdout.write("\n")
+        return
+
     console = Console(file=sys.stdout, soft_wrap=True)
     renderer = _RENDERERS.get(command, _render_fallback)
     renderer(console, redacted_payload)
@@ -155,6 +165,59 @@ def _safe_json_output_text(command: str, payload: dict[str, object]) -> str:
     return _render_redacted_json_payload(sanitized_payload)
 
 
+def _plain_text_protect(payload: dict[str, object]) -> str:
+    if str(payload.get("mode") or "") == "status":
+        lines = ["HOL Guard install protection is active."]
+        supply_chain = payload.get("supply_chain")
+        if isinstance(supply_chain, dict):
+            status = str(supply_chain.get("status") or "").strip()
+            detail = str(supply_chain.get("detail") or "").strip()
+            if status:
+                lines.append(f"Status: {status}")
+            if detail:
+                lines.append(detail)
+        return "\n".join(lines)
+
+    verdict = payload.get("verdict")
+    verdict_map = verdict if isinstance(verdict, dict) else {}
+    action = str(verdict_map.get("action") or "review").strip() or "review"
+    action_line = {
+        "allow": "HOL Guard allowed this install.",
+        "block": "HOL Guard blocked this install before it ran.",
+        "review": "HOL Guard paused this install for review before it ran.",
+        "require-reapproval": "HOL Guard paused this install for review before it ran.",
+        "warn": "HOL Guard warned about this install.",
+    }.get(action, f"HOL Guard decision: {action}.")
+    lines = [action_line]
+
+    request = payload.get("request")
+    if isinstance(request, dict):
+        command_text = _command_text(request.get("command")).strip()
+        if command_text and command_text != "none":
+            lines.append(f"Command: {command_text}")
+
+    reason = str(verdict_map.get("reason") or "").strip()
+    if reason:
+        lines.append(f"Reason: {reason}")
+
+    supply_chain_evaluation = payload.get("supply_chain_evaluation")
+    user_copy = supply_chain_evaluation.get("user_copy") if isinstance(supply_chain_evaluation, dict) else None
+    user_copy_map = user_copy if isinstance(user_copy, dict) else {}
+    harness_message = str(user_copy_map.get("harness_message") or "").strip()
+    if harness_message:
+        lines.append(harness_message)
+
+    next_step = str(user_copy_map.get("next_step") or "").strip()
+    if next_step and next_step not in harness_message:
+        lines.append(f"Next step: {next_step}")
+
+    dashboard_url = str(user_copy_map.get("dashboard_url") or "").strip()
+    if dashboard_url and dashboard_url not in harness_message:
+        lines.append(f"Review: {dashboard_url}")
+
+    return "\n".join(lines)
+
+
 def _sanitize_payload_for_output(value: object) -> object:
     return _redact_payload(value)
 
@@ -2327,6 +2390,11 @@ def _clean_terminal_output(value: str) -> str:
     return re.sub(r"\x1b\[[0-9;?]*[ -/]*[@-~]", "", value)
 
 
+_PLAIN_TEXT_RENDERERS: dict[str, Callable[[dict[str, object]], str]] = {
+    "protect": _plain_text_protect,
+}
+
+
 _RENDERERS: dict[str, Any] = {
     "approvals": _render_approvals,
     "init": _render_init,

{plugin_scanner-2.0.591 → plugin_scanner-2.0.592}/src/codex_plugin_scanner/guard/daemon/manager.py

@@ -23,6 +23,7 @@ from pathlib import Path
 from typing import BinaryIO
 
 from ...version import __version__
+from ..launcher import merge_guard_launcher_env
 
 DEFAULT_GUARD_DAEMON_PORT = 4781
 GUARD_DAEMON_PORT_RANGE = 1000
@@ -58,14 +59,12 @@ class ApprovalCenterLocator:
 
 def _daemon_launcher_env() -> dict[str, str]:
     env = dict(os.environ)
-    pythonpath_entries: list[str] = []
-    for raw_value in (str(Path(__file__).resolve().parents[3]), env.get("PYTHONPATH", "")):
-        for entry in raw_value.split(os.pathsep):
-            normalized = entry.strip()
-            if normalized and normalized not in pythonpath_entries:
-                pythonpath_entries.append(normalized)
-    if pythonpath_entries:
-        env["PYTHONPATH"] = os.pathsep.join(pythonpath_entries)
+    pinned_launcher_env = merge_guard_launcher_env(pin_package=True)
+    pinned_pythonpath = pinned_launcher_env.get("PYTHONPATH")
+    if isinstance(pinned_pythonpath, str) and pinned_pythonpath.strip():
+        env["PYTHONPATH"] = pinned_pythonpath
+    else:
+        env.pop("PYTHONPATH", None)
     return env