Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

28.4 KB
Raw Blame
#!/usr/bin/env python3
"""Produce and verify desktop TEST release assets for the existing release workflow."""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import re
import shutil
import subprocess
import tempfile
from pathlib import Path
from runpy import run_path


_versions = run_path(str(Path(__file__).with_name("release_package_version.py")))
package_version_from_release_tag = _versions["package_version_from_release_tag"]
_github = run_path(str(Path(__file__).with_name("github_release.py")))
# Schema 3 marks records whose macOS artifacts are Developer ID signed and
# notarized. Schema 1 and 2 records were published with ad-hoc macOS apps.
DESKTOP_SOURCE_SCHEMA_VERSION = 3
CUA_DRIVER_SOURCES = Path(__file__).resolve().parents[1] / "desktop" / "cua-driver" / "sources.json"
TARGETS = {
    "aarch64-apple-darwin": ("macos", "aarch64", ".dmg"),
    "x86_64-apple-darwin": ("macos", "x86_64", ".dmg"),
    "x86_64-pc-windows-msvc": ("windows", "x86_64", ".exe"),
}
RC_TAG = re.compile(r"gh-v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)rc(0|[1-9][0-9]*)")
SHA = re.compile(r"[0-9a-f]{40}")
# The OS-signing layers a `.SIGNATURE` file names, by signing profile. A tag
# build must record its target's release profile; a manual build records the
# profile it actually produced.
SIGNING_PROFILES = {
    "macos": {
        "developer-id": (
            "runtime-developer-id-signed",
            "app-developer-id-notarized-stapled",
            "dmg-developer-id-notarized-stapled",
        ),
        "ad-hoc": ("runtime-unsigned", "app-adhoc", "dmg-unsigned-unnotarized"),
    },
    "windows": {"unsigned": ("installer-unsigned",)},
}
RELEASE_SIGNING_PROFILE = {"macos": "developer-id", "windows": "unsigned"}
# The layers already-published schema 1 and 2 records carry.
LEGACY_SIGNATURE = {"macos": "app-adhoc\ndmg-unsigned-unnotarized\n", "windows": "installer-unsigned\n"}
SEMVER = re.compile(
    r"(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"
    r"(?:-(?P<pre>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?"
    r"(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?"
)


def desktop_version_from_tag(tag: str) -> str:
    if re.fullmatch(r"v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)", tag):
        return tag[1:]
    match = RC_TAG.fullmatch(tag)
    if match is None:
        raise ValueError("desktop TEST release requires a canonical gh-vX.Y.ZrcN or vX.Y.Z tag")
    package_version = package_version_from_release_tag(tag)
    return package_version.replace("rc", "-rc.")


def git_output(*args: str) -> str:
    return subprocess.check_output(["git", *args], text=True).strip()


def resolve(tag: str, source_sha: str | None = None) -> dict[str, str]:
    version = desktop_version_from_tag(tag)
    actual = git_output("rev-parse", "--verify", f"refs/tags/{tag}^{{commit}}")
    if SHA.fullmatch(actual) is None or (source_sha is not None and actual != source_sha):
        raise ValueError("desktop release tag does not match the exact source SHA")
    return {"tag": tag, "source_sha": actual, "version": version,
            "package_version": package_version_from_release_tag(tag)}


def _numeric_version(value: str) -> tuple[int, ...]:
    if re.fullmatch(r"[0-9]+(?:\.[0-9]+)*", value) is None:
        raise ValueError(f"Invalid Mach-O build version: {value}")
    parts = tuple(int(part) for part in value.split("."))
    while len(parts) > 1 and parts[-1] == 0:
        parts = parts[:-1]
    return parts


def parse_macos_build_versions(output: str) -> list[tuple[str, str, str]]:
    records: list[tuple[str, str, str]] = []
    command: str | None = None
    deployment_target: str | None = None
    sdk: str | None = None

    def finish_command() -> None:
        nonlocal command, deployment_target, sdk
        if command in {"LC_BUILD_VERSION", "LC_VERSION_MIN_MACOSX"}:
            if deployment_target is None or sdk is None:
                raise ValueError(f"Incomplete {command} command")
            _numeric_version(deployment_target)
            _numeric_version(sdk)
            records.append((command, deployment_target, sdk))
        command = None
        deployment_target = None
        sdk = None

    for line in output.splitlines():
        fields = line.split()
        if len(fields) >= 2 and fields[:2] == ["Load", "command"]:
            finish_command()
        elif len(fields) == 2 and fields[0] == "cmd":
            command = fields[1]
        elif command == "LC_BUILD_VERSION" and len(fields) == 2:
            if fields[0] == "minos":
                deployment_target = fields[1]
            elif fields[0] == "sdk":
                sdk = fields[1]
        elif command == "LC_VERSION_MIN_MACOSX" and len(fields) == 2:
            if fields[0] == "version":
                deployment_target = fields[1]
            elif fields[0] == "sdk":
                sdk = fields[1]
    finish_command()
    if not records:
        raise ValueError(
            "Mach-O binary has no LC_BUILD_VERSION or LC_VERSION_MIN_MACOSX command"
        )
    return records


