plugin-scanner 2.0.566__tar.gz → 2.0.568__tar.gz

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/PKG-INFO

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

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/pyproject.toml

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

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/pyproject.toml.bak

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

@@ -13,6 +13,7 @@ from pathlib import Path
 from urllib.parse import urlencode
 
 from ...path_support import iter_safe_matching_files, resolves_within_root
+from ..aibom_detection import extend_detection_with_workspace_aibom
 from ..daemon import guard_daemon_url_for_home, load_guard_daemon_url
 from ..models import GuardArtifact, HarnessDetection
 from ..runtime.harness_attribution import cursor_hook_query_extras
@@ -473,7 +474,7 @@ class ClaudeCodeHarnessAdapter(HarnessAdapter):
                     )
                 )
         resolved_executable = self.resolved_executable(context)
-        return HarnessDetection(
+        detection = HarnessDetection(
             harness=self.harness,
             installed=bool(found_paths) or resolved_executable is not None,
             command_available=resolved_executable is not None,
@@ -481,6 +482,11 @@ class ClaudeCodeHarnessAdapter(HarnessAdapter):
             artifacts=tuple(artifacts),
             warnings=(),
         )
+        return extend_detection_with_workspace_aibom(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
 
     @staticmethod
     def _hook_command(context: HarnessContext) -> str:

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/src/codex_plugin_scanner/guard/adapters/codex.py

@@ -15,6 +15,7 @@ try:  # pragma: no cover - Python 3.11+
 except ModuleNotFoundError:  # pragma: no cover - Python 3.10
     import tomli as tomllib  # type: ignore[no-redef]
 
+from ..aibom_detection import enrich_mcp_server_metadata, extend_detection_with_workspace_aibom
 from ..codex_config import dump_toml, read_toml_payload, write_toml_payload
 from ..config import MAX_APPROVAL_WAIT_TIMEOUT_SECONDS, load_guard_config
 from ..launcher import merge_guard_launcher_env
@@ -626,6 +627,23 @@ class CodexHarnessAdapter(HarnessAdapter):
                         continue
                     url = server_config.get("url")
                     env = server_config.get("env")
+                    mcp_metadata = enrich_mcp_server_metadata(
+                        {
+                            "name": name,
+                            "env": {
+                                str(key): str(value)
+                                for key, value in env.items()
+                                if isinstance(key, str) and isinstance(value, str)
+                            }
+                            if isinstance(env, dict)
+                            else {},
+                            "env_keys": sorted(env.keys()) if isinstance(env, dict) else [],
+                        },
+                        command=command if isinstance(command, str) else None,
+                        args=args,
+                        url=url if isinstance(url, str) else None,
+                        transport="http" if isinstance(url, str) else "stdio",
+                    )
                     artifacts.append(
                         GuardArtifact(
                             artifact_id=f"codex:{scope}:{name}",
@@ -638,16 +656,7 @@ class CodexHarnessAdapter(HarnessAdapter):
                             args=args,
                             url=url if isinstance(url, str) else None,
                             transport="http" if isinstance(url, str) else "stdio",
-                            metadata={
-                                "env": {
-                                    str(key): str(value)
-                                    for key, value in env.items()
-                                    if isinstance(key, str) and isinstance(value, str)
-                                }
-                                if isinstance(env, dict)
-                                else {},
-                                "env_keys": sorted(env.keys()) if isinstance(env, dict) else [],
-                            },
+                            metadata=mcp_metadata,
                         )
                     )
         hooks_paths = [context.home_dir / ".codex" / "hooks.json"]
@@ -684,7 +693,7 @@ class CodexHarnessAdapter(HarnessAdapter):
                             command=command if isinstance(command, str) else None,
                         )
                     )
