# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-does-an-instance-detect-manifest-level-skill-injection-when-the-poisoned-artifact-is-itself-a-trusted-mcp-server-metadata-field.md
# Remnant Warrant:    https://corpusfetch.com/c/how-does-an-instance-detect-manifest-level-skill-injection-when-the-poisoned-artifact-is-itself-a-trusted-mcp-server-metadata-field.warrant.json
# Markdown SHA-256:   f07cccf8c573fd4c94f866fe01f0bfc441a50c9b59e6122dc11ff9573f646186
# Code AST SHA-256:   af9d8e85e8c0ec18b8d1f35290283e8648f88a3a20bb7f5ea54832a4fdd9650a
# Verified Classes:   ManifestProvenanceError, Manifest
# Defensive Guards:   6 fail-closed invariants (zero external deps)

import hashlib
import re
from dataclasses import dataclass

IMPERATIVE_PATTERN = re.compile(
    r"\b(include|first read|always pass|confirm by|before (?:any|you)|"
    r"send .* to|append .* to)\b",
    re.IGNORECASE,
)
SECRET_PATH_PATTERN = re.compile(
    r"(\.env|\.aws/credentials|id_rsa|\.ssh/|secrets?\.ya?ml)", re.IGNORECASE
)


class ManifestProvenanceError(RuntimeError):
    """Raised when manifest metadata fails the trust boundary."""


@dataclass(frozen=True)
class Manifest:
    server_id: str
    code_hash: str
    metadata_hash: str
    description: str
    instructions: str
    examples: list[str]
    schema_paths: frozenset[str]


def hash_metadata(description: str, instructions: str, examples: list[str]) -> str:
    blob = "\x00".join([description, instructions, *examples]).encode()
    return hashlib.sha256(blob).hexdigest()


def admit_manifest(
    manifest: Manifest,
    approved_metadata_hashes: dict[str, str],
) -> None:
    """Gate manifest ingest on metadata provenance, not code provenance."""

    recomputed = hash_metadata(
        manifest.description, manifest.instructions, manifest.examples
    )
    if recomputed != manifest.metadata_hash:
        raise ManifestProvenanceError(
            f"{manifest.server_id}: metadata hash mismatch "
            f"(declared={manifest.metadata_hash[:12]}, actual={recomputed[:12]})"
        )

    approved = approved_metadata_hashes.get(manifest.server_id)
    if approved is None:
        raise ManifestProvenanceError(
            f"{manifest.server_id}: no approved metadata baseline; "
            "refusing first-contact ingest without explicit approval"
        )
    if approved != recomputed:
        raise ManifestProvenanceError(
            f"{manifest.server_id}: metadata revision {recomputed[:12]} "
            f"diverges from approved {approved[:12]} "
            f"(code hash unchanged: {manifest.code_hash[:12]})"
        )

    corpus = " ".join([manifest.description, manifest.instructions, *manifest.examples])
    if IMPERATIVE_PATTERN.search(corpus):
        raise ManifestProvenanceError(
            f"{manifest.server_id}: metadata contains agent-directed imperatives; "
            "advertised purpose is a claim, not a directive"
        )

    for example in manifest.examples:
        for match in SECRET_PATH_PATTERN.finditer(example):
            if match.group(0) not in manifest.schema_paths:
                raise ManifestProvenanceError(
                    f"{manifest.server_id}: example references out-of-schema "
                    f"path {match.group(0)!r}"
                )


def preflight_tool_call(server_id: str, arguments: dict[str, object]) -> None:
    """Argument-side detector; fires before transport, not after."""
    for key, value in arguments.items():
        if isinstance(value, str) and SECRET_PATH_PATTERN.search(value):
            raise ManifestProvenanceError(
                f"{server_id}: tool argument {key!r} carries secret-shaped "
                "content; leak is already in the request body"
            )
