plugin-scanner 2.0.103__tar.gz → 2.0.105__tar.gz

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/PKG-INFO

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

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

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/pyproject.toml.bak

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

@@ -1043,10 +1043,12 @@ def run_guard_command(
         if args.harness:
             adapter = get_adapter(args.harness)
             payload = adapter.diagnostics(context)
+            payload["runtime_detector_registry"] = _runtime_detector_registry_payload(config)
         else:
             payload = {
                 "tables": store.list_table_names(),
                 "adapters": [detection.to_dict() for detection in detect_all(context)],
+                "runtime_detector_registry": _runtime_detector_registry_payload(config),
             }
         _emit("doctor", payload, getattr(args, "json", False))
         return 0
@@ -3049,6 +3051,15 @@ def _guard_cli_settings_payload(config: GuardConfig) -> dict[str, object]:
     }
 
 
+def _runtime_detector_registry_payload(config: GuardConfig) -> dict[str, object]:
+    return {
+        "enabled": config.runtime_detector_registry,
+        "debug_trace": config.runtime_detector_debug_trace,
+        "timeout_ms": config.runtime_detector_timeout_ms,
+        "disabled_detector_ids": list(config.runtime_detector_disabled_ids),
+    }
+
+
 def _update_guard_cli_settings(*, args: argparse.Namespace, config: GuardConfig, guard_home: Path) -> GuardConfig:
     settings_command = getattr(args, "settings_set_command", None)
     if settings_command == "security-level":

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/src/codex_plugin_scanner/guard/cli/render.py

@@ -293,6 +293,11 @@ def _render_doctor(console: Console, payload: dict[str, object]) -> None:
     summary.add_row("Installed", _bool_label(bool(payload.get("installed"))))
     summary.add_row("Command", _bool_label(bool(payload.get("command_available"))))
     summary.add_row("Artifacts", str(len(_coerce_dict_list(payload.get("artifacts")))))
+    registry = payload.get("runtime_detector_registry")
+    if isinstance(registry, dict):
+        registry_state = "enabled" if bool(registry.get("enabled")) else "disabled"
+        timeout_ms = registry.get("timeout_ms")
+        summary.add_row("Detector registry", f"{registry_state}, {timeout_ms} ms")
     summary.add_row("Warnings", str(len(warnings)))
     console.print(Panel(summary, title="Guard doctor", border_style="cyan"))
     if warnings:

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/src/codex_plugin_scanner/guard/config.py

@@ -176,6 +176,10 @@ class GuardConfig:
     telemetry: bool = False
     sync: bool = False
     billing: bool = False
+    runtime_detector_registry: bool = False
+    runtime_detector_timeout_ms: int = 50
+    runtime_detector_debug_trace: bool = False
+    runtime_detector_disabled_ids: tuple[str, ...] = ()
     risk_actions: dict[str, GuardAction] | None = None
     harness_risk_actions: dict[str, dict[str, GuardAction]] | None = None
     harness_actions: dict[str, GuardAction] | None = None
@@ -252,6 +256,10 @@ def load_guard_config(guard_home: Path, workspace: Path | None = None) -> GuardC
         telemetry=bool(merged.get("telemetry", False)),
         sync=bool(merged.get("sync", False)),
         billing=bool(merged.get("billing", False)),
+        runtime_detector_registry=_coerce_loaded_bool(merged.get("runtime_detector_registry", False)),
+        runtime_detector_timeout_ms=_coerce_loaded_positive_int(merged.get("runtime_detector_timeout_ms", 50), 50),
+        runtime_detector_debug_trace=_coerce_loaded_bool(merged.get("runtime_detector_debug_trace", False)),
+        runtime_detector_disabled_ids=_coerce_loaded_string_tuple(merged.get("runtime_detector_disabled_ids")),
         harness_actions=_coerce_action_map(merged.get("harnesses")),
         publisher_actions=_coerce_action_map(merged.get("publishers")),
         artifact_actions=_coerce_action_map(merged.get("artifacts")),
@@ -346,6 +354,22 @@ def _coerce_loaded_security_level(value: object) -> str:
     return DEFAULT_SECURITY_LEVEL
 
 
