fdai-deployment-cli 0.1.2__py3-none-any.whl

fdai_deployment_cli/source_projection.py

@@ -0,0 +1,164 @@
+"""Derive bounded source snapshots for one service image build."""
+
+from __future__ import annotations
+
+import os
+import shlex
+from pathlib import PurePosixPath
+
+from fdai_deployment_cli.runtime_release import RUNTIME_SERVICES
+from fdai_deployment_cli.source_input import SourceDeploymentInput, _git, _read_tracked
+
+_SUPPORT_FILES = frozenset(
+    {
+        ".dockerignore",
+        "scripts/automation/run-bounded-command.py",
+        "scripts/deployment/azure/genesis_checks.py",
+        "scripts/deployment/azure/genesis_subprocess.py",
+        "scripts/deployment/azure/source_image_build.py",
+    }
+)
+
+
+def service_source_projection(
+    source: SourceDeploymentInput,
+    service: str,
+) -> tuple[str, ...]:
+    """Return the exact tracked files needed to build one baseline service image.
+
+    The Dockerfile remains the source of its copy inputs. Unsupported Dockerfile
+    syntax fails closed instead of broadening the projection to the repository.
+    """
+    if service not in RUNTIME_SERVICES:
+        raise ValueError("source projection service is outside the baseline inventory")
+    entries = _tracked_entries(source)
+    dockerfile = f"services/{service}/docker/Dockerfile"
+    if dockerfile not in entries:
+        raise ValueError("source projection Dockerfile is unavailable")
+    content = _read_tracked(source.root, dockerfile, mode=entries[dockerfile]).decode("utf-8")
+    selected = set(_SUPPORT_FILES)
+    explicit_filtered: set[str] = set()
+    selected.add(dockerfile)
+    for item in _docker_copy_sources(content):
+        expanded = _expand_tracked_source(item, entries)
+        selected.update(expanded)
+        if _explicit_filtered_source(item):
+            explicit_filtered.update(expanded)
+    missing = selected - entries.keys()
+    if missing:
+        raise ValueError("source projection requires unavailable tracked inputs")
+    selected = {
+        path for path in selected if path in explicit_filtered or _included_build_input(path)
+    }
+    _include_symlink_targets(source, selected, entries)
+    return tuple(sorted(selected))
+
+
+def _tracked_entries(source: SourceDeploymentInput) -> dict[str, str]:
+    entries: dict[str, str] = {}
+    for entry in _git(source.root, "ls-tree", "-rz", "--full-tree", source.commit).split(b"\0"):
+        if not entry:
+            continue
+        metadata, raw_path = entry.split(b"\t", 1)
+        mode, kind, _blob = metadata.decode("ascii").split()
+        if kind != "blob" or mode not in {"100644", "100755", "120000"}:
+            raise ValueError("source projection contains an unsupported tracked input")
+        entries[raw_path.decode("utf-8")] = mode
+    return entries
+
+
+def _docker_copy_sources(content: str) -> tuple[str, ...]:
+    logical: list[str] = []
+    pending = ""
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        pending = f"{pending} {line}".strip()
+        if pending.endswith("\\"):
+            pending = pending[:-1].rstrip()
+            continue
+        logical.append(pending)
+        pending = ""
+    if pending:
+        raise ValueError("source projection Dockerfile has an incomplete instruction")
+
+    sources: list[str] = []
+    for instruction in logical:
+        parts = shlex.split(instruction)
+        if not parts:
+            continue
+        if parts[0].upper() == "ADD":
+            raise ValueError("source projection does not accept Docker ADD inputs")
+        if parts[0].upper() != "COPY":
+            continue
+        if any(part.startswith("--from=") for part in parts[1:]):
+            continue
+        operands = [part for part in parts[1:] if not part.startswith("--")]
+        if len(operands) < 2:
+            raise ValueError("source projection COPY instruction is invalid")
+        for value in operands[:-1]:
+            if any(character in value for character in "*?[") or value.startswith("$"):
+                raise ValueError("source projection does not accept dynamic COPY inputs")
+            path = PurePosixPath(value)
+            if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+                raise ValueError("source projection COPY input is invalid")
+            sources.append(path.as_posix())
+    if not sources:
+        raise ValueError("source projection Dockerfile has no local COPY inputs")
+    return tuple(sources)
+
+
+def _expand_tracked_source(value: str, entries: dict[str, str]) -> set[str]:
+    if value in entries:
+        return {value}
+    prefix = value.rstrip("/") + "/"
+    matches = {path for path in entries if path.startswith(prefix)}
+    if not matches:
+        raise ValueError("source projection COPY input is unavailable")
+    return matches
+
+
+def _included_build_input(path: str) -> bool:
+    if "/tests/" in path and not path.startswith("services/core-control-plane/tests/scenarios/"):
+        return False
+    if path.endswith(".md") and path not in {
+        "README.md",
+        "rule-catalog/README.md",
+        "extensions/cost-governance/README.md",
+        "extensions/cost-governance/README-ko.md",
+    }:
+        return False
+    parts = PurePosixPath(path).parts
+    return not (
+        "__pycache__" in parts
+        or "node_modules" in parts
+        or "dist" in parts
+        or path.endswith(".pyc")
+    )
+
+
+def _explicit_filtered_source(path: str) -> bool:
+    parts = PurePosixPath(path).parts
+    return "tests" in parts or "docs" in parts or path.endswith(".md")
+
+
+def _include_symlink_targets(
+    source: SourceDeploymentInput,
+    selected: set[str],
+    entries: dict[str, str],
+) -> None:
+    pending = [path for path in selected if entries[path] == "120000"]
+    while pending:
+        relative = pending.pop()
+        target = os.fsdecode(_read_tracked(source.root, relative, mode="120000"))
+        resolved = PurePosixPath(relative).parent / target
+        if resolved.is_absolute() or ".." in resolved.parts:
+            raise ValueError("source projection link leaves the tracked file set")
+        normalized = resolved.as_posix()
+        if normalized not in entries:
+            raise ValueError("source projection link target is unavailable")
+        if normalized not in selected:
+            selected.add(normalized)
+            if entries[normalized] == "120000":
+                pending.append(normalized)

