plugin-scanner 2.0.118__tar.gz → 2.0.119__tar.gz

{plugin_scanner-2.0.118 → plugin_scanner-2.0.119}/PKG-INFO

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

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

{plugin_scanner-2.0.118 → plugin_scanner-2.0.119}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.118"
+version = "2.0.119"
 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.118 → plugin_scanner-2.0.119}/src/codex_plugin_scanner/guard/adapters/mcp_servers.py

@@ -8,6 +8,7 @@ from hashlib import sha256
 from pathlib import PurePath
 
 from ..models import GuardArtifact, HarnessDetection
+from ..runtime.mcp_protection import McpServerIdentity, build_mcp_server_identity
 
 
 @dataclass(frozen=True, slots=True)
@@ -23,6 +24,7 @@ class ManagedMcpServer:
     transport: str
     env: dict[str, str]
     enabled: bool
+    identity: McpServerIdentity | None = None
 
 
 _GUARD_PROXY_COMMANDS = frozenset(
@@ -113,6 +115,9 @@ def proxy_cli_args(
         args.extend(["--workspace", workspace])
     for value in server.args:
         args.append(f"--arg={value}")
+    for key in sorted(server.env):
+        if key.strip():
+            args.append(f"--server-env-key={key.strip()}")
     return args
 
 
@@ -156,6 +161,13 @@ def _managed_stdio_server(artifact: GuardArtifact) -> ManagedMcpServer | None:
         transport=transport,
         env=env,
         enabled=enabled,
+        identity=build_mcp_server_identity(
+            config_path=artifact.config_path,
+            command=artifact.command,
+            args=artifact.args,
+            transport=transport,
+            env=env,
+        ),
     )
 
 

{plugin_scanner-2.0.118 → plugin_scanner-2.0.119}/src/codex_plugin_scanner/guard/cli/commands.py

@@ -562,6 +562,7 @@ def _configure_guard_parser(guard_parser: argparse.ArgumentParser) -> None:
     codex_proxy_parser.add_argument("--transport", default="stdio")
     codex_proxy_parser.add_argument("--command", dest="server_command", required=True)
     codex_proxy_parser.add_argument("--arg", dest="server_args", action="append", default=[])
+    codex_proxy_parser.add_argument("--server-env-key", dest="server_env_keys", action="append", default=[])
 
     opencode_proxy_parser = guard_subparsers.add_parser("opencode-mcp-proxy", help=argparse.SUPPRESS)
     _add_guard_common_args(opencode_proxy_parser)
@@ -572,6 +573,7 @@ def _configure_guard_parser(guard_parser: argparse.ArgumentParser) -> None:
     opencode_proxy_parser.add_argument("--transport", default="local")
     opencode_proxy_parser.add_argument("--command", dest="server_command", required=True)
     opencode_proxy_parser.add_argument("--arg", dest="server_args", action="append", default=[])
+    opencode_proxy_parser.add_argument("--server-env-key", dest="server_env_keys", action="append", default=[])
 
     copilot_proxy_parser = guard_subparsers.add_parser("copilot-mcp-proxy", help=argparse.SUPPRESS)
     _add_guard_common_args(copilot_proxy_parser)
@@ -582,6 +584,7 @@ def _configure_guard_parser(guard_parser: argparse.ArgumentParser) -> None:
     copilot_proxy_parser.add_argument("--transport", default="stdio")
     copilot_proxy_parser.add_argument("--command", dest="server_command", required=True)
     copilot_proxy_parser.add_argument("--arg", dest="server_args", action="append", default=[])
+    copilot_proxy_parser.add_argument("--server-env-key", dest="server_env_keys", action="append", default=[])
 
     hermes_mcp_proxy_parser = guard_subparsers.add_parser("hermes-mcp-proxy", help=argparse.SUPPRESS)
     _add_guard_common_args(hermes_mcp_proxy_parser)
@@ -828,6 +831,7 @@ def run_guard_command(
             config_path=args.config_path,
             transport=args.transport,
             server_id=args.server_id,
+            server_env_keys=tuple(args.server_env_keys),
         )
         return proxy.serve()
 
@@ -842,6 +846,7 @@ def run_guard_command(
             config_path=args.config_path,
             transport=args.transport,
             server_id=args.server_id,
+            server_env_keys=tuple(args.server_env_keys),
         )
         return proxy.serve()
 
@@ -856,6 +861,7 @@ def run_guard_command(
             config_path=args.config_path,
             transport=args.transport,
             server_id=args.server_id,
+            server_env_keys=tuple(args.server_env_keys),
         )
         return proxy.serve()
 

{plugin_scanner-2.0.118 → plugin_scanner-2.0.119}/src/codex_plugin_scanner/guard/mcp_tool_calls.py

@@ -11,6 +11,12 @@ from pathlib import PurePath
 from .config import GuardConfig
 from .models import GUARD_ACTION_VALUES, GuardAction, GuardArtifact, GuardReceipt, PolicyDecision
 from .receipts import build_receipt
+from .runtime.mcp_protection import (
+    McpServerIdentity,
+    build_mcp_tool_identity,
+    mcp_server_identity_metadata,
+    mcp_tool_identity_metadata,
+)
 from .store import GuardStore
 
 
@@ -35,12 +41,30 @@ def build_tool_call_artifact(
     transport: str,
     server_id: str | None = None,
     server_fingerprint: object | None = None,
+    server_identity: McpServerIdentity | None = None,
+    tool_schema: object | None = None,
+    tool_description: str | None = None,
 ) -> GuardArtifact:
     metadata = {"server_name": server_name}
     if server_id is not None:
         metadata["server_id"] = server_id
     if server_fingerprint is not None:
         metadata["server_fingerprint"] = server_fingerprint
+    if server_identity is not None:
+        metadata["mcp_server_identity"] = mcp_server_identity_metadata(server_identity)
+    if server_id is not None:
+        server_hash = server_id
+    elif server_identity is not None:
+        server_hash = server_identity.identity_hash
+    else:
+        server_hash = server_id or sha256(f"{harness}:{source_scope}:{server_name}".encode()).hexdigest()
+    tool_identity = build_mcp_tool_identity(
+        server_hash=server_hash,
+        tool_name=tool_name,
+        schema=tool_schema,
+        description=tool_description,
+    )
+    metadata["mcp_tool_identity"] = mcp_tool_identity_metadata(tool_identity)
     return GuardArtifact(
         artifact_id=f"{harness}:runtime:{source_scope}:{server_name}:{tool_name}",
         name=f"{server_name}:{tool_name}",
@@ -61,6 +85,7 @@ def build_tool_call_hash(artifact: GuardArtifact, arguments: object) -> str:
             "config_path": artifact.config_path,
             "transport": artifact.transport,
             "server_fingerprint": artifact.metadata.get("server_fingerprint"),
+            "tool_identity": artifact.metadata.get("mcp_tool_identity"),
             "arguments": arguments,
         },
         sort_keys=True,

{plugin_scanner-2.0.118 → plugin_scanner-2.0.119}/src/codex_plugin_scanner/guard/proxy/runtime_mcp.py

@@ -22,6 +22,7 @@ from ..mcp_tool_calls import (
     tool_call_risk_summary,
 )
 from ..models import HarnessDetection
+from ..runtime.mcp_protection import McpServerIdentity, build_mcp_server_identity
 from ..store import GuardStore
 from .stdio import _blocked_tool_response, _redact_json
 
@@ -42,6 +43,8 @@ class RuntimeMcpGuardProxy:
         config_path: str,
         transport: str = "stdio",
         server_id: str | None = None,
+        server_env_keys: tuple[str, ...] = (),
+        server_identity: McpServerIdentity | None = None,
     ) -> None:
         self.harness = harness
         self.server_name = server_name