def parse_macos_binary_spec(spec: str) -> tuple[Path, str]:
    try:
        binary, maximum_deployment_target = spec.rsplit("=", 1)
    except ValueError as exc:
        raise ValueError(
            f"Invalid macOS binary spec {spec!r}; expected PATH=MAX_DEPLOYMENT_TARGET"
        ) from exc
    if not binary:
        raise ValueError(f"Invalid macOS binary spec {spec!r}: path is empty")
    _numeric_version(maximum_deployment_target)
    return Path(binary), maximum_deployment_target


def verify_macos_build_versions(
    binaries: list[tuple[Path, str]],
    *,
    minimum_sdk: str,
) -> None:
    minimum_sdk_value = _numeric_version(minimum_sdk)
    for binary, maximum_deployment_target in binaries:
        maximum_deployment_target_value = _numeric_version(maximum_deployment_target)
        if binary.is_symlink() or not binary.is_file():
            raise ValueError(f"Missing or invalid Mach-O binary: {binary}")
        architectures = subprocess.check_output(
            ["lipo", "-archs", str(binary)],
            text=True,
            stderr=subprocess.STDOUT,
        ).split()
        if not architectures:
            raise ValueError(f"Mach-O binary has no architecture: {binary}")
        for architecture in architectures:
            output = subprocess.check_output(
                ["otool", "-arch", architecture, "-l", str(binary)],
                text=True,
                stderr=subprocess.STDOUT,
            )
            records = parse_macos_build_versions(output)
            if len(records) != 1:
                raise ValueError(
                    f"{binary} [{architecture}]: expected exactly one "
                    "LC_BUILD_VERSION or LC_VERSION_MIN_MACOSX command, "
                    f"got {len(records)}"
                )
            command, deployment_target, sdk = records[0]
            print(
                f"{binary} [{architecture}]: "
                f"{command} deployment target {deployment_target}, sdk {sdk}"
            )
            if _numeric_version(sdk) < minimum_sdk_value:
                raise ValueError(
                    f"{binary} [{architecture}]: expected {command} sdk >= "
                    f"{minimum_sdk}, got {sdk}"
                )
            if _numeric_version(deployment_target) > maximum_deployment_target_value:
                raise ValueError(
                    f"{binary} [{architecture}]: expected {command} deployment "
                    f"target <= {maximum_deployment_target}, got {deployment_target}"
                )


def prepare(
    version: str,
    tag: str,
    source_sha: str,
    config: Path,
    env_file: Path,
    target: str | None = None,
) -> None:
    match = SEMVER.fullmatch(version)
    if match is None or any(
        part.isdigit() and len(part) > 1 and part.startswith("0")
        for part in (match["pre"] or "").split(".")
    ):
        raise ValueError("version must be valid SemVer")
    override = {"version": version}
    if tag:
        resolved = resolve(tag, source_sha)
        if git_output("rev-parse", "HEAD") != source_sha or version != resolved["version"]:
            raise ValueError("desktop checkout/version does not match the release tag")
        # Tauri never signs with an identity: macOS Developer ID signing and
        # notarization belong to desktop/scripts/macos_signing.py, and Windows
        # installers stay unsigned.
        override["bundle"] = {
            "macOS": {"signingIdentity": "-"},
            "windows": {"certificateThumbprint": None, "signCommand": None},
        }
        with env_file.open("a", encoding="utf-8") as stream:
            for key in ("SETUPTOOLS_SCM_PRETEND_VERSION", "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_AVIBE_OS"):
                stream.write(f"{key}={resolved['package_version']}\n")
    if target is not None:
        if target not in TARGETS:
            raise ValueError("unknown desktop release target")
        if TARGETS[target][0] == "macos":
            bundle = override.setdefault("bundle", {})
            macos = bundle.setdefault("macOS", {})
            # Tauri seals the bundle ad hoc with the hardened runtime and the
            # checked-in entitlements; a signed build then re-signs it.
            macos["signingIdentity"] = "-"
            macos["files"] = {
                "Helpers/cua-driver": f"binaries/cua-driver-{target}",
            }
            resources = bundle.setdefault("resources", {})
            resources.update(
                {
                    "../cua-driver/policy.yaml": "computer-use/policy.yaml",
                    "../cua-driver/tools-v0.31.0.json": "computer-use/tools-v0.31.0.json",
                    "../cua-driver/LICENSE.md": "computer-use/LICENSE.md",
                    "../cua-driver/sources.json": "computer-use/sources.json",
                    f"binaries/cua-driver-{target}.provenance.json": "computer-use/driver-provenance.json",
                }
            )
    config.write_text(json.dumps(override) + "\n", encoding="utf-8")