fdai_deployment_cli/source_receiver.py

@@ -0,0 +1,76 @@
+"""Build a dependency-free receiver from the exact selected source, never a release kit."""
+
+from __future__ import annotations
+
+import hashlib
+import io
+import zipfile
+from pathlib import Path
+
+from fdai_deployment_cli.private_output import read_private_bytes, write_private_bytes
+from fdai_deployment_cli.source_input import _read_tracked
+from fdai_deployment_cli.source_snapshot import verify_source_snapshot
+from fdai_deployment_cli.source_transport import _records
+
+_MODULES = (
+    "__init__",
+    "__about__",
+    "contracts",
+    "private_output",
+    "source_input",
+    "source_snapshot",
+    "source_transport",
+)
+_ENTRY = b"from fdai_deployment_cli.source_transport import main\nraise SystemExit(main())\n"
+_MAX_BOOTSTRAP = 4 * 1024 * 1024
+
+
+def prepare_source_receiver(snapshot: Path, work_dir: Path, *, snapshot_digest: str) -> str:
+    """Retain a deterministic private zipapp and return its independently transferable digest.
+
+    Only verified snapshot modules and a fixed launcher are packaged. This does not install
+    dependencies, execute source, authorize effects, or grant signed-release provenance.
+    A retained bootstrap must match exactly; ambiguous partial outputs are never overwritten.
+    """
+    verify_source_snapshot(snapshot, expected_digest=snapshot_digest)
+    records = {
+        record["path"]: record
+        for record in _records(
+            read_private_bytes(snapshot / "source-input.json", max_bytes=16 * 1024 * 1024),
+            snapshot_digest,
+        )
+    }
+    payload = io.BytesIO()
+    with zipfile.ZipFile(payload, "w", compression=zipfile.ZIP_STORED) as archive:
+        _add(archive, "__main__.py", _ENTRY)
+        for module in _MODULES:
+            relative = f"packages/deployment-cli/src/fdai_deployment_cli/{module}.py"
+            content = _read_tracked(snapshot / "tree", relative, mode="100644")
+            record = records.get(relative)
+            if (
+                record is None
+                or record["mode"] != "100644"
+                or hashlib.sha256(content).hexdigest() != record["sha256"]
+            ):
+                raise ValueError("source receiver module differs from the selected snapshot")
+            if len(content) > _MAX_BOOTSTRAP or payload.tell() + len(content) > _MAX_BOOTSTRAP:
+                raise ValueError("source receiver bootstrap exceeds its bound")
+            _add(archive, f"fdai_deployment_cli/{module}.py", content)
+    verify_source_snapshot(snapshot, expected_digest=snapshot_digest)
+    content = payload.getvalue()
+    if len(content) > _MAX_BOOTSTRAP:
+        raise ValueError("source receiver bootstrap exceeds its bound")
+    destination = work_dir / "source-receiver.pyz"
+    if destination.exists() or destination.is_symlink():
+        if read_private_bytes(destination, max_bytes=_MAX_BOOTSTRAP) != content:
+            raise ValueError("source receiver bootstrap differs; preserve the run")
+    else:
+        write_private_bytes(destination, content)
+    return hashlib.sha256(content).hexdigest()
+
+
+def _add(archive: zipfile.ZipFile, name: str, content: bytes) -> None:
+    member = zipfile.ZipInfo(name)
+    member.create_system = 3
+    member.external_attr = 0o100600 << 16
+    archive.writestr(member, content)