@@ -53,10 +56,21 @@ class RuntimeMcpGuardProxy:
         self.config_path = config_path
         self.transport = transport
         self.server_id = server_id
+        self.server_env_keys = tuple(dict.fromkeys(key.strip() for key in server_env_keys if key.strip()))
+        self.server_identity = server_identity or build_mcp_server_identity(
+            config_path=self.config_path,
+            command=self.command[0] if self.command else "",
+            args=tuple(self.command[1:]),
+            transport=self.transport,
+            env_keys=self.server_env_keys,
+        )
         self._inline_prompt_available = False
         self._inline_prompt_counter = 0
         self._buffered_child_responses: dict[str, list[dict[str, Any]]] = {}
         self._buffered_client_responses: dict[str, list[dict[str, Any]]] = {}
+        self._tool_catalog: dict[str, dict[str, object]] = {}
+        self._tool_catalog_pending: dict[str, dict[str, object]] | None = None
+        self._tool_catalog_generation = 0
 
     def run_session(
         self,
@@ -161,6 +175,8 @@ class RuntimeMcpGuardProxy:
             "decision": "forward",
             "redacted_params": _redact_json(params),
         }
+        if method in {"notifications/tools/list_changed", "tools/list_changed"}:
+            self._invalidate_tools_catalog()
         if _is_notification(message):
             self._forward_notification(message, child_stdin)
             event["decision"] = "forward-notification"
