cf-bootstrap-instance 0.1.8__py3-none-any.whl

cf_bootstrap_instance/recovery.py

@@ -0,0 +1,380 @@
+"""Bootstrap-owned, pip-free restoration of the accepted minimum service plane."""
+from __future__ import annotations
+
+import configparser
+import hashlib
+import json
+import os
+import re
+from pathlib import Path
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import zipfile
+
+from .layout import read_marker
+
+SCHEMA = "cf.bootstrap.minimum-service-recovery.v2"
+RESULT_SCHEMA = "cf.bootstrap.minimum-service-recovery.result.v2"
+MANIFEST_SCHEMA = "cf.bootstrap.minimum-service-recovery-manifest.v2"
+MINIMUM_SERVICE_PLANE = frozenset({"cf-runtime", "cf-service-client", "cf-install-services", "cf-service-mcp-server", "packaging"})
+_SAFE_LAUNCHER_NAME = re.compile(r"[A-Za-z0-9._-]+\Z")
+
+
+def _canonical(value: object) -> bytes:
+    return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode()
+
+
+def _digest(value: object) -> str:
+    return "sha256:" + hashlib.sha256(_canonical(value)).hexdigest()
+
+
+def _safe_launcher_name(value: object, label: str) -> str:
+    if not isinstance(value, str) or not value or value != value.strip() or not _SAFE_LAUNCHER_NAME.fullmatch(value) or Path(value).name != value or value in {".", ".."}:
+        raise ValueError(f"{label} is unsafe")
+    return value
+
+
+def _launcher_script_name(target_name: str) -> str:
+    return _safe_launcher_name(target_name, "launcher target") + (".exe" if os.name == "nt" else "")
+
+
+def _launcher_retained_name(target_name: str) -> str:
+    suffix = ".exe" if os.name == "nt" else ""
+    return f"launcher-{_safe_launcher_name(target_name, 'launcher target')}{suffix}"
+
+
+def _link_free(path: Path, label: str) -> None:
+    current = path
+    while current != Path(current.anchor):
+        try:
+            value = os.lstat(current)
+        except FileNotFoundError:
+            current = current.parent
+            continue
+        if stat.S_ISLNK(value.st_mode) or (os.name == "nt" and getattr(value, "st_file_attributes", 0) & getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)):
+            raise ValueError(f"{label} contains a link or reparse point")
+        current = current.parent
+
+
+def _regular(path: Path, label: str, directory: bool = False) -> None:
+    _link_free(path, label)
+    if path.is_symlink() or not (path.is_dir() if directory else path.is_file()):
+        raise ValueError(f"{label} is missing or unsafe")
+    if os.name == "nt" and getattr(path.stat(), "st_file_attributes", 0) & getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400):
+        raise ValueError(f"{label} is a reparse point")
+
+
+def _load(path: Path, label: str) -> dict[str, object]:
+    _regular(path, label)
+    try:
+        raw = path.read_bytes()
+        value = json.loads(raw)
+        if raw != _canonical(value):
+            raise ValueError(f"{label} is not canonical")
+    except (OSError, ValueError, UnicodeDecodeError) as error:
+        raise ValueError(f"{label} is invalid") from error
+    if not isinstance(value, dict):
+        raise ValueError(f"{label} is invalid")
+    return value
+
+
+def _record(item: object) -> dict[str, object]:
+    if not isinstance(item, dict):
+        raise ValueError("pinned artifact record is invalid")
+    required = {"distribution", "normalized_distribution", "version", "filename", "sha256", "size", "source_kind"}
+    if set(item) not in (required, required | {"source_project"}, required | {"source_project", "artifact_kind", "wheel_tags", "executable"}):
+        raise ValueError("pinned artifact record is invalid")
+    if not all(isinstance(item.get(key), str) and item[key] for key in ("distribution", "normalized_distribution", "version", "filename", "sha256", "source_kind")):
+        raise ValueError("pinned artifact record is invalid")
+    if type(item["size"]) is not int or item["size"] < 1 or len(item["sha256"]) != 64:
+        raise ValueError("pinned artifact record is invalid")
+    filename = str(item["filename"])
+    if Path(filename).name != filename or not filename.endswith(".whl"):
+        raise ValueError("pinned artifact filename is invalid")
+    if item["source_kind"] not in {"stonecastle-local", "external-wheelhouse"}:
+        raise ValueError("pinned artifact source is invalid")
+    return item
+
+
+def _safe_member(name: str) -> bool:
+    path = Path(name)
+    return bool(name) and not path.is_absolute() and ".." not in path.parts and "\\" not in name and not name.startswith("/")
+
+
+def _target_layout(target: Path) -> tuple[Path, Path, Path]:
+    code = "import json,sysconfig; print(json.dumps([sysconfig.get_path('purelib'),sysconfig.get_path('platlib'),sysconfig.get_path('scripts')]))"
+    result = subprocess.run([str(target), "-c", code], check=True, capture_output=True, text=True, timeout=30)
+    values = json.loads(result.stdout)
+    if not isinstance(values, list) or len(values) != 3 or any(not isinstance(value, str) for value in values):
+        raise ValueError("target installation layout is invalid")
+    return tuple(Path(value).resolve() for value in values)  # type: ignore[return-value]
+
+
+def _within(path: Path, roots: tuple[Path, ...]) -> bool:
+    return any(path == root or root in path.parents for root in roots)
+
+
+def _wheel_files(wheel: Path, target: Path) -> dict[Path, bytes]:
+    purelib, platlib, scripts = _target_layout(target)
+    roots = (purelib, platlib, scripts, target.parent.parent.resolve())
+    with zipfile.ZipFile(wheel) as archive:
+        members = archive.infolist()
+        names = [member.filename for member in members]
+        if len(names) != len(set(names)) or any(not _safe_member(name) for name in names):
+            raise ValueError("wheel members are unsafe or duplicated")
+        dist_info = [name.rsplit("/", 1)[0] for name in names if name.endswith(".dist-info/WHEEL")]
+        if len(dist_info) != 1:
+            raise ValueError("wheel metadata is invalid")
+        metadata_root = dist_info[0]
+        metadata_name = metadata_root + "/METADATA"
+        record_name = metadata_root + "/RECORD"
+        if metadata_name not in names or record_name not in names:
+            raise ValueError("wheel metadata is incomplete")
+        metadata = archive.read(metadata_name).decode("utf-8")
+        fields = dict(line.split(": ", 1) for line in metadata.splitlines() if ": " in line)
+        if not fields.get("Name") or not fields.get("Version"):
+            raise ValueError("wheel metadata identity is invalid")
+        result: dict[Path, bytes] = {}
+        for member in members:
+            name = member.filename
+            if name.endswith("/"):
+                continue
+            relative = Path(name)
+            destination_root = purelib
+            if ".data/" in name:
+                _, category, tail = name.split("/", 2)
+                destination_root = {"purelib": purelib, "platlib": platlib, "scripts": scripts, "data": target.parent.parent.resolve()}.get(category)
+                if destination_root is None:
+                    raise ValueError("wheel data category is invalid")
+                relative = Path(tail)
+            elif name.startswith(metadata_root + "/"):
+                destination_root = purelib
+            destination = (destination_root / relative).resolve()
+            if not _within(destination, roots) or destination in result:
+                raise ValueError("wheel destination escaped or collided")
+            result[destination] = archive.read(member)
+        return result
+
+
+def _launcher_record(item: object) -> dict[str, object]:
+    if not isinstance(item, dict):
+        raise ValueError("launcher image record is invalid")
+    required = {"target_launcher", "retained_filename", "size", "sha256", "mode"}
+    if set(item) != required:
+        raise ValueError("launcher image record is invalid")
+    target = _safe_launcher_name(item["target_launcher"], "launcher target")
+    retained = _safe_launcher_name(item["retained_filename"], "retained launcher filename")
+    if retained != _launcher_retained_name(target):
+        raise ValueError("launcher image record is invalid")
+    if type(item["size"]) is not int or item["size"] < 0 or type(item["mode"]) is not int or item["mode"] < 0 or item["mode"] > 0o7777 or not isinstance(item["sha256"], str) or len(item["sha256"]) != 64:
+        raise ValueError("launcher image record is invalid")
+    return {"target_launcher": target, "retained_filename": retained, "size": item["size"], "sha256": item["sha256"], "mode": item["mode"]}
+
+
+def _launcher_targets(records: list[dict[str, object]]) -> set[str]:
+    targets: set[str] = set()
+    seen: set[str] = set()
+    for record in records:
+        wheel = Path(str(record["bundle"]))
+        with zipfile.ZipFile(wheel) as archive:
+            entry_points = [entry for entry in archive.namelist() if entry.endswith(".dist-info/entry_points.txt")]
+            if len(entry_points) > 1:
+                raise ValueError("recovery launcher metadata is invalid")
+            if not entry_points:
+                continue
+            parser = configparser.ConfigParser(interpolation=None)
+            parser.optionxform = str
+            parser.read_string(archive.read(entry_points[0]).decode("utf-8"))
+        if not parser.has_section("console_scripts"):
+            continue
+        for target_name, _target_value in parser.items("console_scripts", raw=True):
+            target = _safe_launcher_name(target_name, "launcher target")
+            key = target.casefold()
+            if key in seen:
+                raise ValueError("recovery launcher names are duplicated or invalid")
+            seen.add(key)
+            targets.add(target)
+    return targets
+
+
+def _restore(target: Path, records: list[dict[str, object]], launcher_records: list[dict[str, object]]) -> list[str]:
+    purelib, platlib, scripts = _target_layout(target)
+    environment = target.parent.parent.resolve()
+    staging = Path(tempfile.mkdtemp(prefix="cf-recovery-", dir=str(environment.parent)))
+    backup = staging / "backup"
+    shutil.copytree(environment, backup, dirs_exist_ok=True)
+    try:
+        expected_targets = _launcher_targets(records)
+        launcher_target_names = {str(record["target_launcher"]).casefold() for record in launcher_records}
+        if launcher_target_names != {name.casefold() for name in expected_targets}:
+            raise ValueError("recovery launcher metadata is incomplete")
+        planned: dict[Path, tuple[bytes, str, int | None]] = {}
+        for record in records:
+            wheel = Path(str(record["bundle"]))
+            _regular(wheel, f"pinned wheel {wheel.name}")
+            if wheel.stat().st_size != record["size"] or hashlib.sha256(wheel.read_bytes()).hexdigest() != record["sha256"]:
+                raise ValueError(f"pinned wheel verification failed: {wheel.name}")
+            for path, data in _wheel_files(wheel, target).items():
+                existing = planned.get(path)
+                if existing is not None and existing[1] != "wheel":
+                    raise ValueError("minimum recovery destination collision")
+                if existing is not None and existing[0] != data:
+                    raise ValueError("minimum recovery wheel collision")
+                planned[path] = (data, "wheel", None)
+        for record in launcher_records:
+            launcher = Path(str(record["bundle"]))
+            _regular(launcher, f"retained launcher {launcher.name}")
+            if launcher.stat().st_size != record["size"] or hashlib.sha256(launcher.read_bytes()).hexdigest() != record["sha256"]:
+                raise ValueError(f"retained launcher verification failed: {launcher.name}")
+            if str(record["target_launcher"]) not in expected_targets:
+                raise ValueError("recovery launcher names are outside the accepted set")
+            destination = scripts / _launcher_script_name(str(record["target_launcher"]))
+            existing = planned.get(destination)
+            if existing is not None:
+                raise ValueError("minimum recovery destination collision")
+            planned[destination] = (launcher.read_bytes(), "launcher", int(record["mode"]))
+        changed: list[str] = []
+        for path, (data, kind, mode) in planned.items():
+            if path.is_symlink() or (path.exists() and not path.is_file()) or not _within(path, (purelib, platlib, scripts, environment)):
+                raise ValueError("target file is unsafe")
+            current_mode = stat.S_IMODE(path.stat().st_mode) if path.exists() else None
+            if not path.exists() or path.read_bytes() != data:
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_bytes(data)
+                changed.append(str(path))
+            if kind == "launcher":
+                if current_mode != mode:
+                    path.chmod(mode)
+                    if str(path) not in changed:
+                        changed.append(str(path))
+            elif path.parent == scripts and os.name != "nt":
+                if current_mode is None or not (current_mode & stat.S_IXUSR):
+                    path.chmod((current_mode or 0o644) | stat.S_IXUSR)
+                    if str(path) not in changed:
+                        changed.append(str(path))
+        return changed
+    except BaseException:
+        if environment.exists():
+            shutil.rmtree(environment)
+        shutil.copytree(backup, environment, dirs_exist_ok=True)
+        raise
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def recover(request: object) -> dict[str, object]:
+    if not isinstance(request, dict) or set(request) != {"schema", "reason", "profile", "target_python", "bootstrap_plan", "handoff_receipt"} or request["schema"] != SCHEMA:
+        raise ValueError("recovery request is invalid")
+
+    locator = Path(str(request["target_python"]))
+    if not locator.is_absolute():
+        raise ValueError("recovery target locator is invalid")
+    _link_free(locator, "recovery target locator")
+    candidates = [parent for parent in locator.parents if os.path.lexists(parent / ".cogniflow-profile-handoff.json")]
+    if len(candidates) > 1:
+        raise ValueError("persisted accepted handoff could not be located unambiguously")
+    root = candidates[0] if candidates else locator.parent.parent.parent
+    persisted_receipt = _load(root / ".cogniflow-profile-handoff.json", "persisted accepted handoff")
+    record_digest = persisted_receipt.get("record_digest")
+    if persisted_receipt.get("schema") != "cf.bootstrap.accepted-handoff.v2" or record_digest != _digest({key: value for key, value in persisted_receipt.items() if key != "record_digest"}):
+        raise ValueError("persisted accepted handoff is invalid or lacks recovery authority")
+
+    marker, _ = read_marker(root / ".cogniflow-instance.json")
+    if marker["schema"] != "cf.bootstrap.instance-marker.v2":
+        raise ValueError("instance marker does not contain v2 recovery authority")
+    manifest_path = root / "state" / "minimum-service-plane" / "recovery-manifest.json"
+    manifest = _load(manifest_path, "recovery manifest")
+    manifest_raw = _canonical(manifest)
+    persisted_plan = manifest.get("bootstrap_plan")
+    if not isinstance(persisted_plan, dict) or manifest.get("schema") != MANIFEST_SCHEMA or manifest.get("plan_digest") != _digest(persisted_plan):
+        raise ValueError("recovery manifest binding is invalid")
+    target = Path(str(persisted_receipt.get("target_python", "")))
+    expected_target = root / "environment" / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+    if target != expected_target or persisted_receipt.get("installation_root") != str(root) or persisted_plan.get("installation_root") != str(root):
+        raise ValueError("persisted recovery target binding is invalid")
+    if persisted_receipt.get("recovery_manifest_path") != str(manifest_path) or persisted_receipt.get("recovery_manifest_digest") != "sha256:" + hashlib.sha256(manifest_raw).hexdigest():
+        raise ValueError("retained recovery authority is stale")
+    if (marker.get("installation_root") != str(root) or marker.get("environment_root") != str(root / "environment")
+            or marker.get("python_executable") != str(target) or marker.get("plan_digest") != manifest.get("plan_digest")
+            or marker.get("instance_id") != manifest.get("instance_id") or marker.get("profile") != persisted_receipt.get("profile")
+            or marker.get("profile_digest") != persisted_receipt.get("profile_digest")
+            or marker.get("selection_digest") != persisted_receipt.get("bootstrap_selection_digest")
+            or marker.get("recovery_manifest_path") != str(manifest_path)
+            or marker.get("recovery_manifest_digest") != persisted_receipt.get("recovery_manifest_digest")):
+        raise ValueError("instance marker is stale")
+    if manifest.get("plan_digest") != persisted_receipt.get("plan_digest") or manifest.get("instance_id") != persisted_receipt.get("instance_id") or manifest.get("artifact_set_digest") != marker.get("artifact_set_digest"):
+        raise ValueError("recovery authority digest graph is invalid")
+
+    if request["handoff_receipt"] != persisted_receipt or request["bootstrap_plan"] != persisted_plan or request["target_python"] != str(target) or request["profile"] != persisted_receipt.get("profile"):
+        raise ValueError("caller recovery assertions differ from persisted accepted authority")
+    _regular(target, "target interpreter")
+    raw_records = manifest.get("artifacts")
+    launcher_raw = manifest.get("launcher_images")
+    closure = manifest.get("recovery_distributions")
+    if not isinstance(raw_records, list) or not isinstance(launcher_raw, list) or not isinstance(closure, list) or any(not isinstance(name, str) for name in closure):
+        raise ValueError("recovery manifest artifacts are invalid")
+    records = []
+    launcher_records = []
+    names: set[str] = set()
+    launcher_targets: set[str] = set()
+    retained_names: set[str] = set()
+    bundle = manifest_path.parent
+    for raw in raw_records:
+        item = _record(raw)
+        name = str(item["normalized_distribution"]).replace("_", "-")
+        if name in names or name not in closure:
+            raise ValueError("recovery manifest contains an unauthorized distribution")
+        names.add(name)
+        wheel = bundle / str(item["filename"])
+        _regular(wheel, "retained recovery wheel")
+        if wheel.stat().st_size != item["size"] or hashlib.sha256(wheel.read_bytes()).hexdigest() != item["sha256"]:
+            raise ValueError("retained recovery wheel digest is invalid")
+        records.append({**item, "bundle": str(wheel)})
+    for raw in launcher_raw:
+        item = _launcher_record(raw)
+        target_name = str(item["target_launcher"])
+        retained_name = str(item["retained_filename"])
+        if target_name.casefold() in launcher_targets or retained_name.casefold() in retained_names:
+            raise ValueError("recovery manifest contains duplicated launcher authority")
+        launcher_targets.add(target_name.casefold())
+        retained_names.add(retained_name.casefold())
+        retained = bundle / retained_name
+        _regular(retained, "retained launcher image")
+        if retained.stat().st_size != item["size"] or hashlib.sha256(retained.read_bytes()).hexdigest() != item["sha256"] or stat.S_IMODE(retained.lstat().st_mode) != item["mode"]:
+            raise ValueError("retained launcher image is invalid")
+        launcher_records.append({**item, "bundle": str(retained)})
+    if names != set(closure):
+        raise ValueError("retained recovery closure is incomplete")
+    expected_names = {str(item["filename"]) for item in records} | {str(item["retained_filename"]) for item in launcher_records} | {"recovery-manifest.json"}
+    children = list(bundle.iterdir())
+    if {child.name for child in children} != expected_names or any(child.is_symlink() or not child.is_file() for child in children):
+        raise ValueError("retained recovery bundle contains missing or foreign state")
+    before = _inventory(target)
+    changed = _restore(target, records, launcher_records)
+    after = _inventory(target)
+    return {"schema": RESULT_SCHEMA, "status": "recovered", "classified_failure": request["reason"], "restored_files": changed, "inventory_before": before, "inventory_after": after, "target_python": str(target), "handoff": {"status": "fresh-client-required"}}
+
+
+def _inventory(target: Path) -> list[dict[str, str]]:
+    code = "import importlib.metadata as m,json; print(json.dumps(sorted([{'name':d.metadata.get('Name'),'version':d.version} for d in m.distributions() if d.metadata.get('Name')], key=lambda x:x['name'].casefold())))"
+    result = subprocess.run([str(target), "-c", code], check=True, capture_output=True, text=True, timeout=30)
+    value = json.loads(result.stdout)
+    if not isinstance(value, list):
+        raise ValueError("target inventory is invalid")
+    return value
+
+
+def main() -> int:
+    try:
+        print(json.dumps(recover(json.loads(sys.stdin.read())), sort_keys=True, separators=(",", ":")))
+        return 0
+    except (OSError, ValueError, json.JSONDecodeError, subprocess.SubprocessError) as error:
+        print(json.dumps({"schema": RESULT_SCHEMA, "status": "failed", "error": str(error)}, separators=(",", ":")))
+        return 4
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cf_bootstrap_instance/semantics/package.trig