def digest(path: Path) -> str:
    result = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            result.update(block)
    return result.hexdigest()


def signature(target: str, profile: str | None = None) -> str:
    system = TARGETS[target][0]
    layers = SIGNING_PROFILES[system].get(profile or RELEASE_SIGNING_PROFILE[system])
    if layers is None:
        raise ValueError("Unknown signing profile for this desktop target")
    return "".join(f"{layer}\n" for layer in layers)


def asset_names(version: str, target: str) -> list[str]:
    prefix = f"Avibe_{version}_{target}"
    return [prefix + TARGETS[target][2], prefix + ".runtime-manifest.json",
            prefix + ".SOURCE.json", prefix + ".SIGNATURE", prefix + ".SHA256SUMS"]


def pinned_driver_source() -> dict:
    source = json.loads(CUA_DRIVER_SOURCES.read_text(encoding="utf-8"))["driver"]
    return {
        "version": source["version"],
        "tag": source["tag"],
        "source_commit": source["source_commit"],
        "release_checksums_sha256": source["release_checksums_sha256"],
        "archive": source["macos"]["asset"],
        "archive_sha256": source["macos"]["sha256"],
        "source_archive": source["source"]["archive"],
        "source_archive_sha256": source["source"]["sha256"],
        "patch_variant": source["patch"]["variant"],
        "patch_file": source["patch"]["file"],
        "patch_sha256": source["patch"]["sha256"],
        "patch_contract": source["patch"]["contract"],
        "tool_snapshot_sha256": source["tool_snapshot_sha256"],
    }


def validate_manifest(manifest: dict, target: str, tag: str) -> None:
    expected_os, arch, _ = TARGETS[target]
    if (manifest.get("schema_version"), manifest.get("os"), manifest.get("arch")) != (2, expected_os, arch):
        raise ValueError("Runtime manifest target/schema mismatch")
    if tag and manifest.get("runtime_version") != package_version_from_release_tag(tag):
        raise ValueError("bundled Avibe version does not match the release tag")
    for field in ("archive_sha256", "tree_sha256"):
        if re.fullmatch(r"[0-9a-f]{64}", str(manifest.get(field))) is None:
            raise ValueError(f"Invalid Runtime {field}")
    for field in ("archive_size", "entry_count", "unpacked_size"):
        if type(manifest.get(field)) is not int or manifest[field] <= 0:
            raise ValueError(f"Invalid Runtime {field}")


def driver_provenance(
    target: str,
    prepared_driver: Path,
    provenance_path: Path,
    *,
    packaged_driver: Path | None = None,
    packaged_cdhash: str | None = None,
) -> dict:
    if TARGETS[target][0] != "macos":
        raise ValueError("Cua Driver provenance is macOS-only")
    if prepared_driver.is_symlink() or not prepared_driver.is_file():
        raise ValueError("Invalid prepared Cua Driver provenance")
    provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
    required_hashes = (
        "source_archive_sha256",
        "patch_sha256",
        "tool_snapshot_sha256",
        "prepared_binary_sha256",
    )
    pinned = pinned_driver_source()
    patched_fields = (
        "version",
        "tag",
        "source_commit",
        "source_archive",
        "source_archive_sha256",
        "patch_variant",
        "patch_file",
        "patch_sha256",
        "patch_contract",
        "tool_snapshot_sha256",
    )
    if (
        provenance.get("schema_version") != 2
        or any(provenance.get(field) != pinned[field] for field in patched_fields)
        or provenance.get("target") != target
        or provenance.get("arch") != TARGETS[target][1].replace("aarch64", "arm64")
        or provenance.get("build_origin") != "repository_patch_built"
        or any(re.fullmatch(r"[0-9a-f]{64}", str(provenance.get(field))) is None for field in required_hashes)
        or digest(prepared_driver) != provenance.get("prepared_binary_sha256")
    ):
        raise ValueError("Invalid prepared Cua Driver provenance")
    if packaged_driver is None and packaged_cdhash is None:
        return provenance
    if (
        packaged_driver is None
        or packaged_driver.is_symlink()
        or not packaged_driver.is_file()
        or re.fullmatch(r"[0-9a-f]{40,64}", str(packaged_cdhash)) is None
    ):
        raise ValueError("Invalid packaged Cua Driver provenance")
    return {
        **provenance,
        "packaged_sha256": digest(packaged_driver),
        "packaged_cdhash": packaged_cdhash,
    }


