plugin-scanner 2.0.132__tar.gz → 2.0.134__tar.gz

{plugin_scanner-2.0.132 → plugin_scanner-2.0.134}/PKG-INFO

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

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

{plugin_scanner-2.0.132 → plugin_scanner-2.0.134}/pyproject.toml.bak

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

@@ -24,6 +24,14 @@ GUARD_FLEET_URL = f"{GUARD_DASHBOARD_URL}/fleet"
 GUARD_CONNECT_URL = f"{GUARD_DASHBOARD_URL}/connect"
 
 
+class ApprovalRequestNotFoundError(ValueError):
+    """Raised when an approval request ID does not exist."""
+
+
+class ApprovalRequestAlreadyResolvedError(ValueError):
+    """Raised when an approval request was already resolved."""
+
+
 def queue_blocked_approvals(
     *,
     detection: HarnessDetection,
@@ -114,9 +122,9 @@ def apply_approval_resolution(
 ) -> dict[str, object]:
     request = store.get_approval_request(request_id)
     if request is None:
-        raise ValueError(f"Unknown approval request: {request_id}")
+        raise ApprovalRequestNotFoundError(f"Unknown approval request: {request_id}")
     if request["status"] != "pending":
-        raise ValueError(f"Approval request already resolved: {request_id}")
+        raise ApprovalRequestAlreadyResolvedError(f"Approval request already resolved: {request_id}")
     if scope == "workspace" and not workspace:
         raise ValueError(f"Approval request {request_id} requires --workspace for workspace scope.")
     if scope == "publisher" and not isinstance(request.get("publisher"), str):

{plugin_scanner-2.0.132 → plugin_scanner-2.0.134}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -18,7 +18,12 @@ from typing import Any
 from urllib.parse import parse_qs, parse_qsl, unquote, urlencode, urlparse, urlunparse
 
 from ...version import __version__
-from ..approvals import apply_approval_resolution, build_runtime_snapshot
+from ..approvals import (
+    ApprovalRequestAlreadyResolvedError,
+    ApprovalRequestNotFoundError,
+    apply_approval_resolution,
+    build_runtime_snapshot,
+)
 from ..config import editable_guard_settings, load_guard_config, update_guard_settings
 from ..models import DECISION_SCOPE_VALUES, GUARD_ACTION_VALUES
 from ..runtime.surface_server import GuardSurfaceRuntime
@@ -183,7 +188,17 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         if len(path_parts) == 3 and path_parts[:2] == ["v1", "requests"]:
             approval = store.get_approval_request(path_parts[2])
             if approval is None:
-                self._write_json({"error": "not_found"}, status=404)
+                self._write_json(
+                    {
+                        "error": "not_found",
+                        "recovery": {
+                            "code": "request_unknown",
+                            "title": "This request is no longer waiting.",
+                            "body": "The request was either already resolved or expired. You can close this tab.",
+                        },
+                    },
+                    status=404,
+                )
                 return
             self._write_json(approval)
             return
@@ -313,11 +328,29 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
             self._write_json({"error": "forbidden_origin"}, status=403)
             return
         if self._requires_header_token(parsed.path, path_parts) and not self._header_token_is_valid():
-            self._write_json(
-                {"error": "unauthorized"},
-                status=401,
-                extra_headers=self._cors_headers_for_request(),
-            )
+            if len(path_parts) == 4 and path_parts[:2] == ["v1", "requests"] and path_parts[3] in {"approve", "block"}:
+                host = self.server.server_address[0]  # type: ignore[attr-defined]
+                port = self.server.server_address[1]  # type: ignore[attr-defined]
+                reconnect_url = _build_local_url(host, port, "/#/reconnect")
+                self._write_json(
+                    {
+                        "error": "unauthorized",
+                        "recovery": {
+                            "code": "session_stale",
+                            "title": "Your session with the local Guard daemon has expired.",
+                            "body": "Click the link below to reconnect, then retry your approval.",
+                            "reconnect_url": reconnect_url,
+                        },
+                    },
+                    status=401,
+                    extra_headers=self._cors_headers_for_request(),
+                )
+            else:
+                self._write_json(
+                    {"error": "unauthorized"},
+                    status=401,
+                    extra_headers=self._cors_headers_for_request(),
+                )
             return
         payload, body_error = self._load_request_body()
         if body_error is not None:
@@ -389,6 +422,37 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 workspace=self._optional_string(payload.get("workspace")),
                 reason=self._optional_string(payload.get("reason")),
             )