fdai_deployment_cli/source_recovery.py

@@ -0,0 +1,264 @@
+"""Resume an immutable source installation with explicitly selected recovery execution code."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from fdai_deployment_cli.contracts import canonical_digest, load_json_object
+from fdai_deployment_cli.deployment_deadline import DeploymentDeadline
+from fdai_deployment_cli.private_output import read_private_bytes
+from fdai_deployment_cli.runtime_profile import RuntimeDeploymentProfile
+from fdai_deployment_cli.source_input import inspect_source
+from fdai_deployment_cli.source_snapshot import verify_source_snapshot
+
+
+@dataclass(frozen=True)
+class RecoveredApplicationEvidence:
+    """Verified recovered Foundation inputs for source application continuation."""
+
+    status: dict[str, object]
+    run_binding: str
+    state_handoff_digest: str
+    source_snapshot_digest: str
+
+
+def retained_source_run(
+    work_dir: Path,
+    *,
+    runtime_profile_digest: str,
+    region: str,
+    monthly_cost_ceiling: int,
+) -> dict[str, object]:
+    """Verify original application source and selected settings without rewriting the run."""
+    intent = load_json_object(
+        read_private_bytes(work_dir / "source-intent.json", max_bytes=65536),
+        label="original source intent",
+    )
+    preparation = load_json_object(
+        read_private_bytes(work_dir / "source-preparation.json", max_bytes=65536),
+        label="original source preparation",
+    )
+    digest = preparation.pop("receipt_digest", None)
+    if (
+        canonical_digest(preparation) != digest
+        or preparation.get("schema_version") != "fdai.source-deployment-preparation.v1"
+        or preparation.get("state") != "prepared"
+        or preparation.get("provenance") != "operator-selected-source"
+        or preparation.get("release_signature_verified") is not False
+        or any(
+            preparation.get(key) is not False
+            for key in (
+                "apply_authorized",
+                "mutation_performed",
+                "deployment_ready",
+                "subscription_ready",
+            )
+        )
+        or preparation.get("intent_digest") != canonical_digest(intent)
+        or intent.get("schema_version") != "fdai.source-deployment-intent.v1"
+        or intent.get("environment") != "dev"
+        or intent.get("region") != region
+        or intent.get("monthly_cost_ceiling") != monthly_cost_ceiling
+        or preparation.get("runtime_profile_digest") != runtime_profile_digest
+        or not isinstance(intent.get("runtime_profile"), dict)
+        or canonical_digest(intent["runtime_profile"]) != runtime_profile_digest
+    ):
+        raise ValueError("source recovery must preserve the original installation settings")
+    snapshot = verify_source_snapshot(
+        work_dir / "source-snapshot", expected_digest=str(preparation.get("source_snapshot_digest"))
+    )
+    if (
+        snapshot != intent.get("source")
+        or snapshot.get("source_commit") != preparation.get("source_commit")
+        or canonical_digest(snapshot) != preparation.get("source_input_digest")
+        or canonical_digest(snapshot) != intent.get("source_input_digest")
+    ):
+        raise ValueError("source recovery application snapshot differs from the original run")
+    preparation["receipt_digest"] = digest
+    return preparation
+
+
+def recovered_application_evidence(
+    *,
+    work_dir: Path,
+    recovery_directory: Path,
+    progress: dict[str, object],
+    runtime_profile_digest: str,
+    region: str,
+    monthly_cost_ceiling: int,
+) -> RecoveredApplicationEvidence:
+    """Reverify the complete recovered handoff before source application effects."""
+
+    prepared = retained_source_run(
+        work_dir,
+        runtime_profile_digest=runtime_profile_digest,
+        region=region,
+        monthly_cost_ceiling=monthly_cost_ceiling,
+    )
+    if (
+        progress.get("stage") != "application-plan"
+        or progress.get("reason_code") != "source_application_continuation_ready"
+        or progress.get("next_action") != "continue_with_original_source_snapshot"
+    ):
+        raise ValueError("source recovery is not ready for application continuation")
+
+    foundation_root = work_dir / "foundation"
+    marker = _private_record(foundation_root / "source-genesis.json", "source Genesis marker")
+    marker_digest = marker.pop("receipt_digest", None)
+    recovery = _private_record(
+        recovery_directory / "recovery-apply-receipt.json",
+        "Foundation recovery receipt",
+    )
+    recovery_digest = recovery.pop("receipt_digest", None)
+    enrollment = _private_record(
+        recovery_directory / "runner-enrollment-receipt.json",
+        "recovered runner enrollment receipt",
+    )
+    enrollment_digest = enrollment.pop("receipt_digest", None)
+    state = _private_record(
+        recovery_directory / "foundation-state-handoff-receipt.json",
+        "recovered Foundation state receipt",
+    )
+    state_digest = state.pop("receipt_digest", None)
+    handoff = read_private_bytes(
+        recovery_directory / "recovery-private-handoff.json",
+        max_bytes=1024 * 1024,
+    )
+    status = _private_record(foundation_root / "status.json", "source Foundation status")
+    required_state = (
+        "effect_verified",
+        "runner_attested",
+        "remote_backend_authority_verified",
+        "zero_change_verified",
+        "remote_transient_deleted",
+        "local_state_deleted",
+    )
+    if (
+        canonical_digest(marker) != marker_digest
+        or marker.get("source_commit") != prepared["source_commit"]
+        or marker.get("run_binding") != progress.get("run_binding")
+        or marker.get("target_binding") != progress.get("target_binding")
+        or canonical_digest(recovery) != recovery_digest
+        or recovery.get("schema_version") != "fdai.foundation-recovery-receipt.v1"
+        or recovery.get("state") != "verified"
+        or recovery.get("source_commit") != prepared["source_commit"]
+        or recovery.get("control_plane_readback_verified") is not True
+        or recovery.get("zero_change_verified") is not True
+        or recovery_digest != progress.get("foundation_receipt_digest")
+        or canonical_digest(enrollment) != enrollment_digest
+        or enrollment.get("schema_version") != "fdai.genesis-runner-enrollment-receipt.v1"
+        or enrollment.get("state") != "attested"
+        or enrollment.get("foundation_receipt_digest") != recovery_digest
+        or enrollment_digest != progress.get("enrollment_receipt_digest")
+        or canonical_digest(state) != state_digest
+        or state.get("schema_version") != "fdai.genesis-foundation-state-handoff-receipt.v1"
+        or state.get("state") != "verified"
+        or state.get("source_commit") != prepared["source_commit"]
+        or state.get("target_binding") != progress.get("target_binding")
+        or state.get("foundation_receipt_digest") != recovery_digest
+        or state.get("enrollment_receipt_digest") != enrollment_digest
+        or any(state.get(field) is not True for field in required_state)
+        or state_digest != progress.get("state_handoff_digest")
+        or canonical_digest(load_json_object(handoff, label="recovered Foundation handoff"))
+        != recovery.get("handoff_digest")
+    ):
+        raise ValueError("recovered source application evidence differs from the verified handoff")
+    return RecoveredApplicationEvidence(
+        status=status,
+        run_binding=str(marker["run_binding"]),
+        state_handoff_digest=str(state_digest),
+        source_snapshot_digest=str(prepared["source_snapshot_digest"]),
+    )
+
+
+def _private_record(path: Path, label: str) -> dict[str, object]:
+    return load_json_object(
+        read_private_bytes(path, max_bytes=1024 * 1024),
+        label=label,
+        max_bytes=1024 * 1024,
+    )
+
+
+def resume_source_installation(
+    *,
+    source_root: Path,
+    work_dir: Path,
+    recovery_directory: Path,
+    runtime_profile: RuntimeDeploymentProfile,
+    region: str,
+    monthly_cost_ceiling: int,
+    timeout_seconds: int,
+    approval_file: Path | None,
+) -> dict[str, object]:
+    """Invoke current recovery code while retaining the original application's exact source.
+
+    This explicit route never starts a new installation, renews an approval, or
+    repeats Foundation apply. Only receipt-bound enrollment and migration may advance.
+    """
+    from fdai_deployment_cli.source_azure import _capture
+
+    deadline = DeploymentDeadline(timeout_seconds)
+    source = inspect_source(source_root)
+    work_dir, recovery_directory = work_dir.absolute(), recovery_directory.absolute()
+    prepared = retained_source_run(
+        work_dir,
+        runtime_profile_digest=runtime_profile.digest,
+        region=region,
+        monthly_cost_ceiling=monthly_cost_ceiling,
+    )
+    environment = {
+        key: value
+        for key, value in os.environ.items()
+        if key
+        in {"HOME", "PATH", "AZURE_CONFIG_DIR", "LANG", "SSL_CERT_FILE", "REQUESTS_CA_BUNDLE"}
+    }
+    environment["PYTHONPATH"] = str(source.root / "packages/deployment-cli/src")
+    source.reverify()
+    result = _capture(
+        (
+            sys.executable,
+            str(source.root / "scripts/deployment/azure/source_recovery.py"),
+            "--work-dir",
+            str(work_dir),
+            "--recovery-directory",
+            str(recovery_directory),
+            "--runtime-profile-digest",
+            runtime_profile.digest,
+            "--region",
+            region,
+            "--monthly-cost-ceiling",
+            str(monthly_cost_ceiling),
+            "--timeout-seconds",
+            str(deadline.remaining(14400)),
+            *(
+                ("--approval-file", str(approval_file.absolute()))
+                if approval_file is not None
+                else ()
+            ),
+        ),
+        source.root,
+        environment,
+        deadline.remaining(14400),
+    )
+    source.reverify()
+    if (
+        result.get("schema_version") != "fdai.source-recovery-progress.v1"
+        or result.get("state") != "review"
+        or result.get("source_commit") != prepared["source_commit"]
+        or result.get("execution_source_commit") != source.commit
+        or result.get("runtime_profile_digest") != runtime_profile.digest
+        or result.get("provenance") != "operator-selected-source"
+        or any(
+            result.get(key) is not False
+            for key in ("apply_authorized", "deployment_ready", "release_signature_verified")
+        )
+        or canonical_digest(
+            {key: value for key, value in result.items() if key != "receipt_digest"}
+        )
+        != result.get("receipt_digest")
+    ):
+        raise ValueError("source recovery returned progress for a different execution context")
+    return result

fdai_deployment_cli/source_runtime.py

@@ -0,0 +1,81 @@
+"""Verify source-bound runtime content without release trust or execution authority."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from fdai_deployment_cli.contracts import canonical_digest
+from fdai_deployment_cli.runtime_build import _regular_digest
+from fdai_deployment_cli.runtime_release import load_runtime_release, validate_runtime_images
+from fdai_deployment_cli.source_snapshot import verify_source_snapshot
+
+
+def verify_source_runtime(
+    *,
+    snapshot: Path,
+    snapshot_digest: str,
+    runtime_root: Path,
+    runtime_digest: str,
+    deployment_bundle: Path,
+    bundle_digest: str,
+    platform_tag: str,
+) -> dict[str, object]:
+    """Return no-authority content evidence for independently pinned local inputs.
+
+    This read-only check rejects changed snapshots, catalogs, payloads, revision,
+    platform or bundle bytes. OCI validation checks all service images and ClamAV;
+    other payloads remain opaque. No signature, bundle-source correspondence,
+    toolchain, support semantics, host identity or execution eligibility is proved.
+    Callers must preserve exclusive ownership and reverify inputs before later use.
+    """
+    for digest in (snapshot_digest, runtime_digest, bundle_digest):
+        if not isinstance(digest, str) or re.fullmatch(r"[0-9a-f]{64}", digest) is None:
+            raise ValueError("source runtime requires independently pinned SHA-256 digests")
+    if any(not path.is_absolute() for path in (snapshot, runtime_root, deployment_bundle)):
+        raise ValueError("source runtime paths must be absolute")
+    source = verify_source_snapshot(snapshot, expected_digest=snapshot_digest)
+    commit = source.get("source_commit")
+    if not isinstance(commit, str) or re.fullmatch(r"[0-9a-f]{40}", commit) is None:
+        raise ValueError("source runtime source commit is invalid")
+    release = load_runtime_release(
+        runtime_root, expected_source_commit=commit, expected_platform_tag=platform_tag
+    )
+    if release.digest != runtime_digest:
+        raise ValueError("source runtime catalog differs from the retained digest")
+    if (
+        release.deployment_bundle_sha256 != bundle_digest
+        or _regular_digest(deployment_bundle, label="source deployment bundle") != bundle_digest
+    ):
+        raise ValueError("source runtime deployment bundle differs from the retained digest")
+    images = validate_runtime_images(runtime_root, release)
+    observed = load_runtime_release(
+        runtime_root, expected_source_commit=commit, expected_platform_tag=platform_tag
+    )
+    if (
+        observed.digest != runtime_digest
+        or verify_source_snapshot(snapshot, expected_digest=snapshot_digest) != source
+        or _regular_digest(deployment_bundle, label="source deployment bundle") != bundle_digest
+    ):
+        raise ValueError("source runtime inputs changed during verification")
+    result: dict[str, object] = {
+        "schema_version": "fdai.source-runtime-content.v1",
+        "state": "content-verified",
+        "source_commit": commit,
+        "source_snapshot_digest": snapshot_digest,
+        "runtime_release_digest": runtime_digest,
+        "deployment_bundle_sha256": bundle_digest,
+        "platform_tag": platform_tag,
+        "artifact_count": len(release.artifact_paths),
+        "image_content_digests": images,
+        "provenance": "operator-selected-source",
+        "release_signature_verified": False,
+        "bundle_source_verified": False,
+        "support_contents_verified": False,
+        "registry_published": False,
+        "apply_authorized": False,
+        "deployment_ready": False,
+        "mutation_performed": False,
+    }
+    result["receipt_digest"] = canonical_digest(result)
+    return result