+def _coerce_loaded_bool(value: object) -> bool:
+    return value if isinstance(value, bool) else False
+
+
+def _coerce_loaded_positive_int(value: object, fallback: int) -> int:
+    if isinstance(value, int) and not isinstance(value, bool) and value > 0:
+        return value
+    return fallback
+
+
+def _coerce_loaded_string_tuple(value: object) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        return ()
+    return tuple(item for item in value if isinstance(item, str) and item.strip())
+
+
 def _coerce_risk_action_payload(value: object) -> dict[str, GuardAction]:
     if not isinstance(value, dict):
         raise ValueError("Risk actions must be a table.")

plugin_scanner-2.0.105/src/codex_plugin_scanner/guard/runtime/detectors.py

@@ -0,0 +1,148 @@
+"""Runtime detector registry primitives for Guard actions."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal, Protocol
+
+from codex_plugin_scanner.guard.config import GuardConfig
+from codex_plugin_scanner.guard.runtime.actions import GuardActionEnvelope
+from codex_plugin_scanner.guard.runtime.signals import RiskSignalCategory, RiskSignalV2
+
+DETECTOR_CATEGORY_TAGS: tuple[RiskSignalCategory, ...] = (
+    "secret",
+    "network",
+    "prompt",
+    "mcp",
+    "skill",
+    "supply_chain",
+    "encoded",
+    "persistence",
+    "bypass",
+    "false_positive",
+)
+DetectorRunStatus = Literal["ok", "disabled", "filtered", "timeout", "error"]
+
+
+@dataclass(frozen=True, slots=True)
+class DetectorContext:
+    """Context shared with runtime detectors."""
+
+    config: GuardConfig
+    workspace: Path | None
+    prior_decisions: Mapping[str, object]
+    threat_intel: Mapping[str, object]
+    redaction_settings: Mapping[str, object]
+
+
+class GuardDetector(Protocol):
+    """Detector interface for runtime Guard actions."""
+
+    detector_id: str
+    categories: tuple[RiskSignalCategory, ...]
+
+    def detect(self, action: GuardActionEnvelope, context: DetectorContext) -> tuple[RiskSignalV2, ...]:
+        """Return typed risk signals for the runtime action."""
+
+
+@dataclass(frozen=True, slots=True)
+class DetectorTelemetry:
+    """Debug-safe detector execution telemetry."""
+
+    detector_id: str
+    categories: tuple[RiskSignalCategory, ...]
+    status: DetectorRunStatus
+    elapsed_ms: int
+    error_type: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "detector_id": self.detector_id,
+            "categories": list(self.categories),
+            "status": self.status,
+            "elapsed_ms": self.elapsed_ms,
+            "error_type": self.error_type,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class DetectorRunResult:
+    """Signals and telemetry produced by a registry run."""
+
+    signals: tuple[RiskSignalV2, ...]
+    telemetry: tuple[DetectorTelemetry, ...]
+
+
+class DetectorRegistry:
+    """Runs detectors in deterministic order with failure isolation."""
+
+    def __init__(
+        self,
+        detectors: Iterable[GuardDetector],
+        *,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        self._detectors = tuple(sorted(detectors, key=lambda detector: detector.detector_id))
+        self._clock = clock or time.monotonic
+
+    def run(
+        self,
+        action: GuardActionEnvelope,
+        context: DetectorContext,
+        *,
+        timeout_ms: int = 50,
+        disabled_detector_ids: Sequence[str] = (),
+        enabled_categories: Sequence[RiskSignalCategory] | None = None,
+    ) -> DetectorRunResult:
+        disabled_ids = frozenset(disabled_detector_ids)
+        category_filter = frozenset(enabled_categories) if enabled_categories is not None else None
+        signals: list[RiskSignalV2] = []
+        telemetry: list[DetectorTelemetry] = []
+        for detector in self._detectors:
+            if detector.detector_id in disabled_ids:
+                telemetry.append(_telemetry(detector, "disabled", elapsed_ms=0))
+                continue
+            if category_filter is not None and not category_filter.intersection(detector.categories):
+                telemetry.append(_telemetry(detector, "filtered", elapsed_ms=0))
+                continue
+            started_at = self._clock()
+            try:
+                detector_signals = detector.detect(action, context)
+                elapsed_ms = _elapsed_ms(started_at, self._clock())
+            except Exception as error:
+                elapsed_ms = _elapsed_ms(started_at, self._clock())
+                telemetry.append(_telemetry(detector, "error", elapsed_ms=elapsed_ms, error_type=type(error).__name__))
+                continue
+            if elapsed_ms > timeout_ms:
+                telemetry.append(_telemetry(detector, "timeout", elapsed_ms=elapsed_ms))
+                continue
+            signals.extend(detector_signals)
+            telemetry.append(_telemetry(detector, "ok", elapsed_ms=elapsed_ms))
+        return DetectorRunResult(signals=tuple(signals), telemetry=tuple(telemetry))
+
+
+def register_default_detectors() -> tuple[GuardDetector, ...]:
+    return ()
+
+
+def _elapsed_ms(started_at: float, finished_at: float) -> int:
+    return max(0, round((finished_at - started_at) * 1000))
+
+
+def _telemetry(
+    detector: GuardDetector,
+    status: DetectorRunStatus,
+    *,
+    elapsed_ms: int,
+    error_type: str | None = None,
+) -> DetectorTelemetry:
+    return DetectorTelemetry(
+        detector_id=detector.detector_id,
+        categories=detector.categories,
+        status=status,
+        elapsed_ms=elapsed_ms,
+        error_type=error_type,
+    )

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/src/codex_plugin_scanner/guard/runtime/runner.py

@@ -26,6 +26,7 @@ from ..models import GuardArtifact, HarnessDetection, PolicyDecision
 from ..store import GuardStore
 from ..types import PromptRequest, RemediationAction
 from .actions import GuardActionEnvelope, redacted_workspace_label
+from .detectors import DetectorContext, DetectorRegistry, DetectorRunResult, register_default_detectors
 
 _APPROVAL_METADATA_KEYS = (
     "approval_center_url",
@@ -251,6 +252,12 @@ def guard_run(
             if key in pending_evaluation:
                 reevaluated[key] = pending_evaluation[key]
         evaluation = reevaluated
+    evaluation = _evaluation_with_detector_registry(
+        evaluation,
+        action_envelope,
+        context,
+        config,
+    )
     if "config_paths" not in evaluation:
         evaluation["config_paths"] = list(detection.config_paths) or _guard_run_config_paths(
             detection=detection,
@@ -337,6 +344,86 @@ def _evaluation_with_action_envelope(
     return {**evaluation, "artifacts": normalized_artifacts}
 
 
+def _evaluation_with_detector_registry(
+    evaluation: dict[str, Any],
+    action_envelope: GuardActionEnvelope,
+    context: HarnessContext,
+    config: GuardConfig,
+) -> dict[str, Any]:
+    if not config.runtime_detector_registry:
+        return evaluation
+    detector_context = DetectorContext(
+        config=config,
+        workspace=context.workspace_dir,
+        prior_decisions={},
+        threat_intel={},
+        redaction_settings={},
+    )
+    result = DetectorRegistry(register_default_detectors()).run(
+        action_envelope,
+        detector_context,
+        timeout_ms=config.runtime_detector_timeout_ms,
+        disabled_detector_ids=config.runtime_detector_disabled_ids,
+    )
+    trace_error = (
+        _write_detector_debug_trace(config, action_envelope, result) if config.runtime_detector_debug_trace else None
+    )
+    if not result.signals and not result.telemetry:
+        if trace_error is None:
+            return evaluation
+        return {**evaluation, "runtime_detector_trace_error": trace_error}
+    next_evaluation = {
+        **evaluation,
+        "runtime_detector_signals_v2": [signal.to_dict() for signal in result.signals],
+        "runtime_detector_telemetry": [item.to_dict() for item in result.telemetry],
+    }
+    if trace_error is not None:
+        next_evaluation["runtime_detector_trace_error"] = trace_error
+    return next_evaluation
+
+
+def _write_detector_debug_trace(
+    config: GuardConfig,
+    action_envelope: GuardActionEnvelope,
+    result: DetectorRunResult,
+) -> dict[str, object] | None:
+    created_at = datetime.now(timezone.utc)
+    action_payload = action_envelope.to_dict()
+    trace_payload = {
+        "schema_version": 1,
+        "created_at": created_at.isoformat(),
+        "action": _redact_detector_debug_payload(action_payload),
+        "signals": [signal.to_dict() for signal in result.signals],
+        "telemetry": [item.to_dict() for item in result.telemetry],
+    }
+    trace_dir = config.guard_home / "debug" / "detectors"
+    action_digest = hashlib.sha256(
+        json.dumps(action_payload, sort_keys=True, default=str).encode("utf-8"),
+    ).hexdigest()[:12]
+    trace_path = trace_dir / f"{created_at.strftime('%Y%m%dT%H%M%S%fZ')}-{action_digest}.json"
+    try:
+        trace_dir.mkdir(parents=True, exist_ok=True)
+        trace_path.write_text(json.dumps(trace_payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    except OSError as error:
+        return {"error_type": type(error).__name__, "message": str(error)}
+    return None
+
+
+def _redact_detector_debug_payload(value: object) -> object:
+    if isinstance(value, dict):
+        redacted: dict[str, object] = {}
+        for key, item in value.items():
+            key_text = str(key)
+            if "prompt" in key_text.lower():
+                redacted[key_text] = "[redacted]"
+            else:
+                redacted[key_text] = _redact_detector_debug_payload(item)
+        return redacted
+    if isinstance(value, (tuple, list)):
+        return [_redact_detector_debug_payload(item) for item in value]
+    return value
+
+
 def _guard_run_config_paths(
     *,
     detection: HarnessDetection,

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/tests/test_guard_cli.py

@@ -3962,6 +3962,46 @@ args = ["-lc", "echo hi"]
         assert any("native hooks are disabled" in warning for warning in output["warnings"])
         assert any("managed Codex hooks are missing" in warning for warning in output["warnings"])
 
+    def test_guard_doctor_reports_runtime_detector_registry_state(self, tmp_path, monkeypatch, capsys):
+        home_dir = tmp_path / "home"
+        guard_home = tmp_path / "guard-home"
+        _write_text(
+            guard_home / "config.toml",
+            "\n".join(
+                [
+                    "runtime_detector_registry = true",
+                    "runtime_detector_timeout_ms = 75",
+                    'runtime_detector_disabled_ids = ["secret.local"]',
+                ]
+            )
+            + "\n",
+        )
+        monkeypatch.setattr("codex_plugin_scanner.guard.adapters.codex._command_available", lambda command: True)
+
+        rc = main(["guard", "doctor", "codex", "--home", str(home_dir), "--guard-home", str(guard_home), "--json"])
+        output = json.loads(capsys.readouterr().out)
+
+        assert rc == 0
+        assert output["runtime_detector_registry"] == {
+            "enabled": True,
+            "debug_trace": False,
+            "timeout_ms": 75,
+            "disabled_detector_ids": ["secret.local"],
+        }
+
+    def test_guard_doctor_human_output_includes_detector_registry_line(self, tmp_path, monkeypatch, capsys):
+        home_dir = tmp_path / "home"
+        guard_home = tmp_path / "guard-home"
+        _write_text(guard_home / "config.toml", "runtime_detector_registry = true\n")
+        monkeypatch.setattr("codex_plugin_scanner.guard.adapters.codex._command_available", lambda command: True)
+
+        rc = main(["guard", "doctor", "codex", "--home", str(home_dir), "--guard-home", str(guard_home)])
+        output = capsys.readouterr().out
+
+        assert rc == 0
+        assert "Detector registry" in output
+        assert "enabled" in output
+
     def test_guard_codex_hook_blocks_shell_file_upload_script(self, tmp_path, capsys):
         home_dir = tmp_path / "home"
         workspace_dir = tmp_path / "workspace"

{plugin_scanner-2.0.103 → plugin_scanner-2.0.105}/tests/test_guard_config_paths.py

@@ -110,6 +110,29 @@ def test_guard_config_loads_security_level_and_risk_action_overrides(tmp_path):
     assert resolve_risk_action(config, "credential_exfiltration", harness="codex") == "block"
 
 
+def test_load_guard_config_parses_hidden_runtime_detector_registry(tmp_path):
+    guard_home = tmp_path / ".hol-guard"
+    _write_text(
+        guard_home / "config.toml",
+        "\n".join(
+            [
+                "runtime_detector_registry = true",
+                "runtime_detector_timeout_ms = 75",
+                "runtime_detector_debug_trace = true",
+                'runtime_detector_disabled_ids = ["secret.local"]',
+            ]
+        )
+        + "\n",
+    )
+
+    config = load_guard_config(guard_home)
+
+    assert config.runtime_detector_registry is True
+    assert config.runtime_detector_timeout_ms == 75
+    assert config.runtime_detector_debug_trace is True
+    assert config.runtime_detector_disabled_ids == ("secret.local",)
+
+
 def test_guard_config_strict_profile_defaults_review_sensitive_risks(tmp_path):
     guard_home = tmp_path / ".hol-guard"
     _write_text(guard_home / "config.toml", 'security_level = "strict"\n')