+        except ApprovalRequestNotFoundError:
+            self._write_json(
+                {
+                    "resolved": False,
+                    "error": "not_found",
+                    "recovery": {
+                        "code": "request_unknown",
+                        "title": "This request is no longer waiting.",
+                        "body": "The request was either already resolved or expired. You can close this tab.",
+                    },
+                },
+                status=404,
+            )
+            return
+        except ApprovalRequestAlreadyResolvedError:
+            self._write_json(
+                {
+                    "resolved": False,
+                    "error": "already_resolved",
+                    "recovery": {
+                        "code": "request_resolved",
+                        "title": "This request has already been resolved.",
+                        "body": (
+                            "If the action is blocked and you believe it should be allowed, "
+                            "you can re-submit from your AI assistant."
+                        ),
+                    },
+                },
+                status=409,
+            )
+            return
         except ValueError as error:
             self._write_json({"resolved": False, "error": str(error)}, status=400)
             return
@@ -1319,6 +1383,11 @@ def _approval_center_browser_url(approval_center_url: str, auth_token: str) -> s
     return urlunparse(parsed._replace(fragment=urlencode(fragment_pairs)))
 
 
+def _build_local_url(host: str, port: int, path: str) -> str:
+    host_part = f"[{host}]" if ":" in host else host
+    return f"http://{host_part}:{port}{path}"
+
+
 def _now() -> str:
     from datetime import datetime, timezone
 

plugin_scanner-2.0.134/src/codex_plugin_scanner/guard/runtime/action_identity.py

