plugin-scanner 2.0.77__tar.gz → 2.0.78__tar.gz

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.77
+Version: 2.0.78
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/ai-plugin-scanner
 Project-URL: Repository, https://github.com/hashgraph-online/ai-plugin-scanner

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/pyproject.toml

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

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.77"
+version = "2.0.78"
 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.78/src/codex_plugin_scanner/guard/advisory_model.py

@@ -0,0 +1,150 @@
+"""Guard advisory identity helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+_PACKAGE_URL_ECOSYSTEMS = {
+    "npm": "npm",
+    "pnpm": "npm",
+    "yarn": "npm",
+    "pip": "pypi",
+    "uv": "pypi",
+    "go": "golang",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ProtectTargetIdentity:
+    """Subset of install target data advisory matching needs."""
+
+    artifact_id: str
+    artifact_name: str
+    ecosystem: str
+    package_name: str | None
+    package_url: str | None
+    source_url: str | None
+
+
+def build_package_url(ecosystem: str, package_name: str | None, version: str | None) -> str | None:
+    """Build a simple purl-style identifier for registry package installs."""
+
+    if package_name is None:
+        return None
+    purl_type = _PACKAGE_URL_ECOSYSTEMS.get(ecosystem)
+    if purl_type is None:
+        return None
+    base = f"pkg:{purl_type}/{normalize_identity_value(package_name)}"
+    if version is None or not version.strip():
+        return base
+    return f"{base}@{version.strip()}"
+
+
+def advisory_matches_target(advisory: dict[str, object], target: ProtectTargetIdentity) -> bool:
+    """Match advisories against install targets using stable identities first."""
+
+    advisory_id = advisory.get("artifact_id")
+    if isinstance(advisory_id, str) and advisory_id == target.artifact_id:
+        return True
+
+    advisory_ecosystem = advisory.get("ecosystem")
+    if isinstance(advisory_ecosystem, str) and advisory_ecosystem not in {target.ecosystem, "*"}:
+        return False
+
+    package_url = advisory.get("package_url")
+    if isinstance(package_url, str) and _package_url_matches(package_url, target.package_url):
+        return True
+
+    if _normalized_membership(advisory.get("aliases"), target.package_name, target.artifact_name):
+        return True
+
+    advisory_package = advisory.get("package") or advisory.get("name")
+    normalized_advisory_package = (
+        normalize_identity_value(advisory_package) if isinstance(advisory_package, str) else ""
+    )
+    if normalized_advisory_package != "" and normalized_advisory_package in {
+        normalize_identity_value(target.package_name),
+        normalize_identity_value(target.artifact_name),
+    }:
+        return True
+
+    publisher = advisory.get("publisher")
+    normalized_publisher = normalize_identity_value(publisher) if isinstance(publisher, str) else ""
+    if normalized_publisher != "" and normalized_publisher == normalize_identity_value(target.package_name):
+        return True
+
+    if _normalized_membership(advisory.get("publisher_identities"), target.package_name):
+        return True
+
+    if _endpoint_indicator_matches(advisory.get("endpoint_indicators"), target.source_url):
+        return True
+
+    advisory_source_url = advisory.get("source_url")
+    if not isinstance(advisory_source_url, str):
+        return False
+
+    normalized_advisory_source = _normalized_url_indicator(advisory_source_url)
+    normalized_target_source = _normalized_url_indicator(target.source_url)
+    return (
+        normalized_advisory_source != ""
+        and normalized_target_source != ""
+        and normalized_advisory_source == normalized_target_source
+    )
+
+
+def normalize_identity_value(value: str | None) -> str:
+    return value.strip().lower() if isinstance(value, str) and value.strip() else ""
+
+
+def _normalized_membership(values: object, *candidates: str | None) -> bool:
+    if not isinstance(values, list):
+        return False
+    normalized_values = {normalize_identity_value(item) for item in values if isinstance(item, str)}
+    normalized_candidates = {normalize_identity_value(candidate) for candidate in candidates if candidate is not None}
+    normalized_candidates.discard("")
+    return bool(normalized_values & normalized_candidates)
+
+
+def _package_url_matches(advisory_url: str, target_url: str | None) -> bool:
+    if target_url is None:
+        return False
+    normalized_advisory = _package_url_base(advisory_url)
+    normalized_target = _package_url_base(target_url)
+    return normalized_advisory != "" and normalized_advisory == normalized_target
+
+
+def _package_url_base(package_url: str) -> str:
+    normalized = normalize_identity_value(package_url)
+    for separator in ("?", "#"):
+        normalized = normalized.split(separator, 1)[0]
+    last_at = normalized.rfind("@")
+    if last_at == -1 or last_at < normalized.rfind("/"):
+        return normalized
+    return normalized[:last_at]
+
+
+def _endpoint_indicator_matches(values: object, source_url: str | None) -> bool:
+    if source_url is None or not isinstance(values, list):
+        return False
+    normalized_source = _normalized_url_indicator(source_url)
+    return any(
+        isinstance(item, str) and _url_indicator_matches(normalized_source, _normalized_url_indicator(item))
+        for item in values
+    )
+
+
+def _normalized_url_indicator(value: str | None) -> str:
+    if value is None:
+        return ""
+    parsed = urlsplit(value)
+    if not parsed.scheme or not parsed.netloc:
+        return normalize_identity_value(value)
+    path = parsed.path.rstrip("/")
+    return normalize_identity_value(f"{parsed.netloc}{path}")
+
+
+def _url_indicator_matches(normalized_source: str, normalized_indicator: str) -> bool:
+    if normalized_source == "" or normalized_indicator == "":
+        return False
+    return normalized_source == normalized_indicator or normalized_source.startswith(f"{normalized_indicator}/")

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/src/codex_plugin_scanner/guard/cli/commands.py

@@ -285,6 +285,7 @@ def _configure_guard_parser(guard_parser: argparse.ArgumentParser) -> None:
     )
     _add_guard_common_args(protect_parser)
     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("protect_command", nargs=argparse.REMAINDER)
 
@@ -659,6 +660,7 @@ def run_guard_command(
             workspace_dir=workspace or Path.cwd(),
             dry_run=bool(getattr(args, "dry_run", False)),
             now=_now(),
+            unsafe_raw_output=bool(getattr(args, "unsafe_raw_output", False)),
         )
         _emit("protect", payload, getattr(args, "json", False))
         return exit_code

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/src/codex_plugin_scanner/guard/protect.py

@@ -12,8 +12,10 @@ from pathlib import Path
 from typing import Literal
 from urllib.parse import urlparse
 
+from .advisory_model import ProtectTargetIdentity, advisory_matches_target, build_package_url
 from .models import GuardReceipt
 from .receipts import build_receipt
+from .redaction import redact_text
 from .store import GuardStore
 
 ProtectAction = Literal["allow", "review", "block"]
@@ -38,6 +40,7 @@ class ProtectTarget:
     artifact_type: str
     ecosystem: str
     package_name: str | None
+    package_url: str | None
     raw_spec: str | None
     version: str | None
     source_url: str | None
@@ -50,6 +53,7 @@ class ProtectTarget:
             "artifact_type": self.artifact_type,
             "ecosystem": self.ecosystem,
             "package_name": self.package_name,
+            "package_url": self.package_url,
             "raw_spec": self.raw_spec,
             "version": self.version,
             "source_url": self.source_url,
@@ -109,6 +113,7 @@ def build_protect_payload(
     workspace_dir: Path,
     dry_run: bool,
     now: str,
+    unsafe_raw_output: bool = False,
 ) -> tuple[dict[str, object], int]:
     """Evaluate and optionally execute an install command."""
 
@@ -151,11 +156,16 @@ def build_protect_payload(
         text=True,
         timeout=_protect_command_timeout_seconds(),
     )
+    redacted_stdout = redact_text(execution.stdout)
+    redacted_stderr = redact_text(execution.stderr)
     payload["executed"] = True
     payload["execution"] = {
         "returncode": execution.returncode,
-        "stdout": execution.stdout,
-        "stderr": execution.stderr,
+        "stdout": execution.stdout if unsafe_raw_output else redacted_stdout.text,
+        "stderr": execution.stderr if unsafe_raw_output else redacted_stderr.text,
+        "stdout_redactions": redacted_stdout.to_dict(),
+        "stderr_redactions": redacted_stderr.to_dict(),
+        "raw_output_enabled": unsafe_raw_output,
     }
     if execution.returncode == 0:
         store.add_receipt(receipt)
@@ -287,6 +297,7 @@ def _parse_codex_request(command: list[str]) -> ProtectRequest:
             artifact_type="mcp_server",
             ecosystem="codex",
             package_name=name,
+            package_url=None,
             raw_spec=name,
             version=None,
             source_url=_option_value(command, "--url"),
@@ -309,6 +320,7 @@ def _parse_claude_request(command: list[str]) -> ProtectRequest:
             artifact_type="mcp_server",
             ecosystem="claude-code",
             package_name=name,
+            package_url=None,
             raw_spec=command_or_url,
             version=None,
             source_url=command_or_url if command_or_url.startswith(("http://", "https://")) else None,
@@ -334,6 +346,7 @@ def _parse_cursor_request(command: list[str]) -> ProtectRequest:
             artifact_type="mcp_server",
             ecosystem="cursor",
             package_name=name,
+            package_url=None,
             raw_spec=name,
             version=None,
             source_url=_option_value(command, "--url"),
@@ -352,6 +365,7 @@ def _parse_gemini_request(command: list[str]) -> ProtectRequest:
             artifact_type="extension",
             ecosystem="gemini",
             package_name=name,
+            package_url=None,
             raw_spec=name,
             version=None,
             source_url=_option_value(command, "--url"),
@@ -372,6 +386,7 @@ def _parse_gemini_request(command: list[str]) -> ProtectRequest:
             artifact_type=artifact_type,
             ecosystem="gemini",
             package_name=name if artifact_type == "extension" else None,
+            package_url=build_package_url("gemini", name if artifact_type == "extension" else None, None),
             raw_spec=spec,
             version=None,
             source_url=_spec_url(spec),
@@ -389,6 +404,7 @@ def _parse_gemini_request(command: list[str]) -> ProtectRequest:
             artifact_type="mcp_server",
             ecosystem="gemini",
             package_name=name,
+            package_url=None,
             raw_spec=command_or_url,
             version=None,
             source_url=source_url,
@@ -407,6 +423,7 @@ def _parse_antigravity_request(command: list[str]) -> ProtectRequest:
             artifact_type="extension",
             ecosystem="antigravity",
             package_name=extension_name,
+            package_url=build_package_url("antigravity", extension_name, None),
             raw_spec=extension_name,
             version=None,
             source_url=_spec_url(extension_name),
@@ -429,6 +446,7 @@ def _parse_opencode_request(command: list[str]) -> ProtectRequest:
             artifact_type="plugin" if command[1] == "plugin" else "skill",
             ecosystem="opencode",
             package_name=name,
+            package_url=None,
             raw_spec=name,
             version=None,
             source_url=_option_value(command, "--url"),
@@ -446,6 +464,7 @@ def _parse_custom_request(command: list[str]) -> ProtectRequest:
         artifact_type="custom_command",
         ecosystem="custom",
         package_name=None,
+        package_url=None,
         raw_spec=shlex.join(command),
         version=None,
         source_url=_first_url(command),
@@ -464,6 +483,7 @@ def _package_manager_request(command: list[str], ecosystem: str, specs: tuple[st
                 artifact_type="package_request",
                 ecosystem=ecosystem,
                 package_name=None,
+                package_url=None,
                 raw_spec=shlex.join(command),
                 version=None,
                 source_url=_first_url(command),
@@ -483,6 +503,7 @@ def _package_target(ecosystem: str, spec: str) -> ProtectTarget:
         artifact_type=f"{ecosystem}_package",
         ecosystem=ecosystem,
         package_name=package_name,
+        package_url=build_package_url(ecosystem, package_name, version),
         raw_spec=spec,
         version=version,
         source_url=source_url,
@@ -613,6 +634,7 @@ def _parse_antigravity_mcp_target(raw_payload: str) -> ProtectTarget:
         artifact_type="mcp_server",
         ecosystem="antigravity",
         package_name=name,
+        package_url=None,
         raw_spec=raw_payload,
         version=None,
         source_url=source_url,
@@ -640,6 +662,7 @@ def _parse_claude_mcp_target(name: str, raw_payload: str) -> ProtectTarget:
         artifact_type="mcp_server",
         ecosystem="claude-code",
         package_name=name,
+        package_url=None,
         raw_spec=raw_payload,
         version=None,
         source_url=source_url,
@@ -670,17 +693,17 @@ def _matching_advisories(
 
 
 def _advisory_matches_target(advisory: dict[str, object], target: ProtectTarget) -> bool:
-    advisory_id = advisory.get("artifact_id")
-    if isinstance(advisory_id, str) and advisory_id == target.artifact_id:
-        return True
-    advisory_ecosystem = advisory.get("ecosystem")
-    if isinstance(advisory_ecosystem, str) and advisory_ecosystem not in {target.ecosystem, "*"}:
-        return False
-    advisory_package = advisory.get("package") or advisory.get("name")
-    if isinstance(advisory_package, str):
-        return advisory_package == target.package_name or advisory_package == target.artifact_name
-    advisory_publisher = advisory.get("publisher")
-    return isinstance(advisory_publisher, str) and advisory_publisher == target.package_name
+    return advisory_matches_target(
+        advisory,
+        ProtectTargetIdentity(
+            artifact_id=target.artifact_id,
+            artifact_name=target.artifact_name,
+            ecosystem=target.ecosystem,
+            package_name=target.package_name,
+            package_url=target.package_url,
+            source_url=target.source_url,
+        ),
+    )
 
 
 def _advisory_severity(advisory: dict[str, object]) -> SeverityLabel:

plugin_scanner-2.0.78/src/codex_plugin_scanner/guard/redaction.py

@@ -0,0 +1,93 @@
+"""Output redaction helpers for Guard command payloads."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RedactedText:
+    """Safe text plus minimal metadata about removed secrets."""
+
+    text: str
+    count: int
+    classifiers: tuple[str, ...]
+    original_sha256: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "count": self.count,
+            "classifiers": list(self.classifiers),
+            "original_sha256": self.original_sha256,
+        }
+
+
+_REDACTION_PATTERNS: tuple[tuple[str, re.Pattern[str], str], ...] = (
+    (
+        "bearer-token",
+        re.compile(r"(?i)\b(Bearer)\s+([A-Za-z0-9._\-]{8,})"),
+        r"\1 *****",
+    ),
+    (
+        "github-token",
+        re.compile(r"\bgh[pousr]_[A-Za-z0-9_]{8,}\b"),
+        "gh*****",
+    ),
+    (
+        "aws-access-key",
+        re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
+        "AKIA****************",
+    ),
+    (
+        "npm-token",
+        re.compile(r"(?im)\b(_authToken|npm[_ -]?token)\s*[:=]\s*([^\s]+)"),
+        r"\1=*****",
+    ),
+    (
+        "private-key",
+        re.compile(
+            r"-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----.*?-----END [A-Z0-9 ]*PRIVATE KEY-----",
+            re.DOTALL,
+        ),
+        "-----BEGIN PRIVATE KEY-----\n*****\n-----END PRIVATE KEY-----",
+    ),
+    (
+        "secret-env",
+        re.compile(
+            r"(?im)^([ \t]*)([A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|KEY|CREDENTIAL)[A-Z0-9_]*)=(.+)$",
+        ),
+        r"\1\2=*****",
+    ),
+    (
+        "connection-env",
+        re.compile(r"(?im)^([ \t]*)([A-Z0-9_]*(?:URL|URI|DSN))=([A-Za-z][A-Za-z0-9+.-]*://.+)$"),
+        r"\1\2=*****",
+    ),
+    (
+        "connection-string",
+        re.compile(r"\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp)://[^\s]+", re.IGNORECASE),
+        "*****",
+    ),
+)
+
+
+def redact_text(value: str) -> RedactedText:
+    """Redact common secret-like values before Guard prints or syncs them."""
+
+    redacted_value = value
+    classifiers: list[str] = []
+    total_count = 0
+    for classifier, pattern, replacement in _REDACTION_PATTERNS:
+        redacted_value, match_count = pattern.subn(replacement, redacted_value)
+        if match_count == 0:
+            continue
+        classifiers.extend([classifier] * match_count)
+        total_count += match_count
+    return RedactedText(
+        text=redacted_value,
+        count=total_count,
+        classifiers=tuple(dict.fromkeys(classifiers)),
+        original_sha256=hashlib.sha256(value.encode("utf-8")).hexdigest(),
+    )

{plugin_scanner-2.0.77 → plugin_scanner-2.0.78}/src/codex_plugin_scanner/version.py

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