cf-bootstrap-source-pypi 0.1.8__py3-none-any.whl

cf_bootstrap_source_pypi/__init__.py

@@ -0,0 +1,20 @@
+"""Deterministic PyPI artifact resolver and semantic package surface."""
+
+from pathlib import Path
+
+PACKAGE_DISTRIBUTION = "cf-bootstrap-source-pypi"
+PYTHON_PACKAGE = "cf_bootstrap_source_pypi"
+PACKAGE_VERSION = "0.1.8"
+__version__ = "0.1.8"
+
+
+def package_root() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def semantics_dir() -> Path:
+    return package_root() / "semantics"
+
+
+def semantic_files() -> tuple[Path, ...]:
+    return (semantics_dir() / "package.trig",)

cf_bootstrap_source_pypi/artifacts.py

@@ -0,0 +1,60 @@
+"""Wheel and publication validation."""
+
+from __future__ import annotations
+
+import base64
+import csv
+import hashlib
+from io import TextIOWrapper
+from pathlib import Path
+import re
+import zipfile
+
+from .model import ResolverError, normalize_distribution
+
+
+def _safe(name: str) -> bool:
+    return bool(name) and not name.startswith(("/", "\\")) and not re.match(r"^[A-Za-z]:", name) and ".." not in Path(name).parts and ".." not in name.replace("\\", "/").split("/")
+
+
+def validate_wheel(path: Path, expected: dict[str, object]) -> None:
+    try:
+        with zipfile.ZipFile(path) as wheel:
+            names = wheel.namelist()
+            if len(names) != len(set(names)) or any(not _safe(name) for name in names):
+                raise ResolverError("ARTIFACT_INVALID", "wheel contains unsafe or duplicate ZIP paths")
+            dist_infos = [name for name in names if name.endswith(".dist-info/METADATA")]
+            wheel_infos = [name for name in names if name.endswith(".dist-info/WHEEL")]
+            records = [name for name in names if name.endswith(".dist-info/RECORD")]
+            if len(dist_infos) != 1 or len(wheel_infos) != 1 or len(records) != 1:
+                raise ResolverError("ARTIFACT_INVALID", "wheel metadata files are incomplete")
+            metadata = wheel.read(dist_infos[0]).decode("utf-8")
+            fields = {}
+            for line in metadata.splitlines():
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    fields.setdefault(key.lower(), value.strip())
+            if normalize_distribution(fields.get("name", "")) != expected["normalized_distribution"] or fields.get("version") != expected["version"]:
+                raise ResolverError("ARTIFACT_INVALID", "wheel metadata does not match the report")
+            if any(name.endswith("direct_url.json") or name.endswith(".pth") for name in names):
+                raise ResolverError("ARTIFACT_INVALID", "wheel contains a forbidden direct URL or .pth file")
+            record_name = records[0]
+            checked: set[str] = set()
+            with TextIOWrapper(wheel.open(record_name), encoding="utf-8", newline="") as stream:
+                for row in csv.reader(stream):
+                    if len(row) != 3 or row[0] in checked or row[0] not in names:
+                        raise ResolverError("ARTIFACT_INVALID", "wheel RECORD coverage is invalid")
+                    checked.add(row[0])
+                    if row[0] == record_name:
+                        if row[1] or row[2]:
+                            raise ResolverError("ARTIFACT_INVALID", "RECORD self-entry is invalid")
+                    else:
+                        data = wheel.read(row[0])
+                        if row[1] != "sha256=" + base64.urlsafe_b64encode(hashlib.sha256(data).digest()).decode().rstrip("=") or row[2] != str(len(data)):
+                            raise ResolverError("ARTIFACT_INVALID", "RECORD hash or size is invalid")
+            if checked != set(names):
+                raise ResolverError("ARTIFACT_INVALID", "RECORD does not cover the wheel")
+    except zipfile.BadZipFile as error:
+        raise ResolverError("ARTIFACT_INVALID", "artifact is not a valid wheel") from error
+    if hashlib.sha256(path.read_bytes()).hexdigest() != expected["sha256"] or path.stat().st_size <= 0 or ("size_bytes" in expected and path.stat().st_size != expected["size_bytes"]):
+        raise ResolverError("ARTIFACT_INVALID", "wheel hash or size is invalid")