-        return HarnessDetection(
+        detection = HarnessDetection(
             harness=self.harness,
             installed=bool(found_paths) or _command_available(self.executable),
             command_available=_command_available(self.executable),
@@ -692,6 +701,11 @@ class CodexHarnessAdapter(HarnessAdapter):
             artifacts=tuple(artifacts),
             warnings=(),
         )
+        return extend_detection_with_workspace_aibom(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
 
     def install(self, context: HarnessContext) -> dict[str, object]:
         detection = self.detect(context)

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/src/codex_plugin_scanner/guard/adapters/cursor.py

@@ -7,8 +7,10 @@ import sys
 from hashlib import sha256
 from pathlib import Path
 
+from ..aibom_detection import extend_detection_with_workspace_aibom
 from ..launcher import merge_guard_launcher_env
 from ..models import GuardArtifact, HarnessDetection
+from ..runtime.mcp_skill_firewall import enrich_artifact_with_mcp_skill_firewall
 from ..shims import ensure_guard_shim_path_in_shell_profile, install_guard_shim, remove_guard_shim
 from .base import HarnessAdapter, HarnessContext, _json_payload, _run_command_probe
 from .cursor_cli import (
@@ -88,34 +90,36 @@ class CursorHarnessAdapter(HarnessAdapter):
                 environment_payload = server_config.get("environment")
                 environment = env_payload if isinstance(env_payload, dict) else environment_payload
                 artifacts.append(
-                    GuardArtifact(
-                        artifact_id=f"cursor:{scope}:{name}",
-                        name=name,
-                        harness=self.harness,
-                        artifact_type="mcp_server",
-                        source_scope=scope,
-                        config_path=str(config_path),
-                        command=command if isinstance(command, str) else None,
-                        args=args,
-                        url=server_config.get("url") if isinstance(server_config.get("url"), str) else None,
-                        transport="http" if isinstance(server_config.get("url"), str) else "stdio",
-                        metadata={
-                            "env": {
-                                str(key): str(value)
-                                for key, value in environment.items()
-                                if isinstance(key, str) and isinstance(value, str)
-                            }
-                            if isinstance(environment, dict)
-                            else {},
-                            "guard_managed_proxy": is_guard_proxy_command(
-                                command if isinstance(command, str) else None,
-                                args,
-                            ),
-                        },
+                    enrich_artifact_with_mcp_skill_firewall(
+                        GuardArtifact(
+                            artifact_id=f"cursor:{scope}:{name}",
+                            name=name,
+                            harness=self.harness,
+                            artifact_type="mcp_server",
+                            source_scope=scope,
+                            config_path=str(config_path),
+                            command=command if isinstance(command, str) else None,
+                            args=args,
+                            url=server_config.get("url") if isinstance(server_config.get("url"), str) else None,
+                            transport="http" if isinstance(server_config.get("url"), str) else "stdio",
+                            metadata={
+                                "env": {
+                                    str(key): str(value)
+                                    for key, value in environment.items()
+                                    if isinstance(key, str) and isinstance(value, str)
+                                }
+                                if isinstance(environment, dict)
+                                else {},
+                                "guard_managed_proxy": is_guard_proxy_command(
+                                    command if isinstance(command, str) else None,
+                                    args,
+                                ),
+                            },
+                        )
                     )
                 )
         cli_available = cursor_cli_command_available(context)
-        return HarnessDetection(
+        detection = HarnessDetection(
             harness=self.harness,
             installed=bool(found_paths) or cli_available,
             command_available=cli_available,
@@ -123,6 +127,11 @@ class CursorHarnessAdapter(HarnessAdapter):
             artifacts=tuple(artifacts),
             warnings=(),
         )
+        return extend_detection_with_workspace_aibom(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
 
     def resolved_executable(self, context: HarnessContext) -> str | None:
         entry = resolve_cursor_cli_entry(context)

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/src/codex_plugin_scanner/guard/adapters/gemini.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from ..aibom_detection import extend_detection_with_workspace_aibom
 from ..models import GuardArtifact, HarnessDetection
 from .base import HarnessAdapter, HarnessContext, _command_available, _json_payload
 
@@ -70,7 +71,7 @@ class GeminiHarnessAdapter(HarnessAdapter):
                 self._append_found_path(found_paths, settings_path)
                 self._append_settings_artifacts(artifacts, settings_path, payload, scope)
             self._append_skill_artifacts(artifacts, found_paths, skill_root, scope)
-        return HarnessDetection(
+        detection = HarnessDetection(
             harness=self.harness,
             installed=bool(found_paths) or _command_available(self.executable),
             command_available=_command_available(self.executable),
@@ -78,6 +79,11 @@ class GeminiHarnessAdapter(HarnessAdapter):
             artifacts=tuple(artifacts),
             warnings=(),
         )
+        return extend_detection_with_workspace_aibom(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
 
     def _append_extension_artifacts(
         self,

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/src/codex_plugin_scanner/guard/adapters/opencode.py

@@ -8,6 +8,7 @@ import os
 from pathlib import Path
 
 from ...ecosystems.opencode import _load_json_or_jsonc
+from ..aibom_detection import extend_detection_with_workspace_aibom
 from ..launcher import merge_guard_launcher_env
 from ..models import HarnessDetection
 from ..shims import install_guard_shim, remove_guard_shim
@@ -150,7 +151,7 @@ class OpenCodeHarnessAdapter(HarnessAdapter):
             found_paths=found_paths,
             seen_artifact_ids=seen_artifact_ids,
         )
-        return HarnessDetection(
+        detection = HarnessDetection(
             harness=self.harness,
             installed=bool(found_paths) or _command_available(self.executable),
             command_available=_command_available(self.executable),
@@ -158,6 +159,11 @@ class OpenCodeHarnessAdapter(HarnessAdapter):
             artifacts=tuple(artifacts),
             warnings=(),
         )
+        return extend_detection_with_workspace_aibom(
+            detection,
+            home_dir=context.home_dir,
+            workspace_dir=context.workspace_dir,
+        )
 
     def install(self, context: HarnessContext) -> dict[str, object]:
         detection = self.detect(context)

{plugin_scanner-2.0.566 → plugin_scanner-2.0.568}/src/codex_plugin_scanner/guard/adapters/opencode_artifacts.py

@@ -8,6 +8,7 @@ from collections.abc import Iterator
 from pathlib import Path
 
 from ..models import GuardArtifact
+from ..runtime.mcp_skill_firewall import enrich_artifact_with_mcp_skill_firewall
 from .base import HarnessContext
 
 CONFIG_FILENAMES = ("opencode.json", "opencode.jsonc")
@@ -202,13 +203,14 @@ def append_artifact(
     seen_artifact_ids: set[str],
     artifact: GuardArtifact,
 ) -> None:
-    if artifact.artifact_id in seen_artifact_ids:
+    enriched = enrich_artifact_with_mcp_skill_firewall(artifact)
+    if enriched.artifact_id in seen_artifact_ids:
         for index, existing_artifact in enumerate(artifacts):
-            if existing_artifact.artifact_id == artifact.artifact_id:
-                artifacts[index] = artifact
+            if existing_artifact.artifact_id == enriched.artifact_id:
+                artifacts[index] = enriched
                 return
-    seen_artifact_ids.add(artifact.artifact_id)
-    artifacts.append(artifact)
+    seen_artifact_ids.add(enriched.artifact_id)
+    artifacts.append(enriched)
 
 
 def append_found_path(found_paths: list[str], path: Path) -> None:

plugin_scanner-2.0.568/src/codex_plugin_scanner/guard/aibom_detection.py

@@ -0,0 +1,344 @@
+"""Shared AIBOM artifact discovery and content hashing for Guard inventory."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Literal
+
+from ..marketplace_support import extract_marketplace_source, load_marketplace_context
+from ..path_support import is_safe_relative_path, iter_safe_matching_files, resolves_within_root
+from .inventory_contract import fingerprint_mapping, fingerprint_path_tree, fingerprint_text
+from .models import GuardArtifact, HarnessDetection
+
+InstructionRole = Literal["agents_md", "cursor_rules", "claude_md", "mcp_json"]
+INVENTORY_ITEM_KINDS: tuple[str, ...] = (
+    "agent",
+    "daemon_plugin",
+    "harness",
+    "model_provider",
+    "package",
+    "prompt_pack",
+    "skill",
+    "mcp_server",
+    "mcp_tool",
+    "plugin",
+    "channel",
+    "hook",
+    "overlay",
+    "repository",
+    "container_image",
+    "policy",
+    "secret_reference",
+    "network_endpoint",
+)
+
+_MAX_FILE_BYTES = 1024 * 1024
+_CURSOR_RULE_PATTERNS = ("*.mdc", "*.md")
+_CODEX_SKILL_ROOTS = (".agents/skills",)
+
+
+def file_content_hash(path: Path, *, max_bytes: int = _MAX_FILE_BYTES) -> str | None:
+    try:
+        with path.open("rb") as handle:
+            payload = handle.read(max_bytes)
+    except OSError:
+        return None
+    return fingerprint_text(payload.decode("utf-8", errors="replace"))
+
+
+def directory_content_hash(root: Path, *, home_dir: Path) -> str:
+    return fingerprint_path_tree(root, home_dir=home_dir)
+
+
+def mcp_server_content_hash(
+    *,
+    command: str | None,
+    args: tuple[str, ...],
+    url: str | None,
+    transport: str | None,
+    env_keys: tuple[str, ...] = (),
+) -> str:
+    return fingerprint_mapping(
+        {
+            "command": command,
+            "args": list(args),
+            "url": url,
+            "transport": transport,
+            "env_keys": sorted(env_keys),
+        }
+    )
+
+
+def version_info_metadata(*, content_hash: str, version_label: str) -> dict[str, object]:
+    return {
+        "versionInfo": {
+            "versionLabel": version_label,
+            "hashBasis": "content",
+            "contentHash": content_hash,
+            "changedFields": [],
+        }
+    }
+
+
+def instruction_role_for_path(path: Path) -> InstructionRole | None:
+    name = path.name.lower()
+    if name == "agents.md":
+        return "agents_md"
+    if name == "claude.md":
+        return "claude_md"
+    if name == "mcp.json":
+        return "mcp_json"
+    if path.suffix.lower() in {".md", ".mdc"}:
+        parts = path.parts
+        for index, part in enumerate(parts):
+            if part == ".cursor" and index + 1 < len(parts) and parts[index + 1] == "rules":
+                return "cursor_rules"
+    return None
+
+
+def discover_shared_workspace_aibom_artifacts(
+    harness: str,
+    *,
+    home_dir: Path,
+    workspace_dir: Path,
+) -> tuple[GuardArtifact, ...]:
+    if not workspace_dir.is_dir():
+        return ()
+    try:
+        workspace_dir = workspace_dir.resolve()
+    except OSError:
+        return ()
+    artifacts: list[GuardArtifact] = []
+    artifacts.extend(_discover_agents_md(harness, workspace_dir=workspace_dir))
+    artifacts.extend(_discover_cursor_rules(harness, workspace_dir=workspace_dir))
+    artifacts.extend(_discover_codex_skills(harness, workspace_dir=workspace_dir, home_dir=home_dir))
+    artifacts.extend(_discover_codex_marketplace_plugins(harness, workspace_dir=workspace_dir))
+    return tuple(artifacts)
+
+
+def _discover_agents_md(harness: str, *, workspace_dir: Path) -> list[GuardArtifact]:
+    agents_md = workspace_dir / "AGENTS.md"
+    if not agents_md.is_file() or agents_md.is_symlink():
+        return []
+    if not resolves_within_root(workspace_dir, agents_md, require_exists=True):
+        return []
+    return [_instruction_artifact(harness, agents_md, role="agents_md", scope="project")]
+
+
+def _discover_cursor_rules(harness: str, *, workspace_dir: Path) -> list[GuardArtifact]:
+    rules_dir = workspace_dir / ".cursor" / "rules"
+    if not rules_dir.is_dir() or not resolves_within_root(workspace_dir, rules_dir, require_exists=True):
+        return []
+    artifacts: list[GuardArtifact] = []
+    for pattern in _CURSOR_RULE_PATTERNS:
+        for rule_path in iter_safe_matching_files(workspace_dir, rules_dir, pattern):
+            artifacts.append(
+                _instruction_artifact(
+                    harness,
+                    rule_path,
+                    role="cursor_rules",
+                    scope="project",
+                    display_name=rule_path.stem,
+                )
+            )
+    return artifacts
+
+
+def _discover_codex_skills(harness: str, *, workspace_dir: Path, home_dir: Path) -> list[GuardArtifact]:
+    artifacts: list[GuardArtifact] = []
+    for relative_root in _CODEX_SKILL_ROOTS:
+        skill_root = workspace_dir / relative_root
+        if not skill_root.is_dir() or not resolves_within_root(workspace_dir, skill_root, require_exists=True):
+            continue
+        for skill_md in sorted(skill_root.rglob("SKILL.md")):
+            if skill_md.is_symlink() or not skill_md.is_file():
+                continue
+            if not resolves_within_root(workspace_dir, skill_md, require_exists=True):
+                continue
+            skill_dir = skill_md.parent
+            relative_id = skill_dir.relative_to(skill_root).as_posix()
+            content_hash = directory_content_hash(skill_dir, home_dir=home_dir)
+            digest = file_content_hash(skill_md)
+            metadata: dict[str, object] = {
+                "skill_root": relative_root,
+                "content_hash": digest,
+                "directory_hash": content_hash,
+                **version_info_metadata(content_hash=content_hash, version_label=relative_id or skill_dir.name),
+            }
+            artifacts.append(
+                GuardArtifact(
+                    artifact_id=f"{harness}:project:skill:{relative_root}:{relative_id or skill_dir.name}",
+                    name=relative_id or skill_dir.name,
+                    harness=harness,
+                    artifact_type="skill",
+                    source_scope="project",
+                    config_path=str(skill_md),
+                    metadata=metadata,
+                )
+            )
+    return artifacts
+
+
+def _discover_codex_marketplace_plugins(harness: str, *, workspace_dir: Path) -> list[GuardArtifact]:
+    context = load_marketplace_context(workspace_dir)
+    if context is None:
+        return []
+    plugins = context.payload.get("plugins")
+    if not isinstance(plugins, list):
+        return []
+    manifest_hash = file_content_hash(context.file_path)
+    artifacts: list[GuardArtifact] = []
+    marketplace_id = hashlib.sha256(str(context.file_path).encode()).hexdigest()[:12]
+    if manifest_hash is not None:
+        artifacts.append(
+            GuardArtifact(
+                artifact_id=f"{harness}:project:marketplace:{marketplace_id}",
+                name="marketplace.json",
+                harness=harness,
+                artifact_type="plugin",
+                source_scope="project",
+                config_path=str(context.file_path),
+                metadata={
+                    "marketplace_root": True,
+                    "content_hash": manifest_hash,
+                    **version_info_metadata(content_hash=manifest_hash, version_label="marketplace.json"),
+                },
+            )
+        )
+    for index, entry in enumerate(plugins):
+        if not isinstance(entry, dict):
+            continue
+        plugin_name = entry.get("name")
+        if not isinstance(plugin_name, str) or not plugin_name.strip():
+            plugin_name = f"plugin_{index}"
+        source_ref, source_path = extract_marketplace_source(entry)
+        metadata: dict[str, object] = {
+            "marketplace_index": index,
+            "source_ref": source_ref,
+            "source_path": source_path,
+        }
+        plugin_manifest: Path | None = None
+        if source_path and source_path.startswith("./"):
+            relative = source_path[2:]
+            if is_safe_relative_path(workspace_dir, relative, require_exists=False):
+                candidate = workspace_dir / relative
+                if candidate.is_dir() and resolves_within_root(
+                    workspace_dir,
+                    candidate,
+                    require_exists=True,
+                ):
+                    for manifest_name in ("plugin.json", ".codex-plugin/plugin.json"):
+                        manifest_candidate = candidate / manifest_name
+                        if manifest_candidate.is_file() and resolves_within_root(
+                            workspace_dir,
+                            manifest_candidate,
+                            require_exists=True,
+                        ):
+                            plugin_manifest = manifest_candidate
+                            break
+        if plugin_manifest is not None and plugin_manifest.is_file():
+            manifest_digest = file_content_hash(plugin_manifest)
+            if manifest_digest is not None:
+                metadata["content_hash"] = manifest_digest
+                metadata.update(
+                    version_info_metadata(content_hash=manifest_digest, version_label=plugin_name),
+                )
+        artifacts.append(
+            GuardArtifact(
+                artifact_id=f"{harness}:project:marketplace-plugin:{marketplace_id}:{plugin_name}",
+                name=plugin_name,
+                harness=harness,
+                artifact_type="plugin",
+                source_scope="project",
+                config_path=str(plugin_manifest or context.file_path),
+                metadata=metadata,
+            )
+        )
+    return artifacts
+
+
+def _instruction_artifact(
+    harness: str,
+    path: Path,
+    *,
+    role: InstructionRole,
+    scope: str,
+    display_name: str | None = None,
+) -> GuardArtifact:
+    content_hash = file_content_hash(path) or fingerprint_text(path.name)
+    name = display_name or path.name
+    return GuardArtifact(
+        artifact_id=f"{harness}:{scope}:instruction:{role}:{name}",
+        name=name,
+        harness=harness,
+        artifact_type="instruction",
+        source_scope=scope,
+        config_path=str(path),
+        metadata={
+            "instructionRole": role,
+            "content_hash": content_hash,
+            **version_info_metadata(content_hash=content_hash, version_label=name),
+        },
+    )
+
+
+def extend_detection_with_workspace_aibom(
+    detection: HarnessDetection,
+    *,
+    home_dir: Path,
+    workspace_dir: Path | None,
+) -> HarnessDetection:
+    if workspace_dir is None:
+        return detection
+    extra = discover_shared_workspace_aibom_artifacts(
+        detection.harness,
+        home_dir=home_dir,
+        workspace_dir=workspace_dir,
+    )
+    if not extra:
+        return detection
+    existing_ids = {artifact.artifact_id for artifact in detection.artifacts}
+    merged = list(detection.artifacts)
+    found_paths = list(detection.config_paths)
+    for artifact in extra:
+        if artifact.artifact_id in existing_ids:
+            continue
+        merged.append(artifact)
+        existing_ids.add(artifact.artifact_id)
+        config_path = getattr(artifact, "config_path", None)
+        if isinstance(config_path, str):
+            found_paths.append(config_path)
+    return HarnessDetection(
+        harness=detection.harness,
+        installed=detection.installed,
+        command_available=detection.command_available,
+        config_paths=tuple(dict.fromkeys(found_paths)),
+        artifacts=tuple(merged),
+        warnings=detection.warnings,
+    )
+
+
+def enrich_mcp_server_metadata(
+    metadata: dict[str, object],
+    *,
+    command: str | None,
+    args: tuple[str, ...],
+    url: str | None,
+    transport: str | None,
+) -> dict[str, object]:
+    env_keys = metadata.get("env_keys")
+    normalized_env_keys: tuple[str, ...] = ()
+    if isinstance(env_keys, list):
+        normalized_env_keys = tuple(str(key) for key in env_keys if isinstance(key, str))
+    content_hash = mcp_server_content_hash(
+        command=command,
+        args=args,
+        url=url,
+        transport=transport,
+        env_keys=normalized_env_keys,
+    )
+    enriched = dict(metadata)
+    enriched["content_hash"] = content_hash
+    enriched.update(version_info_metadata(content_hash=content_hash, version_label=str(metadata.get("name", "mcp"))))
+    return enriched