cf-bootstrap-source-local 0.1.0__py3-none-any.whl

cf_bootstrap_source_local/inventory.py

@@ -0,0 +1,255 @@
+"""Deterministic direct-project inventory and index validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+import tomllib
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version
+
+from .model import ResolverError, canonical_json, normalize_distribution
+
+
+@dataclass(frozen=True, slots=True)
+class Project:
+    name: str
+    normalized_name: str
+    version: str
+    path: Path
+    relative: str
+    dependencies: tuple[str, ...] = ()
+    optional_dependencies: tuple[tuple[str, tuple[str, ...]], ...] = ()
+    build_requirements: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class NativeProject:
+    crate_path: Path
+    relative: str
+    distribution: str
+    binary: str
+    version: str
+    platforms: tuple[str, ...]
+    wheel_tags: tuple[str, ...] = ()
+    executable: str | None = None
+    discovery_group: str | None = None
+    entry_point: str | None = None
+
+    @property
+    def normalized_name(self) -> str:
+        return normalize_distribution(self.distribution)
+
+
+def normalize(name: str) -> str:
+    return normalize_distribution(name)
+
+
+def _validate_symlinks(root: Path) -> None:
+    for current, directories, files in os.walk(root, followlinks=False):
+        for name in [*directories, *files]:
+            path = Path(current) / name
+            if path.is_symlink():
+                try:
+                    path.resolve().relative_to(root.resolve())
+                except ValueError as error:
+                    raise ResolverError("SOURCE_PROJECT_INVALID", "project symlink escapes source tree") from error
+
+
+def _validate_package_conformance(path: Path, name: str, version: str) -> None:
+    try:
+        data = tomllib.loads((path / "pyproject.toml").read_text(encoding="utf-8"))
+        package = next(item.split("/")[-1] for item in data.get("tool", {}).get("hatch", {}).get("build", {}).get("targets", {}).get("wheel", {}).get("packages", []) if isinstance(item, str) and item.startswith("src/"))
+    except (OSError, KeyError, TypeError, StopIteration, tomllib.TOMLDecodeError) as error:
+        raise ResolverError("SOURCE_CONFORMANCE_INVALID", "project package layout is not conforming") from error
+    semantic = path / "src" / package / "semantics" / "package.trig"
+    init = path / "src" / package / "__init__.py"
+    if not semantic.is_file() or not init.is_file():
+        raise ResolverError("SOURCE_CONFORMANCE_INVALID", f"project {path.name} has no package semantic source")
+    text = semantic.read_text(encoding="utf-8")
+    if text.count("cfpkg:CfPackage") != 1 or str(name) not in text or str(version) not in text or f'rdf:value "{package}"' not in text or 'rdf:value "Python"' not in text:
+        raise ResolverError("SOURCE_CONFORMANCE_INVALID", f"project {path.name} package semantic manifest is invalid")
+    entries = data.get("project", {}).get("entry-points", {}).get("cogniflow.semantic_sources", {})
+    if not isinstance(entries, dict) or entries.get(name) != f"{package}:semantic_files" or "def semantic_files" not in init.read_text(encoding="utf-8"):
+        raise ResolverError("SOURCE_CONFORMANCE_INVALID", f"project {path.name} has no semantic source entry point")
+
+
+def inventory(checkout: Path) -> tuple[tuple[Project, ...], str, str]:
+    root = checkout / "stonecastle"
+    if not root.is_dir():
+        raise ResolverError("SOURCE_INVALID", "checkout has no stonecastle directory")
+    projects: list[Project] = []
+    for child in sorted(root.iterdir(), key=lambda p: p.name.casefold()):
+        if not child.is_dir() or not (child / "pyproject.toml").is_file():
+            continue
+        try:
+            real = child.resolve()
+            real.relative_to(root.resolve())
+            data = tomllib.loads((child / "pyproject.toml").read_text(encoding="utf-8"))
+            project = data["project"]
+            name, version = project["name"], project["version"]
+        except (OSError, KeyError, TypeError, tomllib.TOMLDecodeError) as error:
+            raise ResolverError("SOURCE_PROJECT_INVALID", f"invalid project metadata: {child.name}") from error
+        if not isinstance(name, str) or not isinstance(version, str) or not name or not version:
+            raise ResolverError("SOURCE_PROJECT_INVALID", "project name and version must be strings")
+        normalized = normalize(name)
+        relative = child.relative_to(checkout).as_posix()
+        if any(item.normalized_name == normalized for item in projects):
+            raise ResolverError("SOURCE_PROJECT_INVALID", "duplicate normalized distribution name")
+        _validate_package_conformance(child, name, version)
+        dependencies = project.get("dependencies", [])
+        optional = data.get("project", {}).get("optional-dependencies", {})
+        build = data.get("build-system", {}).get("requires", [])
+        if not isinstance(dependencies, list) or any(not isinstance(item, str) for item in dependencies):
+            raise ResolverError("SOURCE_PROJECT_INVALID", f"project {child.name} dependencies are invalid")
+        if not isinstance(build, list) or any(not isinstance(item, str) for item in build):
+            raise ResolverError("SOURCE_PROJECT_INVALID", f"project {child.name} build requirements are invalid")
+        optional_items = tuple(sorted((str(group), tuple(values)) for group, values in optional.items() if isinstance(group, str) and isinstance(values, list) and all(isinstance(item, str) for item in values)))
+        projects.append(Project(name, normalized, version, child, relative, tuple(dependencies), optional_items, tuple(build)))
+    projects.sort(key=lambda item: (item.normalized_name, item.relative))
+    for project in projects:
+        _validate_symlinks(project.path)
+    index_path = root / "stonecastle.index.json"
+    try:
+        index = json.loads(index_path.read_text(encoding="utf-8"))
+        entries = [item for item in index["files"] if item.get("kind") == "project-metadata"]
+    except (OSError, KeyError, TypeError, json.JSONDecodeError) as error:
+        raise ResolverError("SOURCE_INDEX_INVALID", "stonecastle index is invalid") from error
+    expected = {item.relative + "/pyproject.toml" for item in projects}
+    all_index_paths = [item.get("path") for item in entries]
+    if any(not isinstance(path, str) or path.replace("\\", "/") != path or Path(path).parts[:1] != ("stonecastle",) or len(Path(path).parts) != 3 or Path(path).parts[-1] != "pyproject.toml" for path in all_index_paths):
+        raise ResolverError("SOURCE_INDEX_INVALID", "project metadata path is not a direct pyproject")
+    if len(all_index_paths) != len(set(all_index_paths)) or set(all_index_paths) != expected or any(not (checkout / path).is_file() for path in all_index_paths):
+        raise ResolverError("SOURCE_INDEX_INVALID", "index and direct project inventory differ")
+    source_data = []
+    ignored = {".git", ".venv", "__pycache__", ".pytest_cache", "build", "dist"}
+    for project in projects:
+        files = []
+        for path in sorted(project.path.rglob("*")):
+            if not path.is_file() or any(part in ignored or part.endswith(".egg-info") for part in path.relative_to(project.path).parts):
+                continue
+            files.append({"path": path.relative_to(project.path).as_posix(), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()})
+        source_data.append({"path": project.relative, "name": project.name, "version": project.version, "files": files})
+    for native in inventory_natives(checkout):
+        native_files = []
+        for path in sorted(native.crate_path.rglob("*")):
+            if path.is_file() and not any(part in {"target", ".git"} for part in path.relative_to(native.crate_path).parts):
+                native_files.append({"path": path.relative_to(native.crate_path).as_posix(), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()})
+        source_data.append({"path": native.relative, "distribution": native.distribution, "binary": native.binary, "version": native.version, "platforms": list(native.platforms), "wheel_tags": list(native.wheel_tags), "executable": native.executable, "discovery_group": native.discovery_group, "entry_point": native.entry_point, "files": native_files})
+    source_digest = "sha256:" + hashlib.sha256(canonical_json(source_data)).hexdigest()
+    index_digest = "sha256:" + hashlib.sha256(index_path.read_bytes()).hexdigest()
+    return tuple(projects), source_digest, index_digest
+
+
+def inventory_natives(checkout: Path, *, selected_kind: str = "native-service-artifact") -> tuple[NativeProject, ...]:
+    """Read one indexed native category; target-instance natives are the default."""
+    if selected_kind not in {"native-service-artifact", "native-frontend-artifact"}:
+        raise ResolverError("NATIVE_PROJECT_INVALID", "native project category is invalid")
+    declarations = {
+        "stonecastle/cf_service_mcp_server": ("native-service-artifact", "cf_service_mcp_server", "cf-service-mcp-server", "cf-service-mcp-server"),
+        "stonecastle/cf_install_tui_ratatui": ("native-frontend-artifact", "cf_install_tui_ratatui", "cogniflow-tui", "cogniflow-tui"),
+    }
+    try:
+        index = json.loads((checkout / "stonecastle/stonecastle.index.json").read_text(encoding="utf-8"))
+        indexed = sorted(item["path"] for item in index.get("files", []) if item.get("kind") == "native-project-metadata")
+        expected_paths = sorted(f"{path}/native-artifact.toml" for path in declarations if (checkout / path / "native-artifact.toml").is_file())
+        if indexed != expected_paths:
+            raise ValueError
+        projects = []
+        for metadata_relative in indexed:
+            metadata_path = checkout / metadata_relative
+            data = tomllib.loads(metadata_path.read_text(encoding="utf-8"))
+            native = data["native"]
+            crate_relative = native["crate_path"]
+            expected = declarations.get(crate_relative)
+            if expected is None:
+                raise ValueError
+            crate = checkout / crate_relative
+            cargo = tomllib.loads((crate / "Cargo.toml").read_text(encoding="utf-8"))
+            package = cargo["package"]
+            kind, package_name, distribution, binary = expected
+            fields = {"kind", "crate_path", "distribution", "binary", "version_source", "platforms"}
+            wheel_tags: tuple[str, ...] = ()
+            executable = discovery_group = entry_point = None
+            if kind == "native-frontend-artifact":
+                fields |= {"wheel_tags", "executable", "discovery_group", "entry_point"}
+                wheel_tags = tuple(native.get("wheel_tags", ()))
+                executable = native.get("executable")
+                discovery_group = native.get("discovery_group")
+                entry_point = native.get("entry_point")
+                if wheel_tags != ("py3-none-manylinux_2_39_x86_64", "py3-none-win_amd64") or (executable, discovery_group, entry_point) != (binary, "cogniflow.frontends.v1", binary):
+                    raise ValueError
+            if set(native) != fields or native["kind"] != kind or native["version_source"] != "cargo.package.version" or metadata_relative != f"{crate_relative}/native-artifact.toml" or not crate.is_dir() or not (crate / "Cargo.lock").is_file() or package["name"] != package_name or package["version"] != str(package["version"]) or native["distribution"] != distribution or native["binary"] != binary or tuple(native["platforms"]) != ("linux-x86_64", "windows-x86_64"):
+                raise ValueError
+            if selected_kind == native["kind"]:
+                projects.append(NativeProject(crate, crate_relative, distribution, binary, str(package["version"]), tuple(native["platforms"]), wheel_tags, executable, discovery_group, entry_point))
+    except (OSError, KeyError, TypeError, ValueError, tomllib.TOMLDecodeError) as error:
+        raise ResolverError("NATIVE_PROJECT_INVALID", "native project metadata is invalid") from error
+    return tuple(projects)
+
+
+def inventory_stage0_frontends(checkout: Path) -> tuple[NativeProject, ...]:
+    """Read Stage-0 presentation adapters without granting target authority."""
+    return inventory_natives(checkout, selected_kind="native-frontend-artifact")
+
+
+def dependency_closure(projects: tuple[Project, ...], roots: tuple[str, ...], environment: dict[str, str] | None = None) -> tuple[tuple[Project, ...], tuple[str, ...]]:
+    """Resolve first-party runtime dependencies without importing project code."""
+    by_name = {project.normalized_name: project for project in projects}
+    selected: dict[str, Project] = {}
+    external: dict[str, list[tuple[str, SpecifierSet]]] = {}
+    visiting: set[str] = set()
+
+    def visit(name: str) -> None:
+        normalized = normalize_distribution(name)
+        if normalized in visiting:
+            raise ResolverError("DEPENDENCY_INVALID", "first-party dependency cycle")
+        project = by_name.get(normalized)
+        if project is None:
+            if normalized.startswith("cf-"):
+                raise ResolverError("DEPENDENCY_INVALID", f"unresolved first-party dependency: {name}")
+            external[normalized] = (name, SpecifierSet())
+            return
+        if normalized in selected:
+            return
+        visiting.add(normalized)
+        selected[normalized] = project
+        for raw in project.dependencies:
+            try:
+                requirement = Requirement(raw)
+            except InvalidRequirement as error:
+                raise ResolverError("DEPENDENCY_INVALID", f"invalid PEP 508 requirement: {raw}") from error
+            if requirement.marker is not None and not requirement.marker.evaluate(environment):
+                continue
+            normalized_requirement = normalize_distribution(requirement.name)
+            if normalized_requirement in by_name:
+                visit(requirement.name)
+                continue
+            if normalized_requirement.startswith("cf-"):
+                raise ResolverError("DEPENDENCY_INVALID", f"unresolved first-party dependency: {requirement}")
+            canonical = str(requirement)
+            current = external.setdefault(normalized_requirement, [])
+            combined = SpecifierSet(",".join(str(item[1]) for item in [*current, (canonical, requirement.specifier)] if str(item[1])))
+            if current and not any(_specifier_has_candidate(combined) for _ in (None,)):
+                raise ResolverError("DEPENDENCY_INVALID", f"contradictory external requirements for {normalized_requirement}")
+            current.append((canonical, SpecifierSet(str(requirement.specifier))))
+        visiting.remove(normalized)
+
+    for root in roots:
+        if normalize_distribution(root) not in by_name:
+            raise ResolverError("DEPENDENCY_INVALID", f"selected provider root is not inventoried: {root}")
+        visit(root)
+    return tuple(sorted(selected.values(), key=lambda project: (project.normalized_name, project.relative))), tuple(item[0] for _, values in sorted(external.items()) for item in sorted(values))
+
+
+def _specifier_has_candidate(specifier: SpecifierSet) -> bool:
+    """Reject an intersection that has no plausible released version."""
+    for major in range(0, 100):
+        for minor in range(0, 100):
+            if Version(f"{major}.{minor}") in specifier:
+                return True
+    return not str(specifier)

cf_bootstrap_source_local/model.py

@@ -0,0 +1,91 @@
+"""Strict protocol and request models for the local resolver."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path, PurePosixPath, PureWindowsPath
+import re
+from typing import Any
+
+PROTOCOL = "cf.bootstrap.artifact-resolver.v1"
+REQUEST_SCHEMA = "cf.bootstrap.artifact-resolution.request.v2"
+RESULT_SCHEMA = "cf.bootstrap.local-artifact-resolution.v2"
+ARTIFACT_SET_SCHEMA = "cf.bootstrap.artifact-set.v2"
+PLAN_SCHEMA = "cf.bootstrap.plan.v2"
+
+
+class ResolverError(ValueError):
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+def canonical_json(value: object) -> bytes:
+    return (json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8")
+
+
+def normalize_distribution(name: str) -> str:
+    """Apply the canonical PyPA distribution-name normalization."""
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def _path(value: object, label: str) -> Path:
+    if not isinstance(value, str) or not value or "\x00" in value or "://" in value:
+        raise ResolverError("SCHEMA_INVALID", f"{label} is invalid")
+    windows = PureWindowsPath(value)
+    posix = PurePosixPath(value)
+    if ".." in windows.parts or ".." in posix.parts:
+        raise ResolverError("SCHEMA_INVALID", f"{label} must be an absolute non-root path")
+    path = windows if windows.drive or "\\" in value else posix
+    if not path.is_absolute() or str(path) == path.anchor:
+        raise ResolverError("SCHEMA_INVALID", f"{label} must be an absolute non-root path")
+    return Path(value)
+
+
+def _contained(child: Path, parent: Path) -> bool:
+    try:
+        child.resolve().relative_to(parent.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def parse_request(payload: object) -> tuple[dict[str, Any], Path]:
+    if not isinstance(payload, dict):
+        raise ResolverError("SCHEMA_INVALID", "request must be an object")
+    fields = {"schema", "bootstrap_plan", "artifact_output_root", "external_wheelhouse_path", "phase"}
+    if payload.get("phase") == "post-handoff-verify":
+        fields |= {"bound_artifact_set_digest", "bound_selection_digest", "bound_profile_digest", "bound_catalog_digest", "bound_repository_source_digest", "bound_index_digest"}
+    unknown = set(payload) - fields
+    if unknown:
+        raise ResolverError("UNKNOWN_REQUEST_FIELD", "request contains unknown fields")
+    if set(payload) != fields or payload.get("schema") != REQUEST_SCHEMA:
+        raise ResolverError("SCHEMA_INVALID", "request schema or required fields are invalid")
+    if payload.get("phase") not in {"bootstrap", "post-handoff", "post-handoff-verify"}:
+        raise ResolverError("SCHEMA_INVALID", "resolution phase is invalid")
+    plan = payload["bootstrap_plan"]
+    plan_fields = {"schema", "instance_id", "installation_root", "cogniflow_home", "artifact_source", "profile", "stages"}
+    if not isinstance(plan, dict) or set(plan) != plan_fields or plan.get("schema") != PLAN_SCHEMA:
+        raise ResolverError("SCHEMA_INVALID", "bootstrap plan schema is invalid")
+    profile = plan.get("profile")
+    if not isinstance(profile, str) or not re.fullmatch(r"[A-Za-z][A-Za-z0-9+.-]*:[^\s]+", profile):
+        raise ResolverError("SCHEMA_INVALID", "plan profile is not an absolute IRI")
+    source = plan.get("artifact_source")
+    if not isinstance(source, dict) or set(source) != {"mode", "checkout_path"} or source.get("mode") != "local-repository":
+        raise ResolverError("SOURCE_INVALID", "plan source must be local-repository")
+    checkout = _path(source.get("checkout_path"), "checkout_path")
+    output = _path(payload["artifact_output_root"], "artifact_output_root")
+    wheelhouse = _path(payload["external_wheelhouse_path"], "external_wheelhouse_path")
+    if _contained(output, checkout) or _contained(wheelhouse, checkout):
+        raise ResolverError("SCHEMA_INVALID", "artifact paths must be outside checkout")
+    for key in ("cogniflow_home", "installation_root"):
+        protected = _path(plan[key], key)
+        if _contained(output, protected) or _contained(wheelhouse, protected):
+            raise ResolverError("SCHEMA_INVALID", "artifact paths are inside a protected path")
+    if not checkout.is_dir() or not wheelhouse.is_dir() or wheelhouse.is_symlink():
+        raise ResolverError("SOURCE_INVALID", "checkout or external wheelhouse does not exist")
+    if payload.get("phase") != "post-handoff-verify":
+        for item in wheelhouse.iterdir():
+            if item.is_symlink() or not item.is_file() or item.suffix != ".whl":
+                raise ResolverError("EXTERNAL_SOURCE_FORBIDDEN", "external wheelhouse must contain regular wheels only")
+    return plan, output

cf_bootstrap_source_local/native.py

@@ -0,0 +1,163 @@
+"""Locked Rust build and deterministic platform wheel assembly."""
+
+from __future__ import annotations
+
+import base64
+import csv
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import platform
+import shutil
+import subprocess
+import zipfile
+
+from .inventory import NativeProject
+from .model import ResolverError
+
+
+def _platform() -> tuple[str, str, str]:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    if system == "windows" and machine in {"amd64", "x86_64"}:
+        return "windows-x86_64", "win_amd64", ".exe"
+    if system == "linux" and machine in {"amd64", "x86_64"}:
+        return "linux-x86_64", "manylinux_2_39_x86_64", ""
+    raise ResolverError("UNSUPPORTED_PLATFORM", "native gateway supports only Windows and Linux x86_64")
+
+
+def _record(files: dict[str, bytes], record_name: str) -> bytes:
+    rows: list[list[str]] = []
+    for name in sorted(files):
+        digest = base64.urlsafe_b64encode(hashlib.sha256(files[name]).digest()).rstrip(b"=").decode("ascii")
+        rows.append([name, "sha256=" + digest, str(len(files[name]))])
+    rows.append([record_name, "", ""])
+    stream = io.StringIO(newline="")
+    csv.writer(stream, lineterminator="\n").writerows(rows)
+    return stream.getvalue().encode("utf-8")
+
+
+def package_native(project: NativeProject, binary: Path, staging: Path, accepted_sha256: str | None = None, authority: dict[str, str] | None = None) -> dict[str, object]:
+    """Assemble the canonical wheel from an authority-bound native executable."""
+    normalized_platform, platform_tag, suffix = _platform()
+    if normalized_platform not in project.platforms:
+        raise ResolverError("UNSUPPORTED_PLATFORM", "native metadata does not declare this platform")
+    if not binary.is_file() or binary.is_symlink():
+        raise ResolverError("NATIVE_BINARY_MISSING", "expected native executable is missing or unsafe")
+    payload = binary.read_bytes()
+    payload_sha256 = hashlib.sha256(payload).hexdigest()
+    if accepted_sha256 is not None and payload_sha256 != accepted_sha256:
+        raise ResolverError("NATIVE_AUTHORITY_MISMATCH", "installed native executable differs from accepted bootstrap authority")
+    if (suffix and not payload.startswith(b"MZ")) or (not suffix and not payload.startswith(b"\x7fELF")) or str(project.crate_path.resolve()).encode() in payload:
+        raise ResolverError("NATIVE_BINARY_INVALID", "native executable identity is invalid")
+    authority = {project.normalized_name: payload_sha256} if authority is None else dict(authority)
+    if (
+        authority.get(project.normalized_name) != payload_sha256
+        or any(
+            not isinstance(name, str)
+            or not name
+            or not isinstance(digest, str)
+            or len(digest) != 64
+            or any(char not in "0123456789abcdef" for char in digest)
+            for name, digest in authority.items()
+        )
+    ):
+        raise ResolverError("NATIVE_AUTHORITY_INVALID", "native packaging authority is invalid")
+    wheel_name = project.normalized_name.replace("-", "_")
+    dist_info = f"{wheel_name}-{project.version}.dist-info"
+    executable_name = project.binary
+    if project.normalized_name == "cogniflow-tui":
+        executable_name += "-native"
+    executable = f"{wheel_name}-{project.version}.data/scripts/{executable_name}{suffix}"
+    metadata = (f"Metadata-Version: 2.1\nName: {project.distribution}\nVersion: {project.version}\n\n").encode()
+    wheel = (f"Wheel-Version: 1.0\nGenerator: stonecastle-native-wheel\nRoot-Is-Purelib: false\nTag: py3-none-{platform_tag}\n\n").encode()
+    files = {f"{dist_info}/METADATA": metadata, f"{dist_info}/WHEEL": wheel, executable: payload}
+    if project.normalized_name == "cogniflow-tui":
+        if (project.executable, project.discovery_group, project.entry_point) != (project.binary, "cogniflow.frontends.v1", project.binary):
+            raise ResolverError("NATIVE_METADATA_INVALID", "frontend registration metadata is invalid")
+        target = "cogniflow_tui:main"
+        files[f"{dist_info}/entry_points.txt"] = (
+            f"[console_scripts]\n{project.entry_point} = {target}\n"
+            f"[{project.discovery_group}]\n{project.entry_point} = {target}\n"
+        ).encode("ascii")
+        files["cogniflow_tui.py"] = (
+            "from pathlib import Path\n"
+            "import os\n"
+            "import stat\n"
+            "import subprocess\n"
+            "import sys\n\n"
+            "def main():\n"
+            "    suffix = '.exe' if sys.platform == 'win32' else ''\n"
+            "    executable = Path(sys.executable).parent / ('cogniflow-tui-native' + suffix)\n"
+            "    metadata = os.lstat(executable)\n"
+            "    if stat.S_ISLNK(metadata.st_mode) or not stat.S_ISREG(metadata.st_mode) or (sys.platform == 'win32' and metadata.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT):\n"
+            "        raise RuntimeError('native frontend executable is missing or unsafe')\n"
+            "    if sys.platform == 'win32':\n"
+            "        return subprocess.run([str(executable), *sys.argv[1:]], stdin=None, stdout=None, stderr=None, shell=False, check=False).returncode\n"
+            "    os.execv(str(executable), [str(executable), *sys.argv[1:]])\n"
+        ).encode("ascii")
+    if project.normalized_name in {"cf-service-mcp-server", "cogniflow-tui"}:
+        records = [{"normalized_distribution": name, "sha256": digest} for name, digest in sorted(authority.items() if project.normalized_name == "cf-service-mcp-server" else [(project.normalized_name, payload_sha256)])]
+        files[f"{dist_info}/NATIVE-AUTHORITY.json"] = json.dumps({"schema": "stonecastle.native-authority.v1", "executables": records}, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    files[f"{dist_info}/RECORD"] = _record(files, f"{dist_info}/RECORD")
+    filename = f"{wheel_name}-{project.version}-py3-none-{platform_tag}.whl"
+    output = staging / "wheels" / filename
+    output.parent.mkdir(parents=True, exist_ok=True)
+    epoch = (1980, 1, 1, 0, 0, 0)
+    with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as archive:
+        for name in sorted(files):
+            info = zipfile.ZipInfo(name, epoch)
+            info.compress_type = zipfile.ZIP_DEFLATED
+            info.external_attr = (0o100755 if "/scripts/" in name else 0o100644) << 16
+            archive.writestr(info, files[name])
+    return {"distribution": project.distribution, "normalized_distribution": project.normalized_name, "version": project.version, "filename": filename, "sha256": hashlib.sha256(output.read_bytes()).hexdigest(), "size_bytes": output.stat().st_size, "source_project": project.relative, "artifact_kind": "native", "wheel_tags": [f"py3-none-{platform_tag}"], "executable": executable, "discovery_group": project.discovery_group, "entry_point": project.entry_point}
+
+
+def _build_native_binary(project: NativeProject, staging: Path) -> Path:
+    normalized_platform, _, suffix = _platform()
+    if normalized_platform not in project.platforms:
+        raise ResolverError("UNSUPPORTED_PLATFORM", "native metadata does not declare this platform")
+    target_dir = staging / "cargo-target"
+    env = os.environ.copy()
+    cargo = env.get("STONECASTLE_CARGO") or shutil.which("cargo")
+    if not cargo:
+        raise ResolverError("BUILD_TOOL_UNAVAILABLE", "exact Cargo executable is unavailable")
+    cargo_candidate = Path(cargo)
+    cargo_path = cargo_candidate.resolve()
+    if cargo_path.name.lower().startswith("rustup"):
+        sibling = cargo_candidate.with_name("cargo.exe" if os.name == "nt" else "cargo")
+        cargo_path = sibling.absolute() if sibling.is_file() else cargo_path
+    if not cargo_path.is_file():
+        raise ResolverError("BUILD_TOOL_UNAVAILABLE", "exact Cargo executable is unavailable")
+    cargo_home = Path(env.get("CARGO_HOME", "")) if env.get("CARGO_HOME") else cargo_path.parent.parent
+    rustup_home = Path(env.get("RUSTUP_HOME", "")) if env.get("RUSTUP_HOME") else cargo_home.parent / ".rustup"
+    env.update({"CARGO_HOME": str(cargo_home), "RUSTUP_HOME": str(rustup_home), "RUSTUP_TOOLCHAIN": "1.96.0", "CARGO_TARGET_DIR": str(target_dir), "CARGO_INCREMENTAL": "0", "SOURCE_DATE_EPOCH": "315532800"})
+    env["RUSTFLAGS"] = (env.get("RUSTFLAGS", "") + " --remap-path-prefix=" + str(project.crate_path.resolve()) + "=/stonecastle").strip()
+    if suffix:
+        env["RUSTFLAGS"] += " -C link-arg=/Brepro"
+    env.pop("PYTHONPATH", None)
+    try:
+        result = subprocess.run([str(cargo_path), "build", "--release", "--locked"], cwd=project.crate_path, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=600, check=False)
+    except (FileNotFoundError, subprocess.TimeoutExpired) as error:
+        raise ResolverError("BUILD_TOOL_UNAVAILABLE", "locked Cargo build is unavailable") from error
+    if result.returncode != 0:
+        diagnostic = (result.stderr or result.stdout or "no Cargo diagnostic").strip().replace("\n", " ")[:500]
+        raise ResolverError("BUILD_FAILED", f"locked native gateway build failed: {diagnostic}")
+    return target_dir / "release" / (project.binary + suffix)
+
+
+def build_natives(projects: tuple[NativeProject, ...], staging: Path) -> list[dict[str, object]]:
+    """Compile the complete native set before emitting authority-bound wheels."""
+    binaries = [(project, _build_native_binary(project, staging)) for project in projects]
+    authority = {project.normalized_name: hashlib.sha256(binary.read_bytes()).hexdigest() for project, binary in binaries}
+    if len(authority) != len(projects):
+        raise ResolverError("NATIVE_AUTHORITY_INVALID", "native project authority is ambiguous")
+    packaged = [package_native(project, binary, staging, authority=authority) for project, binary in binaries]
+    from .artifacts import validate_native_wheel
+    return [validate_native_wheel(staging / "wheels" / str(record["filename"]), project) for (project, _binary), record in zip(binaries, packaged, strict=True)]
+
+
+def build_native(project: NativeProject, staging: Path) -> dict[str, object]:
+    return build_natives((project,), staging)[0]

cf_bootstrap_source_local/profiles.py

@@ -0,0 +1,129 @@
+"""Fail-closed loading and validation of the indexed TriG profile catalog."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+import re
+
+from rdflib import Dataset, Literal, RDF, SKOS, URIRef
+from packaging.version import Version, InvalidVersion
+
+from .model import ResolverError, canonical_json
+
+PROFILE_NS = "urn:cf:profile:"
+INSTALLATION_PROFILE = URIRef(PROFILE_NS + "InstallationProfile")
+IDENTIFIER = URIRef(PROFILE_NS + "hasProfileIdentifier")
+IDENTIFIER_TYPE = URIRef(PROFILE_NS + "ProfileIdentifier")
+VERSION = URIRef(PROFILE_NS + "hasProfileVersion")
+VERSION_TYPE = URIRef(PROFILE_NS + "ProfileVersion")
+CAPABILITY = URIRef(PROFILE_NS + "hasCapabilityRequest")
+CAPABILITY_TYPE = URIRef(PROFILE_NS + "CapabilityRequest")
+POST_INSTALL_VERIFICATION = URIRef(PROFILE_NS + "hasPostInstallVerificationCapability")
+POST_INSTALL_VERIFICATION_TYPE = URIRef(PROFILE_NS + "PostInstallVerificationCapability")
+SUPPORTED_VERSION = Version("1.0.0")
+
+
+def _attribute_values(dataset: Dataset, subject: URIRef, relation: URIRef, attribute_type: URIRef) -> list[object]:
+    nodes = sorted({obj for _, _, obj, _ in dataset.quads((subject, relation, None, None))}, key=str)
+    values: list[object] = []
+    for node in nodes:
+        if isinstance(node, Literal):
+            raise ResolverError("PROFILE_INVALID", "profile relations must target typed attribute nodes")
+        predicates = {predicate for _, predicate, _, _ in dataset.quads((node, None, None, None))}
+        types = {obj for _, _, obj, _ in dataset.quads((node, RDF.type, None, None))}
+        node_values = {obj for _, _, obj, _ in dataset.quads((node, RDF.value, None, None))}
+        if predicates != {RDF.type, RDF.value} or types != {attribute_type} or len(node_values) != 1:
+            raise ResolverError("PROFILE_INVALID", "profile attribute structure is outside the canonical model")
+        values.append(next(iter(node_values)))
+    return values
+
+
+def _profile(path: Path, requested_iri: str | None = None) -> dict[str, object]:
+    dataset = Dataset()
+    try:
+        dataset.parse(path, format="trig")
+    except Exception as error:
+        raise ResolverError("PROFILE_INVALID", "profile document is not valid TriG") from error
+    subjects = sorted({subject for subject, _, _, _ in dataset.quads((None, RDF.type, INSTALLATION_PROFILE, None)) if isinstance(subject, URIRef)}, key=str)
+    if len(subjects) != 1:
+        raise ResolverError("PROFILE_INVALID", "profile document must contain exactly one InstallationProfile subject")
+    subject = subjects[0]
+    if requested_iri is not None and str(subject) != requested_iri:
+        raise ResolverError("PROFILE_INVALID", "profile subject does not match requested profile IRI")
+    allowed_predicates = {RDF.type, SKOS.prefLabel, SKOS.definition, IDENTIFIER, VERSION, CAPABILITY, POST_INSTALL_VERIFICATION}
+    predicates = {predicate for _, predicate, _, _ in dataset.quads((subject, None, None, None))}
+    types = {obj for _, _, obj, _ in dataset.quads((subject, RDF.type, None, None))}
+    labels = {obj for _, _, obj, _ in dataset.quads((subject, SKOS.prefLabel, None, None))}
+    definitions = {obj for _, _, obj, _ in dataset.quads((subject, SKOS.definition, None, None))}
+    if predicates - allowed_predicates or types != {INSTALLATION_PROFILE}:
+        raise ResolverError("PROFILE_INVALID", "profile structure is outside the canonical model")
+    if len(labels) != 1 or len(definitions) != 1 or any(not isinstance(item, Literal) or not item.value for item in labels | definitions):
+        raise ResolverError("PROFILE_INVALID", "profile documentation is outside the canonical model")
+    identifiers = _attribute_values(dataset, subject, IDENTIFIER, IDENTIFIER_TYPE)
+    versions = _attribute_values(dataset, subject, VERSION, VERSION_TYPE)
+    capabilities = sorted(_attribute_values(dataset, subject, CAPABILITY, CAPABILITY_TYPE), key=str)
+    verification = _attribute_values(dataset, subject, POST_INSTALL_VERIFICATION, POST_INSTALL_VERIFICATION_TYPE)
+    attribute_nodes = {obj for relation in (IDENTIFIER, VERSION, CAPABILITY, POST_INSTALL_VERIFICATION) for _, _, obj, _ in dataset.quads((subject, relation, None, None))}
+    document_subjects = {item for item, _, _, _ in dataset.quads((None, None, None, None))}
+    if document_subjects != {subject, *attribute_nodes}:
+        raise ResolverError("PROFILE_INVALID", "profile document contains subjects outside the canonical model")
+    if len(identifiers) != 1 or len(versions) != 1 or not capabilities or any(not isinstance(item, URIRef) for item in capabilities):
+        raise ResolverError("PROFILE_INVALID", "profile identity, version, or capabilities are invalid")
+    identifier = identifiers[0]
+    version = versions[0]
+    if not isinstance(identifier, Literal) or not isinstance(version, Literal) or not identifier.value or not version.value:
+        raise ResolverError("PROFILE_INVALID", "profile identity and version must be literals")
+    try:
+        parsed_version = Version(str(version))
+    except InvalidVersion as error:
+        raise ResolverError("PROFILE_INVALID", "profile version is not a supported semantic version") from error
+    if parsed_version != SUPPORTED_VERSION:
+        raise ResolverError("PROFILE_INVALID", "profile semantic version is unsupported")
+    capability_iris = [str(item) for item in capabilities]
+    if capability_iris != sorted(capability_iris) or len(capability_iris) != len(set(capability_iris)):
+        raise ResolverError("PROFILE_INVALID", "capabilities are not canonical and unique")
+    if any(not re.fullmatch(r"urn:cf:service:[A-Za-z][A-Za-z0-9]*", item) for item in capability_iris):
+        raise ResolverError("PROFILE_INVALID", "profile capability contains package or path data")
+    canonical_bytes = path.read_bytes().replace(b"\r\n", b"\n")
+    if len(verification) > 1 or any(not isinstance(item, URIRef) for item in verification):
+        raise ResolverError("PROFILE_INVALID", "post-install verification capability is ambiguous")
+    if verification and str(verification[0]) not in capability_iris:
+        raise ResolverError("PROFILE_INVALID", "post-install verification capability is not requested")
+    return {"profile": str(subject), "identifier": str(identifier), "version": str(version), "capabilities": capability_iris, "post_install_verification_capability": str(verification[0]) if verification else None, "sha256": hashlib.sha256(canonical_bytes).hexdigest()}
+
+
+def load_catalog(checkout: Path, profile_iri: str) -> dict[str, object]:
+    checkout = checkout.resolve()
+    root = (checkout / "stonecastle" / "profiles").resolve()
+    if not root.is_dir() or not re.fullmatch(r"urn:cf:profile:[A-Za-z0-9.-]+", profile_iri):
+        raise ResolverError("PROFILE_INVALID", "profile catalog root or profile IRI is invalid")
+    catalog_path = root / "profiles.index.json"
+    try:
+        catalog = json.loads(catalog_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ResolverError("PROFILE_INVALID", "profile catalog index is invalid") from error
+    if set(catalog) != {"schema", "profiles"} or catalog["schema"] != "cf.installation-profile-catalog.v1" or not isinstance(catalog["profiles"], list):
+        raise ResolverError("PROFILE_INVALID", "profile catalog schema is invalid")
+    actual_paths = sorted(path.relative_to(checkout).as_posix() for path in root.glob("*.trig"))
+    indexed_paths = sorted(item.get("path") for item in catalog["profiles"] if isinstance(item, dict))
+    if actual_paths != indexed_paths or any(not isinstance(path, str) or not path.startswith("stonecastle/profiles/") or ".." in Path(path).parts for path in indexed_paths):
+        raise ResolverError("PROFILE_INVALID", "profile catalog does not exactly cover indexed profiles")
+    entries = []
+    for item in catalog["profiles"]:
+        if set(item) != {"profile", "path", "sha256"}:
+            raise ResolverError("PROFILE_INVALID", "profile catalog entry fields are invalid")
+        path = checkout / item["path"]
+        if not path.is_file() or path.is_symlink():
+            raise ResolverError("PROFILE_INVALID", "catalog profile path is missing or redirected")
+        parsed = _profile(path, str(item["profile"]))
+        if parsed["sha256"] != item["sha256"]:
+            raise ResolverError("PROFILE_INVALID", "profile digest mismatch")
+        entries.append({**parsed, "path": item["path"]})
+    if len({item["profile"] for item in entries}) != len(entries) or len({item["identifier"] for item in entries}) != len(entries):
+        raise ResolverError("PROFILE_AMBIGUOUS", "profile catalog contains duplicate identity")
+    matches = [item for item in entries if item["profile"] == profile_iri]
+    if not matches:
+        raise ResolverError("PROFILE_NOT_FOUND", "requested profile is not in the catalog")
+    return {"profile": matches[0], "catalog": catalog, "catalog_digest": "sha256:" + hashlib.sha256(canonical_json(catalog)).hexdigest()}