cf_bootstrap_source_pypi/index_url.py

@@ -0,0 +1,37 @@
+"""Validation for the single explicit package index."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+from urllib.parse import unquote, urlparse
+from urllib.request import url2pathname
+
+from .model import ResolverError
+
+DEFAULT_INDEX = "https://pypi.org/simple"
+
+
+def validate_index_url(value: object) -> str:
+    if not isinstance(value, str) or not value or any(char.isspace() for char in value):
+        raise ResolverError("INDEX_URL_INVALID", "index URL is invalid")
+    parsed = urlparse(value)
+    if parsed.scheme == "https":
+        if not parsed.netloc or parsed.username or parsed.password or parsed.query or parsed.fragment:
+            raise ResolverError("INDEX_URL_INVALID", "HTTPS index URL must not contain credentials, query, or fragment")
+        return value.rstrip("/")
+    if parsed.scheme == "file":
+        if parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.netloc not in ("", "localhost"):
+            raise ResolverError("INDEX_URL_INVALID", "file index URL is not local and absolute")
+        decoded = unquote(parsed.path)
+        if "\x00" in decoded or ".." in decoded.replace("\\", "/").split("/"):
+            raise ResolverError("INDEX_URL_INVALID", "file index URL contains unsafe path segments")
+        path = Path(url2pathname(decoded))
+        if sys.platform == "win32" and decoded.startswith("/") and len(decoded) > 3 and decoded[2] == ":":
+            path = Path(url2pathname(decoded[1:]))
+        if not path.is_absolute() or not path.is_dir():
+            raise ResolverError("INDEX_URL_INVALID", "file index URL must point to an existing directory")
+        if any(parent.is_symlink() for parent in (path, *path.parents)):
+            raise ResolverError("INDEX_URL_INVALID", "file index URL must not traverse symlinks")
+        return value.rstrip("/")
+    raise ResolverError("INDEX_URL_INVALID", "only HTTPS and local file indexes are supported")

cf_bootstrap_source_pypi/lockfile.py

@@ -0,0 +1,18 @@
+"""Canonical hash-locked requirements generation."""
+
+from __future__ import annotations
+
+import hashlib
+
+from .model import ResolverError
+
+
+def render_lock(artifacts: list[dict[str, object]]) -> bytes:
+    if not artifacts:
+        raise ResolverError("REPORT_INVALID", "cannot create an empty lock")
+    lines = [f"{item['normalized_distribution']}=={item['version']} --hash=sha256:{item['sha256']}" for item in sorted(artifacts, key=lambda item: str(item["normalized_distribution"]))]
+    return ("\n".join(lines) + "\n").encode("utf-8")
+
+
+def lock_digest(lock: bytes) -> str:
+    return hashlib.sha256(lock).hexdigest()

cf_bootstrap_source_pypi/model.py

@@ -0,0 +1,80 @@
+"""Protocol, request, and canonical serialization helpers."""
+
+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.pypi-artifact-resolution.request.v1"
+RESULT_SCHEMA = "cf.bootstrap.pypi-artifact-resolution.v1"
+ARTIFACT_SET_SCHEMA = "cf.bootstrap.pypi-artifact-set.v1"
+PLAN_SCHEMA = "cf.bootstrap.plan.v1"
+_NAME = re.compile(r"[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?\Z")
+_VERSION = re.compile(r"[0-9]+(?:\.[0-9]+){0,2}(?:[-+][A-Za-z0-9.-]+)?\Z")
+
+
+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:
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def _absolute_path(value: object, label: str) -> Path:
+    if not isinstance(value, str) or not value or "\x00" in value or ".." in PurePosixPath(value).parts or ".." in PureWindowsPath(value).parts:
+        raise ResolverError("SCHEMA_INVALID", f"{label} is unsafe")
+    parsed = PureWindowsPath(value) if PureWindowsPath(value).drive or "\\" in value else PurePosixPath(value)
+    if not parsed.is_absolute() or str(parsed) == parsed.anchor:
+        raise ResolverError("SCHEMA_INVALID", f"{label} must be an absolute non-root path")
+    return Path(value)
+
+
+def _inside(child: Path, parent: Path) -> bool:
+    try:
+        child.resolve().relative_to(parent.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def parse_request(value: object) -> tuple[dict[str, Any], Path, str]:
+    if not isinstance(value, dict):
+        raise ResolverError("SCHEMA_INVALID", "request must be an object")
+    fields = {"schema", "bootstrap_plan", "artifact_output_root", "index_url"}
+    if set(value) - fields:
+        raise ResolverError("UNKNOWN_REQUEST_FIELD", "request contains unknown fields")
+    if set(value) != fields or value.get("schema") != REQUEST_SCHEMA:
+        raise ResolverError("SCHEMA_INVALID", "request schema is invalid")
+    plan = value.get("bootstrap_plan")
+    plan_fields = {"schema", "instance_id", "installation_root", "cogniflow_home", "artifact_source", "stages"}
+    profiled_fields = plan_fields | {"profile"}
+    valid_plan = isinstance(plan, dict) and ((set(plan) == plan_fields and plan.get("schema") == PLAN_SCHEMA) or (set(plan) == profiled_fields and plan.get("schema") == "cf.bootstrap.plan.v2"))
+    if not valid_plan:
+        raise ResolverError("SCHEMA_INVALID", "bootstrap plan schema is invalid")
+    source = plan.get("artifact_source")
+    if not isinstance(source, dict) or set(source) != {"mode", "package", "version"} or source.get("mode") != "pypi":
+        raise ResolverError("SOURCE_INVALID", "plan source must be pypi")
+    if not isinstance(source["package"], str) or not _NAME.fullmatch(source["package"]):
+        raise ResolverError("SOURCE_INVALID", "package name is invalid")
+    if not isinstance(source["version"], str) or not _VERSION.fullmatch(source["version"]):
+        raise ResolverError("SOURCE_INVALID", "exact package version is invalid")
+    output = _absolute_path(value.get("artifact_output_root"), "artifact_output_root")
+    for key in ("installation_root", "cogniflow_home"):
+        if not isinstance(plan.get(key), str):
+            raise ResolverError("SCHEMA_INVALID", f"{key} is invalid")
+        if _inside(output, _absolute_path(plan[key], key)):
+            raise ResolverError("SCHEMA_INVALID", "artifact output is inside a protected path")
+    if output.exists() and output.is_symlink():
+        raise ResolverError("OUTPUT_CONFLICT", "artifact output must not be a symlink")
+    from .index_url import validate_index_url
+    return plan, output, validate_index_url(value["index_url"])

cf_bootstrap_source_pypi/pip_runner.py

@@ -0,0 +1,34 @@
+"""Controlled external pip invocations."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+
+from .model import ResolverError
+
+
+def _environment(temp_root: Path) -> dict[str, str]:
+    env = dict(os.environ)
+    for key in ("PYTHONPATH", "PYTHONHOME", "PIP_INDEX_URL", "PIP_EXTRA_INDEX_URL", "PIP_FIND_LINKS", "PIP_TRUSTED_HOST", "PIP_REQUIREMENT", "PIP_CONSTRAINT", "PIP_BUILD_CONSTRAINT", "PIP_TARGET", "PIP_PREFIX", "PIP_ROOT", "PIP_USER", "PIP_EDITABLE", "PIP_PRE", "PIP_NO_BINARY", "PIP_ONLY_BINARY", "PIP_NO_DEPS", "PIP_REPORT", "PIP_DRY_RUN"):
+        env.pop(key, None)
+    null_config = "NUL" if os.name == "nt" else "/dev/null"
+    env.update({"PIP_CONFIG_FILE": null_config, "PIP_DISABLE_PIP_VERSION_CHECK": "1", "PIP_NO_CACHE_DIR": "1", "PIP_NO_INPUT": "1", "PYTHONDONTWRITEBYTECODE": "1", "HOME": str(temp_root / "home"), "USERPROFILE": str(temp_root / "home"), "XDG_CACHE_HOME": str(temp_root / "cache"), "TMPDIR": str(temp_root), "TEMP": str(temp_root), "TMP": str(temp_root)})
+    return env
+
+
+def run_pip(arguments: list[str], temp_root: Path, timeout: float = 120.0) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run([sys.executable, "-m", "pip", "--isolated", *arguments], cwd=str(temp_root), env=_environment(temp_root), text=True, capture_output=True, timeout=timeout, check=False)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        raise ResolverError("RESOLUTION_TOOL_UNAVAILABLE", "pip process was unavailable or timed out") from error
+
+
+def pip_version(temp_root: Path) -> str:
+    result = run_pip(["--version"], temp_root)
+    if result.returncode or not result.stdout.startswith("pip "):
+        raise ResolverError("RESOLUTION_TOOL_UNAVAILABLE", "pip version could not be determined")
+    return result.stdout.split()[1]