@@ -177,10 +193,19 @@ class RuntimeMcpGuardProxy:
                 client_input=client_input,
                 server_output=server_output,
             )
+            if method == "tools/list":
+                list_cursor = params.get("cursor") if isinstance(params, dict) else None
+                list_generation = self._tool_catalog_generation
+                self._capture_tools_catalog(
+                    response,
+                    request_cursor=list_cursor,
+                    request_generation=list_generation,
+                )
             return response, event
 
         tool_name = str(params.get("name") or "unknown")
         arguments = params.get("arguments")
+        tool_definition = self._tool_catalog.get(tool_name, {})
         artifact = build_tool_call_artifact(
             harness=self.harness,
             server_name=self.server_name,
@@ -193,6 +218,9 @@ class RuntimeMcpGuardProxy:
                 "command": self.command,
                 "transport": self.transport,
             },
+            server_identity=self.server_identity,
+            tool_schema=tool_definition.get("input_schema"),
+            tool_description=tool_definition.get("description"),
         )
         artifact_hash = build_tool_call_hash(artifact, arguments)
         decision = evaluate_tool_call(
@@ -364,6 +392,8 @@ class RuntimeMcpGuardProxy:
             if "id" in payload:
                 self._buffer_child_response(payload)
                 continue
+            if str(payload.get("method", "")) in {"notifications/tools/list_changed", "tools/list_changed"}:
+                self._invalidate_tools_catalog()
             if server_output is not None:
                 server_output.write(json.dumps(payload) + "\n")
                 server_output.flush()
@@ -564,6 +594,59 @@ class RuntimeMcpGuardProxy:
             "redacted_params": _redact_json(params),
         }
 
+    def _capture_tools_catalog(
+        self,
+        response: dict[str, Any],
+        *,
+        request_cursor: object | None = None,
+        request_generation: int | None = None,
+    ) -> None:
+        if request_generation is not None and request_generation != self._tool_catalog_generation:
+            return
+        result = response.get("result")
+        if not isinstance(result, dict):
+            return
+        tools = result.get("tools")
+        if not isinstance(tools, list):
+            return
+        if request_cursor is None:
+            self._tool_catalog_pending = None
+        next_cursor = result.get("nextCursor")
+        has_more_pages = next_cursor is not None
+        catalog: dict[str, dict[str, object]] = {}
+        for item in tools:
+            if not isinstance(item, dict):
+                continue
+            name = item.get("name")
+            if not isinstance(name, str) or not name.strip():
+                continue
+            entry: dict[str, object] = {}
+            description = item.get("description")
+            if isinstance(description, str) and description.strip():
+                entry["description"] = description.strip()
+            input_schema = item.get("inputSchema")
+            if input_schema is not None:
+                entry["input_schema"] = input_schema
+            catalog[name.strip()] = entry
+        if has_more_pages:
+            pending_snapshot = {} if self._tool_catalog_pending is None else dict(self._tool_catalog_pending)
+            pending_snapshot.update(catalog)
+            self._tool_catalog_pending = pending_snapshot
+            self._tool_catalog = dict(self._tool_catalog_pending)
+            return
+        if self._tool_catalog_pending is not None:
+            merged_snapshot = dict(self._tool_catalog_pending)
+            merged_snapshot.update(catalog)
+            self._tool_catalog = merged_snapshot
+            self._tool_catalog_pending = None
+            return
+        self._tool_catalog = catalog
+
+    def _invalidate_tools_catalog(self) -> None:
+        self._tool_catalog = {}
+        self._tool_catalog_pending = None
+        self._tool_catalog_generation += 1
+
     @staticmethod
     def _launch_target(tool_name: str, arguments: object) -> str:
         serialized_arguments = json.dumps(arguments) if arguments is not None else ""