plugin-scanner 2.0.999__tar.gz → 2.0.1001__tar.gz

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.999
+Version: 2.0.1001
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.999"
+version = "2.0.1001"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.999"
+version = "2.0.1001"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/src/codex_plugin_scanner/guard/approvals.py

@@ -34,6 +34,7 @@ from .desktop_notifications import (
 from .incident import build_incident_context
 from .local_dashboard_session import build_local_dashboard_session_token
 from .local_supply_chain import build_local_supply_chain_posture
+from .memory_decision_outbox import enqueue_memory_decision_event
 from .models import (
     DECISION_SCOPE_VALUES,
     GUARD_ACTION_VALUES,
@@ -852,6 +853,41 @@ def _record_resolution_event(
         },
         resolved_at,
     )
+    _enqueue_memory_decision_for_resolution(
+        store,
+        request_id=request_id,
+        action=action,
+        scope=scope,
+        resolved_at=resolved_at,
+    )
+
+
+def _enqueue_memory_decision_for_resolution(
+    store: GuardStore,
+    *,
+    request_id: str,
+    action: str,
+    scope: str,
+    resolved_at: str,
+) -> None:
+    """Feed the local-to-cloud memory candidate pipeline for this decision.
+
+    Defensive by design: a missing request, missing cloud pairing, or any store
+    error must never break the local approval that already succeeded.
+    """
+    try:
+        request = store.get_approval_request(request_id)
+    except Exception:
+        request = None
+    if not request:
+        return
+    enqueue_memory_decision_event(
+        store,
+        request=request,
+        action=action,
+        scope=scope,
+        resolved_at=resolved_at,
+    )
 
 
 def _record_created_event(store: GuardStore, request: GuardApprovalRequest, created_at: str) -> None:

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/src/codex_plugin_scanner/guard/cli/commands_support_runtime_policy.py

@@ -132,6 +132,7 @@ def _native_approval_center_context(response_payload: dict[str, object], *, harn
         "bundle",
         "mvn",
         "gradle",
+        "brew",
     }:
         harness_label = "package install"
     return (

{plugin_scanner-2.0.999 → plugin_scanner-2.0.1001}/src/codex_plugin_scanner/guard/edge_events.py

@@ -64,6 +64,33 @@ def build_approval_event(
     )
 
 
+def build_memory_decision_event_envelope(
+    *,
+    request_id: str,
+    decision_action: str,
+    occurred_at: str,
+    payload: dict[str, object],
+    device_id: str | None = None,
+    workspace_id: str | None = None,
+) -> GuardEventV1:
+    """Wrap a memory decision payload in the v1 cloud event envelope.
+
+    The event id and idempotency key include the decision action so an approve
+    and a block on the same request at the same instant stay distinct.
+    """
+    fingerprint = _fingerprint("approval.memory_decision", request_id, decision_action, occurred_at)
+    return GuardEventV1(
+        event_id=f"guard-event-{fingerprint[:32]}",
+        idempotency_key=f"approval.memory_decision:{request_id}:{decision_action}:{occurred_at}",
+        event_type="approval.memory_decision",
+        source="approval-center",
+        occurred_at=occurred_at,
+        workspace_id=workspace_id,
+        device_id=device_id,
+        payload=payload,
+    )
+
+
 def build_policy_event(
     *,
     policy_key: str,

plugin_scanner-2.0.1001/src/codex_plugin_scanner/guard/memory_decision_event.py

@@ -0,0 +1,234 @@
+"""``GuardMemoryDecisionEventV1`` — durable local-to-cloud decision event.
+
+A memory decision event records one concrete human choice (approve, block, or
+keep-asking dismissal) so HOL Guard Cloud can build a Suggested Memory candidate
+from *repeated* choices. This is the missing first-class pipeline: previously
+local approvals lived only in local SQLite and never reached Cloud as decision
+evidence, so Suggested Memory had nothing durable to read.
+
+Contract version: ``guard.memory-decision.v1``. Events are enqueued into the
+existing ``guard_cloud_events`` outbox and synced via the existing platform
+event transport — no new outbox table or auth path.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass, field
+from typing import Literal
+
+from .memory_pattern_fingerprint import (
+    build_memory_pattern_fingerprint,
+)
+
+MEMORY_DECISION_EVENT_CONTRACT_VERSION = "guard.memory-decision.v1"
+
+MemoryDecisionAction = Literal["approved", "blocked", "dismissed_keep_asking"]
+MemoryDecisionSource = Literal[
+    "local_approval_center",
+    "cloud_review",
+    "headless_remote",
+]
+MemoryRedactionState = Literal["disabled", "enabled", "withheld"]
+
+
+@dataclass(frozen=True, slots=True)
+class GuardMemoryDecisionEventV1:
+    """One human decision that may later contribute to a memory candidate."""
+
+    event_id: str
+    event_schema_version: str
+    owner_user_id: str | None
+    workspace_id: str | None
+    device_id: str | None
+    machine_id: str | None
+    machine_installation_id: str | None
+    harness_id: str | None
+    project_id: str | None
+    request_id: str
+    queue_group_id: str | None
+    action_identity: str | None
+    decision_action: MemoryDecisionAction
+    decision_scope: str
+    decision_source: MemoryDecisionSource
+    decision_reason: str | None
+    occurred_at: str
+    command_display: str
+    command_raw: str | None
+    redaction_state: MemoryRedactionState
+    artifact_type: str | None
+    artifact_id: str | None
+    artifact_name: str | None
+    risk_summary: str | None
+    risk_signals: tuple[str, ...] = ()
+    source_receipt_id: str | None = None
+    source_receipt_hash: str | None = None
+    memory_pattern_fingerprint: str | None = None
+    memory_pattern_kind: str | None = None
+    memory_pattern_components: dict[str, str] = field(default_factory=dict)
+
+    def to_payload(self) -> dict[str, object]:
+        payload = asdict(self)
+        payload["event_schema_version"] = self.event_schema_version
+        payload["risk_signals"] = list(self.risk_signals)
+        payload["memory_pattern_components"] = dict(self.memory_pattern_components)
+        return payload
+
+
+def resolve_redaction_state(
+    *,
+    raw_command: str | None,
+    redaction_enabled: bool,
+) -> MemoryRedactionState:
+    """Pick the safest redaction state for the command evidence."""
+    if not raw_command:
+        return "withheld"
+    return "enabled" if redaction_enabled else "disabled"
+
+
+def resolve_command_display(
+    *,
+    review_command: str | None,
+    raw_command: str | None,
+    redaction_state: MemoryRedactionState,
+) -> str:
+    """Return the human-facing command text honoring the redaction policy."""
+    if redaction_state == "withheld":
+        return review_command or "Command withheld"
+    if redaction_state == "enabled":
+        return review_command or "Command redacted"
+    return raw_command or review_command or "Command unavailable"
+
+
+def build_memory_decision_event(
+    *,
+    request: Mapping[str, object],
+    action: str,
+    scope: str,
+    resolved_at: str,
+    owner_user_id: str | None = None,
+    workspace_id: str | None = None,
+    device_id: str | None = None,
+    machine_id: str | None = None,
+    machine_installation_id: str | None = None,
+    source: MemoryDecisionSource = "local_approval_center",
+    redaction_enabled: bool = False,
+    source_receipt_id: str | None = None,
+    source_receipt_hash: str | None = None,
+) -> GuardMemoryDecisionEventV1 | None:
+    """Build a decision event from a resolved approval request mapping.
+
+    Returns ``None`` when the request lacks the minimum signal (request id,
+    command, or artifact) to anchor a future memory candidate. Callers treat
+    ``None`` as "this decision does not contribute to memory" and skip the
+    outbox write rather than emitting a useless event.
+    """
+    request_id = _string_or_none(request.get("request_id"))
+    if not request_id:
+        return None
+
+    review_command = _string_or_none(request.get("review_command"))
+    raw_command = _string_or_none(request.get("raw_command_text"))
+    artifact_id = _string_or_none(request.get("artifact_id"))
+    artifact_name = _string_or_none(request.get("artifact_name"))
+    artifact_type = _string_or_none(request.get("artifact_type"))
+    harness = _string_or_none(request.get("harness"))
+
+    redaction_state = resolve_redaction_state(
+        raw_command=raw_command,
+        redaction_enabled=redaction_enabled,
+    )
+    command_display = resolve_command_display(
+        review_command=review_command,
+        raw_command=raw_command,
+        redaction_state=redaction_state,
+    )
+
+    # Build the fingerprint from the real command when redaction permits it.
+    # When raw_command is withheld, do NOT fall back to review_command: that
+    # field commonly holds the approval wrapper ("hol-guard approvals approve
+    # <id>") which would produce an over-broad, useless command fingerprint.
+    # Fall back to artifact identity only.
+    fingerprint_command = raw_command if redaction_state != "withheld" else None
+    pattern = build_memory_pattern_fingerprint(
+        command=fingerprint_command,
+        artifact_type=artifact_type,
+        artifact_id=artifact_id,
+        artifact_name=artifact_name,
+        harness=harness,
+    )
+
+    decision_action = _normalize_decision_action(action)
+    if decision_action is None:
+        return None
+
+    return GuardMemoryDecisionEventV1(
+        event_id=_event_id(request_id, decision_action, resolved_at),
+        event_schema_version=MEMORY_DECISION_EVENT_CONTRACT_VERSION,
+        owner_user_id=owner_user_id,
+        workspace_id=workspace_id,
+        device_id=device_id,
+        machine_id=machine_id,
+        machine_installation_id=machine_installation_id,
+        harness_id=harness,
+        project_id=_string_or_none(request.get("project_id")),
+        request_id=request_id,
+        queue_group_id=_string_or_none(request.get("queue_group_id")),
+        action_identity=_string_or_none(request.get("action_identity")),
+        decision_action=decision_action,
+        decision_scope=scope,
+        decision_source=source,
+        decision_reason=_string_or_none(request.get("resolution_reason")) or _string_or_none(request.get("reason")),
+        occurred_at=resolved_at,
+        command_display=command_display,
+        command_raw=raw_command if redaction_state == "disabled" else None,
+        redaction_state=redaction_state,
+        artifact_type=artifact_type,
+        artifact_id=artifact_id,
+        artifact_name=artifact_name,
+        risk_summary=_string_or_none(request.get("risk_summary")) or _string_or_none(request.get("risk_headline")),
+        risk_signals=_risk_signals(request),
+        source_receipt_id=source_receipt_id,
+        source_receipt_hash=source_receipt_hash,
+        memory_pattern_fingerprint=pattern.fingerprint if pattern else None,
+        memory_pattern_kind=pattern.kind if pattern else None,
+        memory_pattern_components=dict(pattern.components) if pattern else {},
+    )
+
+
+def event_to_cloud_payload(event: GuardMemoryDecisionEventV1) -> dict[str, object]:
+    """Wrap a decision event as the ``payload`` of a GuardEventV1 envelope."""
+    payload = event.to_payload()
+    payload["contractVersion"] = MEMORY_DECISION_EVENT_CONTRACT_VERSION
+    return payload
+
+
+def _normalize_decision_action(action: str) -> MemoryDecisionAction | None:
+    normalized = action.strip().lower()
+    if normalized in {"approve", "approved", "allow", "allowed"}:
+        return "approved"
+    if normalized in {"block", "blocked", "deny", "denied", "reject", "rejected"}:
+        return "blocked"
+    if normalized in {"dismiss", "dismissed", "keep_asking", "keep-asking"}:
+        return "dismissed_keep_asking"
+    return None
+
+
+def _string_or_none(value: object) -> str | None:
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def _risk_signals(request: Mapping[str, object]) -> tuple[str, ...]:
+    raw = request.get("risk_signals")
+    if isinstance(raw, (list, tuple)):
+        return tuple(str(item).strip() for item in raw if str(item).strip())
+    return ()
+
+
+def _event_id(request_id: str, action: MemoryDecisionAction, occurred_at: str) -> str:
+    import hashlib
+
+    digest = hashlib.sha256(f"memory_decision:{request_id}:{action}:{occurred_at}".encode()).hexdigest()
+    return f"guard-memory-decision-{digest[:32]}"

plugin_scanner-2.0.1001/src/codex_plugin_scanner/guard/memory_decision_outbox.py

@@ -0,0 +1,168 @@
+"""Enqueue memory decision events into the local cloud outbox.
+
+Local Guard approvals and denials previously lived only in local SQLite. This
+module is the missing seam that turns a resolved approval request into a
+``guard.memory-decision.v1`` event in the existing ``guard_cloud_events``
+outbox, so the decision can reach HOL Guard Cloud and become a Suggested Memory
+candidate.
+
+Everything here is defensive: if cloud pairing is absent, the store lacks the
+outbox, or the request has no command/artifact signal, the enqueue is a no-op.
+Local approvals must never fail because the cloud candidate pipeline is not
+ready.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping
+from typing import Any
+
+from .edge_events import build_memory_decision_event_envelope
+from .memory_decision_event import (
+    MemoryDecisionSource,
+    build_memory_decision_event,
+    event_to_cloud_payload,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def enqueue_memory_decision_event(
+    store: Any,
+    *,
+    request: Mapping[str, object],
+    action: str,
+    scope: str,
+    resolved_at: str,
+    source: MemoryDecisionSource = "local_approval_center",
+) -> bool:
+    """Build and enqueue a memory decision event. Returns True if enqueued.
+
+    ``store`` is a ``GuardStore`` but typed as ``Any`` here to avoid an import
+    cycle (GuardStore imports this module's callers). Returns False on any
+    non-fatal miss (no cloud pairing, no usable signal, outbox unavailable).
+    """
+    try:
+        workspace_id = _resolve_workspace_id(store)
+        device_id, machine_installation_id = _resolve_device_metadata(store)
+        owner_user_id = _resolve_owner_user_id(store)
+        machine_id = _resolve_oauth_machine_id(store) or machine_installation_id
+        redaction_enabled = _resolve_redaction_enabled(store)
+
+        event = build_memory_decision_event(
+            request=request,
+            action=action,
+            scope=scope,
+            resolved_at=resolved_at,
+            owner_user_id=owner_user_id,
+            workspace_id=workspace_id,
+            device_id=device_id,
+            machine_id=machine_id,
+            machine_installation_id=machine_installation_id,
+            source=source,
+            redaction_enabled=redaction_enabled,
+        )
+        if event is None:
+            return False
+
+        envelope = build_memory_decision_event_envelope(
+            request_id=event.request_id,
+            decision_action=event.decision_action,
+            occurred_at=event.occurred_at,
+            payload=event_to_cloud_payload(event),
+            device_id=device_id,
+            workspace_id=workspace_id,
+        )
+        add_guard_event_v1 = getattr(store, "add_guard_event_v1", None)
+        if add_guard_event_v1 is None:
+            return False
+        add_guard_event_v1(envelope)
+        return True
+    except Exception as error:
+        _LOGGER.debug("memory decision event enqueue skipped: %s", error)
+        return False
+
+
+def _resolve_workspace_id(store: Any) -> str | None:
+    getter = getattr(store, "get_cloud_workspace_id", None)
+    if callable(getter):
+        try:
+            value = getter()
+        except Exception:
+            return None
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def _resolve_device_metadata(store: Any) -> tuple[str | None, str | None]:
+    getter = getattr(store, "get_device_metadata", None)
+    if not callable(getter):
+        return None, None
+    try:
+        metadata = getter()
+    except Exception:
+        return None, None
+    if not isinstance(metadata, Mapping):
+        return None, None
+    installation_id = metadata.get("installation_id")
+    device_id = installation_id if isinstance(installation_id, str) and installation_id.strip() else None
+    machine_installation_id = device_id
+    return device_id, machine_installation_id
+
+
+def _resolve_owner_user_id(store: Any) -> str | None:
+    credentials = _oauth_credentials(store)
+    if not credentials:
+        return None
+    for key in ("user_id", "owner_user_id", "userId", "ownerUserId"):
+        value = credentials.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def _resolve_oauth_machine_id(store: Any) -> str | None:
+    """Return the OAuth grant's machine id, distinct from the installation id.
+
+    The installation id (from device metadata) and the OAuth machine id can
+    differ; the OAuth credential payload carries the real machine id seeded at
+    connect time. Falls back to None so callers can default to the installation
+    id.
+    """
+    credentials = _oauth_credentials(store)
+    if not credentials:
+        return None
+    value = credentials.get("machine_id")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def _resolve_redaction_enabled(store: Any) -> bool:
+    config_getter = getattr(store, "get_sync_payload", None)
+    if not callable(config_getter):
+        return False
+    try:
+        payload = config_getter("guard_redaction_policy")
+    except Exception:
+        return False
+    if isinstance(payload, Mapping):
+        value = payload.get("command_redaction_enabled")
+        if isinstance(value, bool):
+            return value
+    return False
+
+
+def _oauth_credentials(store: Any) -> Mapping[str, object] | None:
+    getter = getattr(store, "get_oauth_local_credentials", None)
+    if not callable(getter):
+        return None
+    try:
+        credentials = getter()
+    except Exception:
+        return None
+    if isinstance(credentials, Mapping):
+        return credentials
+    return None