cf_bootstrap_source_pypi/report.py

@@ -0,0 +1,69 @@
+"""Strict validation and canonical extraction of pip report version 1."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import PurePosixPath, PureWindowsPath
+import re
+from urllib.parse import unquote, urlparse
+
+from .model import ResolverError, normalize_distribution
+
+_ENVIRONMENT = ("implementation_name", "implementation_version", "os_name", "platform_machine", "platform_system", "python_full_version", "python_version", "platform_python_implementation", "sys_platform")
+_HASH = re.compile(r"[0-9a-f]{64}\Z")
+
+
+def parse_report(raw: bytes, package: str, version: str) -> tuple[dict[str, object], str]:
+    try:
+        report = json.loads(raw)
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise ResolverError("REPORT_INVALID", "pip report is not valid JSON") from error
+    if not isinstance(report, dict) or report.get("version") != "1" or not isinstance(report.get("pip_version"), str) or not report["pip_version"] or not isinstance(report.get("install"), list) or not report["install"] or not isinstance(report.get("environment"), dict) or any(not isinstance(report["environment"].get(key), str) for key in _ENVIRONMENT):
+        raise ResolverError("UNSUPPORTED_REPORT_VERSION" if isinstance(report, dict) and report.get("version") != "1" else "REPORT_INVALID", "pip report does not match the supported schema")
+    expected = normalize_distribution(package)
+    roots = []
+    artifacts: list[dict[str, object]] = []
+    names: set[str] = set()
+    filenames: set[str] = set()
+    for item in report["install"]:
+        if not isinstance(item, dict) or item.get("requested") is not False and item.get("requested") is not True:
+            raise ResolverError("REPORT_INVALID", "report entry is invalid")
+        metadata = item.get("metadata")
+        info = item.get("download_info")
+        if not isinstance(metadata, dict) or not isinstance(info, dict) or not isinstance(metadata.get("name"), str) or not isinstance(metadata.get("version"), str):
+            raise ResolverError("REPORT_INVALID", "report metadata is invalid")
+        normalized = normalize_distribution(metadata["name"])
+        if normalized in names:
+            raise ResolverError("REPORT_INVALID", "report contains duplicate distributions")
+        names.add(normalized)
+        if item.get("is_direct") is not False or item.get("is_yanked") is not False:
+            raise ResolverError("DIRECT_SOURCE_REJECTED" if item.get("is_direct") else "YANKED_ARTIFACT_REJECTED", "report contains a forbidden source")
+        if item.get("requested_extras") not in (None, [], ()):
+            raise ResolverError("DIRECT_SOURCE_REJECTED", "report contains requested extras")
+        url = info.get("url")
+        parsed = urlparse(url) if isinstance(url, str) else None
+        decoded_path = unquote(parsed.path) if parsed is not None else ""
+        if parsed is None or parsed.scheme not in ("https", "file") or parsed.username or parsed.password or parsed.query or parsed.fragment or not decoded_path.lower().endswith(".whl") or any(part in ("", ".", "..") for part in decoded_path.replace("\\", "/").split("/") if part == "..") or "/" in unquote(parsed.path.rsplit("/", 1)[-1]) or "\\" in unquote(parsed.path.rsplit("/", 1)[-1]):
+            raise ResolverError("SOURCE_DISTRIBUTION_REJECTED", "report artifact is not a wheel URL")
+        hashes = info.get("archive_info", {}).get("hashes") if isinstance(info.get("archive_info"), dict) else None
+        digest = hashes.get("sha256") if isinstance(hashes, dict) else None
+        if not isinstance(digest, str) or not _HASH.fullmatch(digest):
+            raise ResolverError("HASH_UNAVAILABLE", "report artifact has no SHA-256")
+        filename = unquote(parsed.path.rsplit("/", 1)[-1])
+        if not filename or filename in filenames or "/" in filename or "\\" in filename or PureWindowsPath(filename).drive or ".." in PurePosixPath(filename).parts:
+            raise ResolverError("REPORT_INVALID", "report contains an unsafe or duplicate wheel filename")
+        filenames.add(filename)
+        entry = {"distribution": metadata["name"], "normalized_distribution": normalized, "version": metadata["version"], "filename": filename, "sha256": digest, "requested": bool(item["requested"]), "url": url}
+        artifacts.append(entry)
+        if item["requested"]:
+            roots.append(entry)
+    if len(roots) != 1 or roots[0]["normalized_distribution"] != expected or roots[0]["version"] != version:
+        raise ResolverError("REPORT_INVALID", "report root does not match the requested exact requirement")
+    if any(item["requested"] for item in artifacts if item is not roots[0]):
+        raise ResolverError("REPORT_INVALID", "report contains multiple roots")
+    environment = {key: report["environment"][key] for key in _ENVIRONMENT}
+    selected = [{key: item[key] for key in ("distribution", "normalized_distribution", "version", "filename", "sha256", "requested")} for item in sorted(artifacts, key=lambda item: (item["normalized_distribution"], item["version"], item["filename"]))]
+    canonical = {"pip_report_version": "1", "pip_version": report["pip_version"], "environment": environment, "artifacts": selected}
+    digest = "sha256:" + hashlib.sha256(json.dumps(canonical, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    return {"pip_report_version": "1", "pip_version": report["pip_version"], "environment": environment, "artifacts": artifacts}, digest

cf_bootstrap_source_pypi/resolver.py

@@ -0,0 +1,147 @@
+"""JSON-lines entry point and transactional PyPI resolver."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+
+from .artifacts import validate_wheel
+from .lockfile import lock_digest, render_lock
+from .model import ARTIFACT_SET_SCHEMA, PROTOCOL, RESULT_SCHEMA, ResolverError, canonical_json, normalize_distribution, parse_request
+from .pip_runner import pip_version, run_pip
+from .report import parse_report
+
+_FIELDS = {"jsonrpc", "protocol", "id", "method", "params"}
+
+
+def _response(identifier: object, **body: object) -> dict[str, object]:
+    return {"jsonrpc": "2.0", "protocol": PROTOCOL, "id": identifier, **body}
+
+
+def _manifest(plan: dict[str, object], report: dict[str, object], digest: str, lock: bytes, artifacts: list[dict[str, object]]) -> dict[str, object]:
+    source = plan["artifact_source"]
+    environment = report["environment"]
+    entries = []
+    for item in sorted(artifacts, key=lambda value: (str(value["normalized_distribution"]), str(value["filename"]))):
+        entries.append({"distribution": item["distribution"], "normalized_distribution": item["normalized_distribution"], "version": item["version"], "filename": item["filename"], "sha256": item["sha256"], "size_bytes": item["size_bytes"], "requested": item["requested"]})
+    root = {"distribution": source["package"], "normalized_distribution": normalize_distribution(source["package"]), "version": source["version"]}
+    return {"schema": ARTIFACT_SET_SCHEMA, "source_mode": "pypi", "root_requirement": root, "resolver": {"pip_report_version": "1", "pip_version": report["pip_version"]}, "target_environment": environment, "resolution_digest": digest, "lock_sha256": lock_digest(lock), "artifacts": entries}
+
+
+def _existing(output: Path, expected: dict[str, object]) -> dict[str, object] | None:
+    if not output.exists():
+        return None
+    if not output.is_dir() or output.is_symlink():
+        raise ResolverError("OUTPUT_CONFLICT", "artifact output is not a real directory")
+    try:
+        manifest_path = output / "artifact-set.json"
+        lock_path = output / "requirements.lock"
+        value = json.loads(manifest_path.read_bytes())
+        if manifest_path.read_bytes() != canonical_json(value) or lock_path.read_bytes() != expected["lock"] or value != expected["manifest"]:
+            raise ResolverError("OUTPUT_CONFLICT", "existing artifact output differs from the current resolution")
+        names = {item["filename"] for item in value["artifacts"]}
+        if {child.name for child in output.iterdir()} != names | {"artifact-set.json", "requirements.lock"}:
+            raise ResolverError("OUTPUT_CONFLICT", "existing wheelhouse contains unexpected files")
+        for item in value["artifacts"]:
+            validate_wheel(output / item["filename"], item)
+        return value
+    except ResolverError:
+        raise
+    except (OSError, ValueError, KeyError) as error:
+        raise ResolverError("OUTPUT_CONFLICT", "existing artifact output is invalid") from error
+
+
+def resolve(params: object) -> dict[str, object]:
+    plan, output, index_url = parse_request(params)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="cf-bootstrap-source-pypi-", dir=str(output.parent)) as temporary:
+        temp = Path(temporary)
+        report_path = temp / "report.json"
+        root = plan["artifact_source"]
+        install_args = ["install", "--dry-run", "--ignore-installed", "--quiet", "--report", str(report_path), "--only-binary=:all:", "--index-url", index_url, "--no-cache-dir", "--disable-pip-version-check", "--no-input", f"{root['package']}=={root['version']}"]
+        resolution = run_pip(install_args, temp)
+        if resolution.returncode or not report_path.is_file():
+            raise ResolverError("RESOLUTION_FAILED", "pip could not resolve the requested wheel closure")
+        report, resolution_digest = parse_report(report_path.read_bytes(), root["package"], root["version"])
+        lock = render_lock(report["artifacts"])
+        lock_path = temp / "requirements.lock"
+        lock_path.write_bytes(lock)
+        wheelhouse = temp / "wheelhouse"
+        wheelhouse.mkdir()
+        download_args = ["download", "--no-deps", "--only-binary=:all:", "--require-hashes", "--index-url", index_url, "--no-cache-dir", "--disable-pip-version-check", "--no-input", "--dest", str(wheelhouse), "--requirement", str(lock_path)]
+        downloaded = run_pip(download_args, temp)
+        if downloaded.returncode:
+            raise ResolverError("DOWNLOAD_FAILED", "pip could not download the hash-locked closure")
+        files = list(wheelhouse.iterdir())
+        by_name = {item.name: item for item in files if item.is_file()}
+        if len(files) != len(report["artifacts"]) or set(by_name) != {item["filename"] for item in report["artifacts"]}:
+            raise ResolverError("ARTIFACT_SET_MISMATCH", "downloaded wheel set differs from the report")
+        checked = []
+        for item in report["artifacts"]:
+            path = by_name[item["filename"]]
+            checked_item = dict(item)
+            checked_item["size_bytes"] = path.stat().st_size
+            validate_wheel(path, checked_item)
+            checked.append(checked_item)
+        execution_pip_version = pip_version(temp)
+        if execution_pip_version != report["pip_version"]:
+            raise ResolverError("REPORT_INVALID", "pip version changed during resolution")
+        manifest = _manifest(plan, report, resolution_digest, lock, checked)
+        expected = {"manifest": manifest, "lock": lock}
+        existing = _existing(output, expected)
+        if existing is not None:
+            return {"schema": RESULT_SCHEMA, "wheelhouse_path": str(output), "artifact_set": existing, "lock_filename": "requirements.lock"}
+        staging = Path(tempfile.mkdtemp(prefix="cf-bootstrap-source-pypi-publish-", dir=str(output.parent)))
+        try:
+            for path in by_name.values():
+                shutil.copy2(path, staging / path.name)
+            (staging / "requirements.lock").write_bytes(lock)
+            (staging / "artifact-set.json").write_bytes(canonical_json(manifest))
+            staging.rename(output)
+        except FileExistsError as error:
+            shutil.rmtree(staging, ignore_errors=True)
+            raise ResolverError("OUTPUT_CONFLICT", "artifact output appeared during publication") from error
+        except OSError as error:
+            shutil.rmtree(staging, ignore_errors=True)
+            raise ResolverError("INTERNAL_ERROR", "artifact publication failed") from error
+    return {"schema": RESULT_SCHEMA, "wheelhouse_path": str(output), "artifact_set": manifest, "lock_filename": "requirements.lock"}
+
+
+def handle(payload: object) -> dict[str, object]:
+    identifier = payload.get("id") if isinstance(payload, dict) else None
+    try:
+        if not isinstance(payload, dict):
+            raise ResolverError("INVALID_ENVELOPE", "request envelope must be an object")
+        if set(payload) - _FIELDS or set(payload) != _FIELDS:
+            raise ResolverError("UNKNOWN_ENVELOPE_FIELD" if set(payload) - _FIELDS else "INVALID_ENVELOPE", "request envelope fields are invalid")
+        if payload.get("jsonrpc") != "2.0" or not isinstance(payload.get("id"), (str, int)) or isinstance(payload.get("id"), bool):
+            raise ResolverError("INVALID_ENVELOPE", "request identity is invalid")
+        if payload.get("protocol") != PROTOCOL:
+            raise ResolverError("PROTOCOL_VERSION_UNSUPPORTED", "unsupported resolver protocol")
+        if payload.get("method") != "artifacts/resolve":
+            raise ResolverError("UNKNOWN_OPERATION", "unknown resolver operation")
+        return _response(identifier, result=resolve(payload["params"]))
+    except ResolverError as error:
+        return _response(identifier, error={"code": error.code, "message": str(error)})
+    except Exception:
+        return _response(identifier, error={"code": "INTERNAL_ERROR", "message": "resolver failed unexpectedly"})
+
+
+def main() -> int:
+    for line in sys.stdin:
+        try:
+            payload = json.loads(line)
+            response = handle(payload)
+        except json.JSONDecodeError:
+            response = _response(None, error={"code": "MALFORMED_JSON", "message": "request must be valid JSON"})
+        sys.stdout.write(canonical_json(response).decode())
+        sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cf_bootstrap_source_pypi/semantics/package.trig