def record(*, version: str, target: str, tag: str, source_sha: str,
           installer: Path, runtime: Path, output: Path, signing: str,
           prepared_driver: Path | None = None,
           driver: Path | None = None, driver_provenance_path: Path | None = None,
           driver_cdhash: str | None = None) -> None:
    if SHA.fullmatch(source_sha) is None:
        raise ValueError("Invalid source SHA")
    signature_text = signature(target, signing)
    if tag and (version != desktop_version_from_tag(tag) or signature_text != signature(target)):
        raise ValueError("Release version/signature policy mismatch")
    manifest_path = runtime / "runtime-manifest.json"
    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    validate_manifest(manifest, target, tag)
    archive = runtime / "runtime.zip"
    if (manifest.get("archive") != archive.name or archive.stat().st_size != manifest["archive_size"]
            or digest(archive) != manifest["archive_sha256"]):
        raise ValueError("Runtime archive hash/size mismatch")
    if installer.suffix != TARGETS[target][2] or installer.stat().st_size == 0:
        raise ValueError("Missing or wrong installer")
    output.mkdir(parents=True, exist_ok=True)
    if list(output.iterdir()):
        raise ValueError("Desktop artifact output must be empty")
    names = asset_names(version, target)
    shutil.copyfile(installer, output / names[0])
    shutil.copyfile(manifest_path, output / names[1])
    source = {
        "schema_version": DESKTOP_SOURCE_SCHEMA_VERSION,
        "tag": tag, "source_sha": source_sha,
        "version": version, "target": target,
        "package_version": manifest["runtime_version"],
    }
    driver_values = (prepared_driver, driver, driver_provenance_path, driver_cdhash)
    if TARGETS[target][0] == "macos":
        if any(value is None for value in driver_values):
            raise ValueError("macOS desktop artifacts require Cua Driver provenance")
        source["computer_use_driver"] = driver_provenance(
            target,
            prepared_driver,
            driver_provenance_path,
            packaged_driver=driver,
            packaged_cdhash=driver_cdhash,
        )
    elif any(value is not None for value in driver_values):
        raise ValueError("Windows desktop artifacts cannot carry macOS Cua Driver provenance")
    (output / names[2]).write_text(json.dumps(source, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    (output / names[3]).write_text(signature_text, encoding="utf-8")
    (output / names[4]).write_text(
        "".join(f"{digest(output / name)}  {name}\n" for name in sorted(names[:4])), encoding="utf-8",
    )


def verify(directory: Path, tag: str, source_sha: str, *, updater_enabled: bool = False) -> list[Path]:
    version = desktop_version_from_tag(tag)
    if SHA.fullmatch(source_sha) is None:
        raise ValueError("Invalid source SHA")
    expected = {name for target in TARGETS for name in asset_names(version, target)}
    if updater_enabled:
        updater = run_path(str(Path(__file__).with_name("desktop_updater.py")))
        for target in TARGETS:
            expected.update(updater["names"](version, target))
        public = os.environ.get("AVIBE_DESKTOP_UPDATER_PUBLIC_KEY", "")
        if not public.strip():
            raise ValueError("Missing updater verification public key")
        with tempfile.TemporaryDirectory() as temporary:
            key = Path(temporary) / "public-key.txt"
            key.write_text(public, encoding="utf-8")
            updater["verify"](directory, tag, source_sha, key)
    if {path.name for path in directory.iterdir()} != expected:
        raise ValueError("Desktop asset set must contain exactly all three targets and their metadata")
    for target in TARGETS:
        names = asset_names(version, target)
        for name in names:
            path = directory / name
            if path.is_symlink() or not path.is_file() or path.stat().st_size == 0:
                raise ValueError(f"Missing/empty/non-regular desktop asset: {name}")
        checksums = "".join(f"{digest(directory / name)}  {name}\n" for name in sorted(names[:4]))
        if (directory / names[4]).read_text(encoding="utf-8") != checksums:
            raise ValueError("Desktop asset hash mismatch")
        source = json.loads((directory / names[2]).read_text(encoding="utf-8"))
        schema_version = source.get("schema_version")
        if schema_version not in {1, 2, DESKTOP_SOURCE_SCHEMA_VERSION}:
            raise ValueError("Desktop source provenance schema mismatch")
        expected_source = {"schema_version": schema_version, "tag": tag, "source_sha": source_sha,
                           "version": version, "target": target,
                           "package_version": package_version_from_release_tag(tag)}
        driver = source.pop("computer_use_driver", None)
        if TARGETS[target][0] == "macos":
            pinned = pinned_driver_source()
            legacy_fields = (
                "version",
                "tag",
                "source_commit",
                "release_checksums_sha256",
                "archive",
                "archive_sha256",
            )
            patched_fields = (
                "version",
                "tag",
                "source_commit",
                "source_archive",
                "source_archive_sha256",
                "patch_variant",
                "patch_file",
                "patch_sha256",
                "patch_contract",
                "tool_snapshot_sha256",
            )
            legacy_hashes = (
                "release_checksums_sha256",
                "archive_sha256",
                "extracted_universal_sha256",
                "thinned_upstream_sha256",
                "packaged_sha256",
            )
            patched_hashes = (
                "source_archive_sha256",
                "patch_sha256",
                "tool_snapshot_sha256",
                "prepared_binary_sha256",
                "packaged_sha256",
            )
            if driver is None and schema_version == 1:
                # Schema-1 macOS artifacts predate the pinned Cua Driver
                # provenance block. Keep those already-published artifacts
                # verifiable. Schema 2 makes the block mandatory.
                pass
            elif not isinstance(driver, dict):
                raise ValueError("Desktop Cua Driver provenance mismatch")
            elif driver.get("schema_version") == 1:
                if (
                    any(driver.get(field) != pinned[field] for field in legacy_fields)
                    or driver.get("target") != target
                    or driver.get("arch")
                    != TARGETS[target][1].replace("aarch64", "arm64")
                    or driver.get("thinned_signature") != "upstream_preserved"
                    or re.fullmatch(
                        r"[0-9a-f]{40,64}", str(driver.get("packaged_cdhash"))
                    )
                    is None
                    or any(
                        re.fullmatch(r"[0-9a-f]{64}", str(driver.get(field))) is None
                        for field in legacy_hashes
                    )
                ):
                    raise ValueError("Desktop Cua Driver provenance mismatch")
            elif driver.get("schema_version") == 2:  # driver provenance schema, not the record's
                if (
                    any(driver.get(field) != pinned[field] for field in patched_fields)
                    or driver.get("target") != target
                    or driver.get("arch")
                    != TARGETS[target][1].replace("aarch64", "arm64")
                    or driver.get("build_origin") != "repository_patch_built"
                    or re.fullmatch(
                        r"[0-9a-f]{40,64}", str(driver.get("packaged_cdhash"))
                    )
                    is None
                    or any(
                        re.fullmatch(r"[0-9a-f]{64}", str(driver.get(field))) is None
                        for field in patched_hashes
                    )
                ):
                    raise ValueError("Desktop Cua Driver provenance mismatch")
            else:
                raise ValueError("Desktop Cua Driver provenance mismatch")
        elif driver is not None:
            raise ValueError("Windows desktop source unexpectedly carries Cua Driver provenance")
        if source != expected_source:
            raise ValueError("Desktop source provenance mismatch")
        expected_signature = (
            signature(target)
            if schema_version == DESKTOP_SOURCE_SCHEMA_VERSION
            else LEGACY_SIGNATURE[TARGETS[target][0]]
        )
        if (directory / names[3]).read_text(encoding="utf-8") != expected_signature:
            raise ValueError("Desktop release signature policy mismatch")
        validate_manifest(json.loads((directory / names[1]).read_text(encoding="utf-8")), target, tag)
    return [directory / name for name in sorted(expected)]


def check_remote(directory: Path, tag: str, source_sha: str, repo: str, *, complete: bool,
                 updater_enabled: bool = False) -> None:
    paths = verify(directory, tag, source_sha, updater_enabled=updater_enabled)
    if updater_enabled:
        if repo != "avibe-bot/avibe":
            raise ValueError("Updater repository mismatch")
        actual_source = subprocess.check_output(
            ["gh", "api", f"repos/{repo}/commits/{tag}", "--jq", ".sha"], text=True,
        ).strip()
        if actual_source != source_sha:
            raise ValueError("Live release tag no longer matches updater source")
    state = _github["get_release"](repo, tag)
    if state is None:
        if complete:
            raise ValueError("Release is missing before finalization")
        return
    remote = json.loads(subprocess.check_output(
        ["gh", "release", "view", tag, "--repo", repo, "--json", "assets"], text=True,
    ))
    names = {asset["name"] for asset in remote["assets"]}
    expected = {path.name for path in paths}
    if (complete or not state.draft) and not expected <= names:
        raise ValueError("Missing desktop assets; published tags cannot be retrofitted, cut a new rc")
    if complete:
        # Read back uploaded bytes before the sole workflow finalizer publishes.
        with tempfile.TemporaryDirectory(prefix="desktop-release-verify-") as temporary:
            for path in paths:
                subprocess.run(["gh", "release", "download", tag, "--repo", repo,
                                "--pattern", path.name, "--dir", temporary], check=True)
                if digest(Path(temporary) / path.name) != digest(path):
                    raise ValueError(f"Uploaded desktop asset differs: {path.name}")


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    sub = parser.add_subparsers(dest="command", required=True)
    resolver = sub.add_parser("resolve")
    resolver.add_argument("--tag", required=True)
    resolver.add_argument("--output", type=Path, required=True)
    build_version = sub.add_parser("verify-macos-build-version")
    build_version.add_argument(
        "--binary",
        action="append",
        required=True,
        metavar="PATH=MAX_DEPLOYMENT_TARGET",
    )
    build_version.add_argument("--minimum-sdk", default="26.0")
    prep = sub.add_parser("prepare")
    prep.add_argument("--version", required=True)
    prep.add_argument("--tag", default="")
    prep.add_argument("--source-sha", default="")
    prep.add_argument("--config", type=Path, required=True)
    prep.add_argument("--env-file", type=Path, required=True)
    prep.add_argument("--target", choices=TARGETS)
    producer = sub.add_parser("record")
    producer.add_argument("--version", required=True)
    producer.add_argument("--target", choices=TARGETS, required=True)
    producer.add_argument("--tag", default="")
    producer.add_argument("--source-sha", required=True)
    producer.add_argument("--installer", type=Path, required=True)
    producer.add_argument("--runtime", type=Path, required=True)
    producer.add_argument("--output", type=Path, required=True)
    producer.add_argument("--signing", required=True, help="signing profile: developer-id or ad-hoc (macOS), unsigned (Windows)")
    producer.add_argument("--prepared-driver", type=Path)
    producer.add_argument("--driver", type=Path)
    producer.add_argument("--driver-provenance-path", type=Path)
    producer.add_argument("--driver-cdhash")
    verifier = sub.add_parser("verify-driver-prepared")
    verifier.add_argument("--target", choices=TARGETS, required=True)
    verifier.add_argument("--driver", type=Path, required=True)
    verifier.add_argument("--provenance-path", type=Path, required=True)
    for command in ("verify", "check-remote"):
        consumer = sub.add_parser(command)
        consumer.add_argument("--directory", type=Path, required=True)
        consumer.add_argument("--updater-enabled", action="store_true")
        consumer.add_argument("--tag", required=True)
        consumer.add_argument("--source-sha", required=True)
        if command == "check-remote":
            consumer.add_argument("--repo", required=True)
            consumer.add_argument("--complete", action="store_true")
    args = vars(parser.parse_args())
    command = args.pop("command")
    if command == "resolve":
        # $GITHUB_OUTPUT is shared by the whole step: append, never replace
        # outputs the step already wrote (enabled/updater_enabled).
        with args["output"].open("a", encoding="utf-8") as stream:
            stream.write("".join(f"{key}={value}\n" for key, value in resolve(args["tag"]).items()))
    elif command == "verify-macos-build-version":
        verify_macos_build_versions(
            [parse_macos_binary_spec(spec) for spec in args["binary"]],
            minimum_sdk=args["minimum_sdk"],
        )
    elif command == "prepare":
        prepare(**args)
    elif command == "record":
        record(**args)
    elif command == "verify-driver-prepared":
        driver_provenance(
            args["target"],
            args["driver"],
            args["provenance_path"],
        )
    elif command == "verify":
        verify(**args)
    else:
        check_remote(**args)


if __name__ == "__main__":
    main()