@@ -0,0 +1,36 @@
+@prefix cfpkg: <https://cogniflow.odea-project.org/cf#> .
+@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_instance {
+    pkg:cf_bootstrap_instance
+        a cfpkg:CfPackage ;
+        cfpkg:hasPackageManifest [
+            a cfpkg:PackageManifest ;
+            cfpkg:hasDistributionName [
+                a cfpkg:DistributionName ;
+                rdf:value "cf-bootstrap-instance"
+            ] ;
+            cfpkg:hasPythonPackageName [
+                a cfpkg:PythonPackageName ;
+                rdf:value "cf_bootstrap_instance"
+            ] ;
+            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
+        ] ;
+        skos:prefLabel "cf_bootstrap_instance" ;
+        skos:definition "Generated Cogniflow package scaffold." ;
+        skos:scopeNote "Package-local semantic source generated from cf-python-package-basic." ;
+        skos:example "Consumers can validate this package with the package-template conformance service." .
+}

cf_bootstrap_instance/semantics/service.trig

@@ -0,0 +1,93 @@
+@prefix cfservice: <https://cogniflow.odea-project.org/cf#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix service: <urn:cf:service:> .
+
+<urn:cf:pkg:cf_bootstrap_instance> {
+    service:accept_bootstrap_handoff_service a cfservice:Service ;
+        cfservice:hasServiceOperation service:accept_bootstrap_handoff .
+    service:accept_bootstrap_handoff a cfservice:ServiceOperation ;
+        cfservice:hasToolName service:accept_bootstrap_handoff_tool_name ;
+        cfservice:hasToolTitle service:accept_bootstrap_handoff_tool_title ;
+        cfservice:hasToolDescription service:accept_bootstrap_handoff_tool_description ;
+        cfservice:hasOperationCapability service:accept_bootstrap_handoff_capability ;
+        cfservice:hasServiceInterface service:accept_bootstrap_handoff_interface ;
+        cfservice:hasExecutionAffordance service:accept_bootstrap_handoff_execution .
+    service:accept_bootstrap_handoff_tool_name a cfservice:ToolName ; rdf:value "accept_bootstrap_handoff" .
+    service:accept_bootstrap_handoff_tool_title a cfservice:ToolTitle ; rdf:value "Accept bootstrap handoff" .
+    service:accept_bootstrap_handoff_tool_description a cfservice:ToolDescription ; rdf:value "Accept a verified bootstrap artifact handoff into the target instance." .
+    service:accept_bootstrap_handoff_capability a cfservice:OperationCapability ; rdf:value service:BootstrapInstallationHandoff .
+    service:accept_bootstrap_handoff_interface a cfservice:ServiceInterface ;
+        cfservice:hasServiceInput service:handoff_instance_id, service:handoff_installation_root, service:handoff_plan_digest, service:handoff_artifact_set_digest .
+    service:handoff_instance_id a cfservice:ServiceInput ; cfservice:hasArgumentKey service:handoff_instance_id_key ; cfservice:hasValueKind service:handoff_string_kind ; cfservice:hasRequiredFlag service:handoff_required .
+    service:handoff_installation_root a cfservice:ServiceInput ; cfservice:hasArgumentKey service:handoff_installation_root_key ; cfservice:hasValueKind service:handoff_string_kind ; cfservice:hasRequiredFlag service:handoff_required .
+    service:handoff_plan_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey service:handoff_plan_digest_key ; cfservice:hasValueKind service:handoff_string_kind ; cfservice:hasRequiredFlag service:handoff_required .
+    service:handoff_artifact_set_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey service:handoff_artifact_set_digest_key ; cfservice:hasValueKind service:handoff_string_kind ; cfservice:hasRequiredFlag service:handoff_required .
+    service:handoff_instance_id_key rdf:value "instance_id" .
+    service:handoff_installation_root_key rdf:value "installation_root" .
+    service:handoff_plan_digest_key rdf:value "plan_digest" .
+    service:handoff_artifact_set_digest_key rdf:value "artifact_set_digest" .
+    service:handoff_string_kind rdf:value "json" .
+    service:handoff_required rdf:value true .
+    service:accept_bootstrap_handoff_execution a cfservice:ExecutionAffordance ;
+        cfservice:hasExecutorProtocol service:accept_bootstrap_handoff_protocol ;
+        cfservice:hasExecutorModule service:accept_bootstrap_handoff_module ;
+        cfservice:hasExecutorFunction service:accept_bootstrap_handoff_function .
+    service:accept_bootstrap_handoff_protocol a cfservice:ExecutorProtocol ; rdf:value cfservice:PythonFunctionExecutorV1 .
+    service:accept_bootstrap_handoff_module a cfservice:ExecutorModule ; rdf:value "cf_bootstrap_instance.service_executor" .
+    service:accept_bootstrap_handoff_function a cfservice:ExecutorFunction ; rdf:value "execute" .
+    service:accept_profiled_bootstrap_handoff_service a cfservice:Service ;
+        cfservice:hasServiceOperation service:accept_profiled_bootstrap_handoff .
+    service:accept_profiled_bootstrap_handoff a cfservice:ServiceOperation ;
+         cfservice:hasToolName [ a cfservice:ToolName ; rdf:value "accept_profiled_bootstrap_handoff" ] ;
+         cfservice:hasToolTitle [ a cfservice:ToolTitle ; rdf:value "Accept profiled bootstrap handoff" ] ;
+         cfservice:hasToolDescription [ a cfservice:ToolDescription ; rdf:value "Accept the verified profiled bootstrap handoff." ] ;
+         cfservice:hasOperationCapability [ a cfservice:OperationCapability ; rdf:value service:ProfiledBootstrapInstallationHandoff ] ;
+         cfservice:hasServiceInterface [ a cfservice:ServiceInterface ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "instance_id" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "installation_root" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "cogniflow_home" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+             cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "checkout_path" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+           cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "profile" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+           cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "plan_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+           cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "profile_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "selection_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "artifact_set_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_artifact_root" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_artifact_set_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_selection_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_binding_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_profile_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_catalog_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_repository_source_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ;
+            cfservice:hasServiceInput [ a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_index_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] ] ] ;
+        cfservice:hasExecutionAffordance [ a cfservice:ExecutionAffordance ;
+          cfservice:hasExecutorProtocol [ a cfservice:ExecutorProtocol ; rdf:value cfservice:PythonFunctionExecutorV1 ] ;
+          cfservice:hasExecutorModule [ a cfservice:ExecutorModule ; rdf:value "cf_bootstrap_instance.service_executor" ] ;
+          cfservice:hasExecutorFunction [ a cfservice:ExecutorFunction ; rdf:value "execute" ] ] .
+    service:accept_pypi_profiled_bootstrap_handoff_service a cfservice:Service ;
+        cfservice:hasServiceOperation service:accept_pypi_profiled_bootstrap_handoff .
+    service:accept_pypi_profiled_bootstrap_handoff a cfservice:ServiceOperation ;
+        cfservice:hasToolName [ a cfservice:ToolName ; rdf:value "accept_pypi_profiled_bootstrap_handoff" ] ;
+        cfservice:hasToolTitle [ a cfservice:ToolTitle ; rdf:value "Accept public PyPI profiled bootstrap handoff" ] ;
+        cfservice:hasToolDescription [ a cfservice:ToolDescription ; rdf:value "Accept the checkout-free public PyPI bootstrap handoff." ] ;
+        cfservice:hasOperationCapability [ a cfservice:OperationCapability ; rdf:value service:PublicPyPIProfiledBootstrapInstallationHandoff ] ;
+        cfservice:hasServiceInterface service:pypi_profiled_handoff_interface ;
+        cfservice:hasExecutionAffordance [ a cfservice:ExecutionAffordance ;
+          cfservice:hasExecutorProtocol [ a cfservice:ExecutorProtocol ; rdf:value cfservice:PythonFunctionExecutorV1 ] ;
+          cfservice:hasExecutorModule [ a cfservice:ExecutorModule ; rdf:value "cf_bootstrap_instance.service_executor" ] ;
+          cfservice:hasExecutorFunction [ a cfservice:ExecutorFunction ; rdf:value "execute" ] ] .
+    service:pypi_profiled_handoff_interface a cfservice:ServiceInterface ;
+        cfservice:hasServiceInput service:pypi_handoff_instance_id, service:pypi_handoff_installation_root, service:pypi_handoff_cogniflow_home, service:pypi_handoff_artifact_source, service:pypi_handoff_plan_digest, service:pypi_handoff_artifact_set_digest, service:pypi_handoff_profile, service:pypi_handoff_selection_digest, service:pypi_handoff_artifact_root, service:pypi_handoff_post_artifact_set_digest, service:pypi_handoff_post_selection_digest, service:pypi_handoff_binding_digest .
+    service:pypi_handoff_instance_id a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "instance_id" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_installation_root a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "installation_root" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_cogniflow_home a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "cogniflow_home" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_artifact_source a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "artifact_source" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_plan_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "plan_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_artifact_set_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "artifact_set_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_profile a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "profile" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_selection_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "selection_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_artifact_root a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_artifact_root" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_post_artifact_set_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_artifact_set_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_post_selection_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_selection_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+    service:pypi_handoff_binding_digest a cfservice:ServiceInput ; cfservice:hasArgumentKey [ rdf:value "post_handoff_binding_digest" ] ; cfservice:hasValueKind [ rdf:value "json" ] ; cfservice:hasRequiredFlag [ rdf:value true ] .
+ }