@@ -0,0 +1,13 @@
+@prefix cfpkg: <https://cogniflow.odea-project.org/cf#> .
+@prefix contribution: <urn:cf:contribution:> .
+@prefix pkg: <urn:cf:pkg:> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+
+pkg:cf_bootstrap_source_pypi {
+  pkg:cf_bootstrap_source_pypi a cfpkg:CfPackage ;
+    cfpkg:hasPackageManifest [ a cfpkg:PackageManifest ; cfpkg:hasDistributionName [ a cfpkg:DistributionName ; rdf:value "cf-bootstrap-source-pypi" ] ; cfpkg:hasPythonPackageName [ a cfpkg:PythonPackageName ; rdf:value "cf_bootstrap_source_pypi" ] ; cfpkg:hasPackageVersion [ a cfpkg:PackageVersion ; rdf:value "0.1.8" ] ; cfpkg:hasImplementationLanguage [ a cfpkg:ImplementationLanguage ; rdf:value "Python" ] ] ;
+    cfpkg:hasPackageRole [ a cfpkg:PackageRole ; rdf:value cfpkg:SpecificationPackageRole ] ;
+    cfpkg:hasPackageContribution contribution:adopted_package ;
+    skos:prefLabel "cf-bootstrap-source-pypi" ; skos:definition "An adopted Cogniflow package conforming to the basic package template." ; skos:scopeNote "Package semantics were restored through the package conformance repair service." ; skos:example "The installed package publishes its package.trig semantic source." .
+}