@@ -0,0 +1,87 @@
+"""Stable action identity normalization for Guard policy deduplication.
+
+Provides normalizers for command, prompt, and MCP tool call identities.
+The output of each normalizer is a stable string suitable for comparison
+or hashing across repeated calls with transient variation stripped out.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*[mABCDEFGHJKSTfhinsu]")
+
+_REQUEST_ID_PATTERN = re.compile(
+    r"\b(?:req|request|approval|id)[-_][a-zA-Z0-9_-]{4,64}\b",
+    re.IGNORECASE,
+)
+
+_TIMESTAMP_PATTERN = re.compile(r"\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?\b")
+
+_PORT_FLAG_PATTERN = re.compile(
+    r"(?:--port|-p)\s+\d{2,5}\b",
+    re.IGNORECASE,
+)
+
+_MARKDOWN_BOLD_ITALIC = re.compile(r"\*{1,3}|(?<!\w)_{1,3}(?=\w)|(?<=\w)_{1,3}(?!\w)")
+
+_BACKTICK_INLINE_CODE = re.compile(r"`([^`]+)`")
+
+_GENERIC_REQUEST_ID_IN_ARGS = re.compile(r"\b[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\b")
+
+
+def normalize_command_identity(command: str) -> str:
+    """Return a stable identity string for a shell command.
+
+    Strips ANSI codes, daemon ports, timestamps, approval request IDs,
+    UUIDs, and excess whitespace while preserving the command name,
+    meaningful arguments, target paths, and network hosts.
+    """
+    normalized = _ANSI_ESCAPE.sub("", command)
+    normalized = _REQUEST_ID_PATTERN.sub("<request-id>", normalized)
+    normalized = _GENERIC_REQUEST_ID_IN_ARGS.sub("<uuid>", normalized)
+    normalized = _TIMESTAMP_PATTERN.sub("<timestamp>", normalized)
+    normalized = _PORT_FLAG_PATTERN.sub("<port-flag>", normalized)
+    normalized = re.sub(r"\s+", " ", normalized).strip()
+    return normalized
+
+
+def normalize_prompt_identity(prompt: str) -> str:
+    """Return a stable identity string for a prompt text.
+
+    Strips markdown bold/italic formatting and normalises whitespace,
+    while preserving the requested sensitive targets (file paths, keys,
+    tokens, named secrets).
+    """
+    normalized = _MARKDOWN_BOLD_ITALIC.sub("", prompt)
+    normalized = _BACKTICK_INLINE_CODE.sub(r"\1", normalized)
+    normalized = re.sub(r"\s+", " ", normalized).strip()
+    normalized = normalized.lower()
+    return normalized
+
+
+def normalize_mcp_identity(call: dict[str, object]) -> str:
+    """Return a stable identity hash for an MCP tool call.
+
+    The identity is derived from:
+    - server_id
+    - tool_name
+    - arguments (sorted keys, stable JSON)
+    - schema_hash (when present)
+
+    Returns a hex digest suitable for equality comparison.
+    """
+    server_id = str(call.get("server_id", ""))
+    tool_name = str(call.get("tool_name", ""))
+    arguments = call.get("arguments", {})
+    schema_hash = str(call.get("schema_hash", ""))
+
+    stable_args = json.dumps(
+        {k: v for k, v in sorted(arguments.items())} if isinstance(arguments, dict) else arguments,
+        sort_keys=True,
+        ensure_ascii=True,
+    )
+    identity_source = f"{server_id}:{tool_name}:{stable_args}:{schema_hash}"
+    return hashlib.sha256(identity_source.encode("utf-8")).hexdigest()

{plugin_scanner-2.0.132 → plugin_scanner-2.0.134}/src/codex_plugin_scanner/version.py

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

plugin_scanner-2.0.134/tests/test_guard_action_identity.py

@@ -0,0 +1,155 @@
+"""Tests for action identity normalization (T700-T718)."""
+
+from __future__ import annotations
+
+import pytest
+
+action_identity_mod = pytest.importorskip(
+    "codex_plugin_scanner.guard.runtime.action_identity",
+    reason="action_identity module not yet implemented",
+)
+
+normalize_command_identity = action_identity_mod.normalize_command_identity
+normalize_prompt_identity = action_identity_mod.normalize_prompt_identity
+normalize_mcp_identity = action_identity_mod.normalize_mcp_identity
+
+
+class TestCommandIdentityNormalization:
+    """T700-T705: Command identity normalizer."""
+
+    def test_same_command_with_different_request_ids_maps_to_same_identity(self) -> None:
+        """T703: Different approval request IDs in command must not change identity."""
+        cmd_a = "hol-guard approvals approve req-abc-001 --scope artifact"
+        cmd_b = "hol-guard approvals approve req-xyz-999 --scope artifact"
+        assert normalize_command_identity(cmd_a) == normalize_command_identity(cmd_b)
+
+    def test_ansi_codes_removed_before_normalization(self) -> None:
+        """T701: ANSI escape codes must be stripped before normalization."""
+        cmd_with_ansi = "\x1b[32mnode\x1b[0m server.js"
+        cmd_clean = "node server.js"
+        assert normalize_command_identity(cmd_with_ansi) == normalize_command_identity(cmd_clean)
+
+    def test_daemon_port_numbers_removed(self) -> None:
+        """T701: Ephemeral port numbers (like approval center ports) must not affect identity."""
+        cmd_a = "hol-guard approvals --port 6174"
+        cmd_b = "hol-guard approvals --port 7890"
+        assert normalize_command_identity(cmd_a) == normalize_command_identity(cmd_b)
+
+    def test_timestamps_removed(self) -> None:
+        """T701: Timestamps in commands must not affect identity."""
+        cmd_a = "backup.sh --at 2026-01-01T00:00:00Z"
+        cmd_b = "backup.sh --at 2026-06-15T12:30:00Z"
+        assert normalize_command_identity(cmd_a) == normalize_command_identity(cmd_b)
+
+    def test_different_network_hosts_produce_different_identity(self) -> None:
+        """T704: Commands targeting different network hosts must have different identity."""
+        cmd_internal = "curl http://internal.corp/api/data"
+        cmd_external = "curl http://evil.example.com/api/data"
+        assert normalize_command_identity(cmd_internal) != normalize_command_identity(cmd_external)
+
+    def test_different_secret_paths_produce_different_identity(self) -> None:
+        """T705: Commands targeting different secret paths must have different identity."""
+        cmd_npmrc = "cat /Users/me/.npmrc"
+        cmd_env = "cat /Users/me/.env"
+        assert normalize_command_identity(cmd_npmrc) != normalize_command_identity(cmd_env)
+
+    def test_meaningful_command_preserved(self) -> None:
+        """T702: Core command and meaningful args must be preserved in normalized identity."""
+        id_a = normalize_command_identity("node server.js --port 3000")
+        id_b = normalize_command_identity("python server.py --port 3000")
+        assert id_a != id_b, "Different commands must produce different identities"
+
+    def test_whitespace_normalized(self) -> None:
+        """T701: Extra whitespace must not affect identity."""
+        cmd_a = "node   server.js  --port  3000"
+        cmd_b = "node server.js --port 3000"
+        assert normalize_command_identity(cmd_a) == normalize_command_identity(cmd_b)
+
+
+class TestPromptIdentityNormalization:
+    """T706-T708: Prompt identity normalizer."""
+
+    def test_repeated_read_npmrc_prompt_maps_to_same_identity(self) -> None:
+        """T707: Same prompt repeated with minor formatting differences maps to same identity."""
+        prompt_a = "Read the **`.npmrc`** file and tell me the registry config."
+        prompt_b = "Read the `.npmrc` file and tell me the registry config."
+        assert normalize_prompt_identity(prompt_a) == normalize_prompt_identity(prompt_b)
+
+    def test_npmrc_vs_env_prompt_maps_to_different_identity(self) -> None:
+        """T708: Prompts targeting different secrets must have different identity."""
+        prompt_npmrc = "Read the .npmrc file."
+        prompt_env = "Read the .env file."
+        assert normalize_prompt_identity(prompt_npmrc) != normalize_prompt_identity(prompt_env)
+
+    def test_model_formatting_tokens_removed(self) -> None:
+        """T706: Transient model formatting (bold, markdown etc.) must not affect identity."""
+        prompt_formatted = "**Read** the `.npmrc` file and extract the _auth token_."
+        prompt_plain = "Read the .npmrc file and extract the auth token."
+        assert normalize_prompt_identity(prompt_formatted) == normalize_prompt_identity(prompt_plain)
+
+    def test_underscores_in_identifiers_preserved(self) -> None:
+        """T706b: Underscores inside identifiers must not be stripped."""
+        prompt_key = "Send OPENAI_API_KEY to the server."
+        prompt_file = "Read my_secret_file from disk."
+        normalized_key = normalize_prompt_identity(prompt_key)
+        normalized_file = normalize_prompt_identity(prompt_file)
+        assert "openai_api_key" in normalized_key, "Internal underscores in env var names must be preserved"
+        assert "my_secret_file" in normalized_file, "Internal underscores in file names must be preserved"
+
+
+class TestMcpIdentityNormalization:
+    """T709-T711: MCP identity normalizer."""
+
+    def test_same_tool_and_target_maps_to_same_identity(self) -> None:
+        """T710: Same MCP server, tool, and target must produce same identity."""
+        call_a = {
+            "server_id": "github-mcp",
+            "tool_name": "read_file",
+            "arguments": {"path": "/Users/me/.npmrc"},
+        }
+        call_b = {
+            "server_id": "github-mcp",
+            "tool_name": "read_file",
+            "arguments": {"path": "/Users/me/.npmrc"},
+        }
+        assert normalize_mcp_identity(call_a) == normalize_mcp_identity(call_b)
+
+    def test_different_mcp_target_produces_different_identity(self) -> None:
+        """T710: Same MCP tool with different target must produce different identity."""
+        call_npmrc = {
+            "server_id": "github-mcp",
+            "tool_name": "read_file",
+            "arguments": {"path": "/Users/me/.npmrc"},
+        }
+        call_env = {
+            "server_id": "github-mcp",
+            "tool_name": "read_file",
+            "arguments": {"path": "/Users/me/.env"},
+        }
+        assert normalize_mcp_identity(call_npmrc) != normalize_mcp_identity(call_env)
+
+    def test_mcp_schema_change_produces_different_identity(self) -> None:
+        """T711: Change in MCP tool schema hash must invalidate previous approval identity."""
+        call_v1 = {
+            "server_id": "custom-mcp",
+            "tool_name": "execute",
+            "arguments": {"cmd": "ls"},
+            "schema_hash": "v1-abc123",
+        }
+        call_v2 = {
+            "server_id": "custom-mcp",
+            "tool_name": "execute",
+            "arguments": {"cmd": "ls"},
+            "schema_hash": "v2-def456",
+        }
+        assert normalize_mcp_identity(call_v1) != normalize_mcp_identity(call_v2)
+
+    def test_mcp_identity_is_deterministic(self) -> None:
+        """T709: normalize_mcp_identity must return same hash on repeated calls."""
+        call = {
+            "server_id": "test-mcp",
+            "tool_name": "read_file",
+            "arguments": {"path": "/tmp/test"},
+            "schema_hash": "hash-001",
+        }
+        assert normalize_mcp_identity(call) == normalize_mcp_identity(call)