cf_bootstrap_source_pypi-0.1.8.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: cf-bootstrap-source-pypi
+Version: 0.1.8
+Summary: Deterministic wheel-only PyPI artifact resolver.
+License: GPL-3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# cf-bootstrap-source-pypi
+
+`cf-bootstrap-source-pypi` is the artifact-source adapter for resolving a pinned Cogniflow distribution from a Python package index. It validates a complete wheel-only dependency closure and publishes a deterministic artifact set for a separate instance provider to install.
+
+The console script communicates over `cf.bootstrap.artifact-resolver.v1` JSON lines. Inputs identify the package, exact version, index URL, and artifact output root. Outputs bind every accepted wheel to its filename, package metadata, size, and SHA-256 digest and record the resolver report.
+
+The package does not plan installations, choose installation profiles, import resolved packages, create target environments, or perform service handoff. Profile-driven PyPI installation is currently unavailable and the public launcher rejects that mode before orchestration; Local Repository Mode uses `cf-bootstrap-source-local` instead.

cf_bootstrap_source_pypi-0.1.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+cf_bootstrap_source_pypi/__init__.py,sha256=xo3-10QDvs0f5L_MD-Irwa1TI0otKrip6X-Tlu_r6Hs,497
+cf_bootstrap_source_pypi/artifacts.py,sha256=QYCvi9hhB0GskF7KYDuWAbS-kVaJSxUT31hQavri0fo,3556
+cf_bootstrap_source_pypi/index_url.py,sha256=nhm01U5pS5Jj_0PL3wtuEF2PKvhdegG_iJtJ7VdmfIY,1991
+cf_bootstrap_source_pypi/lockfile.py,sha256=wpVNBg9XJs9Pxt4DDBAL5XZpDbVVKddjUN4EC-2uDDk,642
+cf_bootstrap_source_pypi/model.py,sha256=20mu8qrIwyVUHmbBHFEIDGtfkEqLxQO630qzNFRBhbs,4083
+cf_bootstrap_source_pypi/pip_runner.py,sha256=C1axpZw2RyNfczv5PY_EI6X-Oqn7coSlakzqhm93QQM,1893
+cf_bootstrap_source_pypi/report.py,sha256=OrgKyspve2I7godfiba2ALIHM29JCJGxqmXXp-mkHqk,5555
+cf_bootstrap_source_pypi/resolver.py,sha256=biVnAxc7uxuNyYJKgmHDhzmgS4OxlqZNti5zp8Pb12Y,8671
+cf_bootstrap_source_pypi/semantics/package.trig,sha256=QZk5sQzHbyHoHnumK1ZH3R7nlig8BsZeK3nEPHiHjFU,1243
+cf_bootstrap_source_pypi-0.1.8.dist-info/METADATA,sha256=22HbAT5UnsQtxpTEOT532uknfpwXmsMLG9508yXQZKc,1142
+cf_bootstrap_source_pypi-0.1.8.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+cf_bootstrap_source_pypi-0.1.8.dist-info/entry_points.txt,sha256=q6fJPuDBkdmuLqynqP35UOl_YKXZ6NXyXexXAiUGkcA,271
+cf_bootstrap_source_pypi-0.1.8.dist-info/RECORD,,

cf_bootstrap_source_pypi-0.1.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cf_bootstrap_source_pypi-0.1.8.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+cf-bootstrap-source-pypi-resolver = cf_bootstrap_source_pypi.resolver:main
+
+[cogniflow.artifact_resolvers.v1]
+pypi = cf_bootstrap_source_pypi.resolver:main
+
+[cogniflow.semantic_sources]
+cf-bootstrap-source-pypi = cf_bootstrap_source_pypi:semantic_files