mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 20:12:20 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - `docker.yml` builds, probes, gates and signs the standard Core image for every master push. Paperclip Cloud deploys a Core commit only after that image is published. > - Each master push rebuilds the image from scratch: about 10.6 min for amd64 and 7.8 min for arm64. > - The owner approved a merge queue for Core. A merge queue tests the exact commit that master will become, before the merge. > - This pull request builds and probes the image for that exact commit in the queue, with no registry credentials. The later master push pushes those exact bytes instead of rebuilding. When no matching verified build exists, master builds from source exactly as today. > - The benefit is that the image legs on master drop from about 8–11 min to about 3–4 min, and nothing changes until the owner turns the queue on. ## Linked Issues or Issue Description Refs #21013 (it measured the image path and proposed this plan). **What existing behavior does this improve?** Every master push rebuilds the standard image, even when the same commit could already have been built while it waited to merge. **Subsystem affected** `.github/workflows/docker.yml` (`build-and-push` only), new `.github/workflows/docker-merge-group.yml`, new `scripts/merge-group-image.mjs`. **Current behavior** `build-and-push` always runs the full BuildKit build on master: 639 s (amd64) and 468 s (arm64) in run 43133035209. **Proposed behavior** On a `merge_group` event, build both architectures for the merge-group commit, probe PID 1, and upload an OCI archive plus a record of commit, tree, architecture and digest. On the master push for the same commit, each leg pushes that archive by digest instead of building. Everything after the leg (probe, exact-source gate, signed-index check, attestation) is unchanged. **Reason and benefit** The build moves before the merge, where it runs in parallel with the queue's other checks. The master leg only downloads and pushes. **Breaking changes** None. Without `merge_group` events, `find` returns no run and the leg builds as before. **Additional context** This PR does not touch the exact-source gate jobs (`source_verification`, `publication_verification`, `merge-and-push`), `scripts/watch-release-source.mjs` or `cloud-readiness.yml`. Another change owns them. ## What Changed - **`docker-merge-group.yml` (new, `on: merge_group` only).** It runs only for this repository's master queue. Workflow permissions are `{}` and the job has `contents: read` only. There are no secrets, no registry login, no `cache-to`, no `push: true`, no environments, and checkout uses `persist-credentials: false`. It runs on GitHub-hosted runners, not the paid AWS fleets. Steps: build `target: production` with the same build args as master (`PAPERCLIP_BUILD_COMMIT` is the merge-group SHA, which becomes the master SHA). Read the public registry cache. Write `type=oci` to a tar. `docker load` it and run `scripts/assert-orphan-reaping.sh`. Only then write `record.json` and upload `merge-group-image-<arch>` (3-day retention). - **`scripts/merge-group-image.mjs` (new).** - `find` (master push only): selects a completed, successful run of this workflow, with event `merge_group`, the same `head_sha`, repository and head repository both `1170821064`, and a `gh-readonly-queue/master/` head branch. It needs exactly one unexpired artifact for the architecture. - `record` (merge group only): reads the archive's `index.json`, checks each blob's sha256 and that the image is `linux/<arch>`, and writes `{sha, tree, arch, digest}`. - `verify` (master push only): re-reads the archive the same way and requires record SHA = `GITHUB_SHA`, record tree = `git rev-parse HEAD^{tree}` of the master checkout, same architecture, and archive digest = recorded digest. - **`docker.yml` `build-and-push`.** - The leg gets `actions: read` so it can download the artifact. - New steps run after the registry login: find, download, then promote (`verify`, then `skopeo copy --all --preserve-digests oci-archive:… docker://ghcr.io/…@<digest>`). The step sets its `digest` output only after the push succeeds. - All three new steps are `continue-on-error`. Buildx, labels, metadata and "Build and push by digest" run when `steps.promote.outputs.digest == ''`, so any failure builds from source. - "Select image digest" feeds the existing PID 1 probe and digest export. - **Tests (`scripts/merge-group-image.test.mjs`, 8 tests):** - Run selection rejects another commit, another event, another workflow, a fork head, another repository, another queue base, and failed, cancelled or running builds. - Artifact selection. - Archive digest with and without provenance, a tampered blob, the wrong architecture, and a real tar read through the system `tar`. - Record checks for commit, tree, architecture and digest mismatch. - The CLI refuses `record` outside `merge_group` and `find`/`verify` outside a canonical master push. - Static checks of the merge-group workflow: credentials, triggers, permissions and runners. - Static checks of the `docker.yml` wiring: promotion is gated and falls back, the output is set only after the push, and every build step has the fallback condition. ### How promotion proves it publishes the verified tree 1. `find` accepts only a run whose `head_sha` equals `github.sha` of the push, meaning the queue landed the commit it tested (unverified: see "Merge method" in Risks). 2. `verify` compares the record's tree with the tree of the master checkout, and its commit with `GITHUB_SHA`. 3. The archive is content-addressed. The digest is recomputed from the archive blobs and must equal the recorded digest. `skopeo --preserve-digests` to that digest reference fails rather than produce other bytes. 4. The leg then runs the PID 1 probe on that registry digest. `merge-and-push` still signs only an index whose Linux images are the probed digests (#21013), after the unchanged exact-source gate. 5. The pipeline itself is trusted only as master already ran it. `find` and `verify` run the copy of `scripts/merge-group-image.mjs` from the push's `before` commit (`git show "$BEFORE:…"`), not the copy the push brings. `verify` refuses promotion if anything in `before..HEAD` (every commit of a multi-PR group, not only the tip) changes `docker-merge-group.yml`, `docker.yml`, the promotion script or the PID 1 probe. Such a push builds from source. So does the first push after this PR merges, because its `before` has no verifier. ## Verification - `node --test scripts/merge-group-image.test.mjs`: 10 pass. One builds a real git history in which a two-PR push changes the pipeline in its first commit only, and checks that the range check catches it. - `node --test` on the workflow and contract suites (cloud-readiness, docker-canary-promotion, post-merge-runner-routing, lockfile-refresh-workflows, release-verify-workflow, reuse-canary-image, standard-image-contract, cloud-source-verification, merge-group-image): 492 pass. - `vitest run server/src/__tests__/docker-build-stamp.test.ts server/src/__tests__/container-init-reaping.test.ts`: 22 pass. - `actionlint` on both workflows: no new findings (the 6 remaining are pre-existing `ls` and word-splitting notes in `docker.yml`). - Local: `skopeo 1.24.1 copy --all --preserve-digests` between OCI layouts kept the index digest. It accepted a `docker://…@sha256:` destination and failed only at the network step. Cannot be exercised before the queue exists, because no `merge_group` event fires: - the merge-group run itself: the hosted-runner build time, disk use with tar plus `docker load`, `docker load` of a BuildKit OCI tar, and a ~5 GB artifact upload; - the cross-run artifact download on master; - whether `skopeo` exists on the runs-on AMI and accepts digest destinations in its installed version. Each master-side failure falls back to the full build. A merge-group failure only blocks the queue if its check is required, which is why that check is required last in the steps below. ## Risks - **Inert until enabled.** No `merge_group` events fire before the owner adds a merge queue. On master, `find` lists runs (one API call per leg, about 1 s), finds none, and the leg builds as today. The only always-on change is the leg's `actions: read` permission. - **Build cache freshness.** A promoted master push writes no `buildcache-<arch>`, and merge-group builds read but never write it. With every push promoted, the cache ages, so dependency or weekly tool-layer changes rebuild in each merge-group run until a fallback build refreshes the cache. A follow-up can refresh the cache from master without blocking publication. - **Publication time is still gate-bound.** The exact-source gate (about 13–14 min after push) still decides when the image publishes. See "Expected timing". - **Merge method (unverified).** Promotion needs the master commit to be exactly the commit the queue tested, because the image stamps the commit SHA (`PAPERCLIP_BUILD_COMMIT`, `build-info.json`, the provider pack revision). Matching only the tree would publish an image stamped with another SHA, so this PR does not relax the check. I expect the queue to fast-forward master to its tested commit. GitHub's merge-queue page does not state this, and it cannot be tested before the queue exists. If the queue lands a different SHA, promotion never matches and every push builds from source. That is safe but inert. Step 4 below checks this. - **skopeo on the AWS fleet.** The promote step checks for `skopeo` first and logs "Merge-queue promotion unavailable" if it is missing, then builds from source. If that notice appears, add skopeo to the fleet image. - **Hosted runner capacity.** amd64 merge-group builds run on 4-core hosted runners, colder and slower than the AWS fleet. That adds queue latency, not master latency. ### Settings the owner must enable, in order 1. **Prerequisite, a code change, not a setting.** The `master` ruleset (id 13619726) requires `ci / verify` and `ci / e2e`. Those come from `pr.yml`, which triggers only on `pull_request`. A merge queue waits for required checks on the `merge_group` event too, so every entry would stall until its timeout. First decide, and merge in a separate PR, how `ci / verify` and `ci / e2e` report on `merge_group`: a full CI run on the merge-group commit, or a fast pass that relies on the PR-head result. Today the ruleset does not require up-to-date branches either. 2. Merge this PR. Nothing changes yet. 3. In Settings → Rules → Rulesets → `master` (13619726), add **Require merge queue**: - merge method Squash; - build concurrency 5, minimum group size 1, maximum group size 5, wait 0 min; - "Require all queue entries to pass required checks"; - status check timeout 60 min. Do not add the image build to the required checks yet. Promotion is then opportunistic: if the merge-group build has not finished when master is pushed, master builds from source. 4. After the first queued merge, confirm promotion can match. The master commit SHA must equal the `head_sha` of its `Docker merge-queue build` run, and the next master `Docker` run's "Promote the merge-queue image" step must succeed. If the SHAs differ, promotion stays inert under this merge method. Stop here and report it. 5. After about a week of green `Docker merge-queue build` runs, add `build (linux/amd64, ubuntu-latest, amd64)` and `build (linux/arm64, ubuntu-24.04-arm, arm64)` (app: GitHub Actions) to the ruleset's required status checks. Then every queued commit has a verified image ready to promote. 6. The existing bypass actors (org admins, repository admins, integration 5534676) can still merge outside the queue. Those pushes have no merge-group run and build from source. ### Rollback - Remove the image checks from the required status checks (step 5), or remove **Require merge queue** (step 3). Master pushes then find no merge-group run and build from source. Nothing to migrate. - Code: revert this PR. Old merge-group artifacts expire after 3 days. Promoted images are ordinary digests under `ghcr.io/paperclipai/paperclip` and stay valid. ### Expected timing - Image leg on master: about 3–4 min (download about 5 GB, push the new layers by digest, PID 1 probe) instead of 10.6 min (amd64) and 7.8 min (arm64). - Push to published: still bounded by the exact-source gate on master, about 14–15 min (gate plus about 45 s for `merge-and-push`). Today it is the same bound, but with the legs as a second 11-min path and the serialized-run queue in front. - If the gate later accepts proof produced in the merge queue (owned by the gate change), push to published would be about 4–5 min (leg promotion plus `merge-and-push`). ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, via Claude Code with tool use (shell, file edits, read-only GitHub API and registry reads). Default reasoning mode. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [ ] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
211 lines
15 KiB
JavaScript
211 lines
15 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import { execFileSync } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import { fileURLToPath } from "node:url";
|
|
import {
|
|
archiveImageDigest, assertPipelineUnchanged, changedSince, createRecord, repositoryId, selectArtifact, selectVerifiedRun, verifyRecord, workflowPath,
|
|
} from "./merge-group-image.mjs";
|
|
|
|
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const sha = "a".repeat(40), tree = "b".repeat(40);
|
|
const digestOf = bytes => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
|
|
|
|
const run = overrides => ({ id: 10, head_sha: sha, event: "merge_group", path: workflowPath, status: "completed", conclusion: "success",
|
|
head_branch: `gh-readonly-queue/master/pr-1-${"c".repeat(40)}`, repository: { id: repositoryId }, head_repository: { id: repositoryId }, ...overrides });
|
|
|
|
test("promotes only a successful merge-queue build of this repository for this exact commit", () => {
|
|
assert.deepEqual(selectVerifiedRun({ sha, runs: [run()] }), { runId: 10 });
|
|
assert.deepEqual(selectVerifiedRun({ sha, runs: [run({ id: 10 }), run({ id: 12 }), run({ id: 14, conclusion: "failure" })] }), { runId: 12 });
|
|
for (const [label, candidate] of [
|
|
["another commit", run({ head_sha: "d".repeat(40) })],
|
|
["a pull request run", run({ event: "pull_request" })],
|
|
["a push run", run({ event: "push" })],
|
|
["another workflow", run({ path: ".github/workflows/docker.yml" })],
|
|
["a fork head repository", run({ head_repository: { id: 1 } })],
|
|
["another repository", run({ repository: { id: 1 } })],
|
|
["a queue for another branch", run({ head_branch: "gh-readonly-queue/release/pr-1-x" })],
|
|
["an ordinary branch", run({ head_branch: "master" })],
|
|
]) assert.match(selectVerifiedRun({ sha, runs: [candidate] }).reason, /no merge-queue image build/, label);
|
|
for (const candidate of [run({ conclusion: "failure" }), run({ conclusion: "cancelled" }), run({ status: "in_progress", conclusion: null })]) {
|
|
assert.match(selectVerifiedRun({ sha, runs: [candidate] }).reason, /did not succeed/);
|
|
}
|
|
assert.throws(() => selectVerifiedRun({ sha: "master", runs: [] }));
|
|
});
|
|
|
|
test("requires exactly one unexpired image artifact for the architecture", () => {
|
|
const item = (id, name, expired = false) => ({ id, name, expired });
|
|
assert.deepEqual(selectArtifact({ arch: "amd64", artifacts: [item(1, "merge-group-image-amd64"), item(2, "merge-group-image-arm64")] }), { artifactId: 1 });
|
|
assert.match(selectArtifact({ arch: "amd64", artifacts: [item(1, "merge-group-image-amd64", true)] }).reason, /found 0/);
|
|
assert.match(selectArtifact({ arch: "amd64", artifacts: [item(1, "merge-group-image-amd64"), item(2, "merge-group-image-amd64")] }).reason, /found 2/);
|
|
assert.throws(() => selectArtifact({ arch: "riscv64", artifacts: [] }));
|
|
});
|
|
|
|
// An OCI layout as BuildKit writes it for one platform with provenance: the
|
|
// layout index names a per-platform index of the image and its attestation.
|
|
function layout({ arch = "amd64", provenance = true, tamper } = {}) {
|
|
const blobs = new Map();
|
|
const put = value => { const bytes = Buffer.from(JSON.stringify(value)); const digest = digestOf(bytes); blobs.set(digest, bytes); return { digest, size: bytes.length }; };
|
|
const config = put({ architecture: arch, os: "linux", rootfs: { type: "layers", diff_ids: [] } });
|
|
const manifest = put({ schemaVersion: 2, mediaType: "application/vnd.oci.image.manifest.v1+json",
|
|
config: { mediaType: "application/vnd.oci.image.config.v1+json", ...config }, layers: [] });
|
|
const attestation = put({ schemaVersion: 2, mediaType: "application/vnd.oci.image.manifest.v1+json", config: { ...config }, layers: [] });
|
|
const top = provenance ? { mediaType: "application/vnd.oci.image.index.v1+json", ...put({ schemaVersion: 2, mediaType: "application/vnd.oci.image.index.v1+json", manifests: [
|
|
{ mediaType: "application/vnd.oci.image.manifest.v1+json", ...manifest, platform: { os: "linux", architecture: arch } },
|
|
{ mediaType: "application/vnd.oci.image.manifest.v1+json", ...attestation, platform: { os: "unknown", architecture: "unknown" } },
|
|
] }) } : { mediaType: "application/vnd.oci.image.manifest.v1+json", ...manifest };
|
|
if (tamper) blobs.set(manifest.digest, Buffer.from("{}"));
|
|
const entries = new Map([["index.json", Buffer.from(JSON.stringify({ schemaVersion: 2, manifests: [top] }))]]);
|
|
for (const [digest, bytes] of blobs) entries.set(`blobs/sha256/${digest.slice(7)}`, bytes);
|
|
return { entries, digest: top.digest };
|
|
}
|
|
const reader = entries => name => { assert.ok(entries.has(name), `missing ${name}`); return entries.get(name); };
|
|
|
|
test("reads the image digest from an OCI archive and checks its content-addressed blobs", () => {
|
|
for (const provenance of [true, false]) {
|
|
const { entries, digest } = layout({ provenance });
|
|
assert.equal(archiveImageDigest({ readEntry: reader(entries), arch: "amd64" }), digest);
|
|
}
|
|
assert.throws(() => archiveImageDigest({ readEntry: reader(layout().entries), arch: "arm64" }), /amd64 image, not arm64/);
|
|
assert.throws(() => archiveImageDigest({ readEntry: reader(layout({ tamper: true }).entries), arch: "amd64" }), /does not match its digest/);
|
|
const two = layout().entries;
|
|
two.set("index.json", Buffer.from(JSON.stringify({ manifests: [{ digest: `sha256:${"0".repeat(64)}` }, { digest: `sha256:${"1".repeat(64)}` }] })));
|
|
assert.throws(() => archiveImageDigest({ readEntry: reader(two), arch: "amd64" }), /exactly one image/);
|
|
});
|
|
|
|
test("reads a real tar archive through the system tar", () => {
|
|
const directory = mkdtempSync(path.join(tmpdir(), "merge-group-image-"));
|
|
try {
|
|
const { entries, digest } = layout({ arch: "arm64" });
|
|
for (const [name, bytes] of entries) { mkdirSync(path.dirname(path.join(directory, "layout", name)), { recursive: true }); writeFileSync(path.join(directory, "layout", name), bytes); }
|
|
execFileSync("tar", ["-cf", path.join(directory, "image.tar"), "-C", path.join(directory, "layout"), "index.json", "blobs"]);
|
|
const readEntry = name => execFileSync("tar", ["-xOf", path.join(directory, "image.tar"), name]);
|
|
assert.equal(archiveImageDigest({ readEntry, arch: "arm64" }), digest);
|
|
} finally { rmSync(directory, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test("promotion proves commit, tree, architecture and archive digest", () => {
|
|
const digest = `sha256:${"e".repeat(64)}`;
|
|
const record = createRecord({ sha, tree, arch: "amd64", digest });
|
|
assert.equal(verifyRecord({ record, sha, tree, arch: "amd64", archiveDigest: digest }), digest);
|
|
for (const [change, pattern] of [
|
|
[{ sha: "f".repeat(40) }, /different commit/],
|
|
[{ tree: "f".repeat(40) }, /different tree/],
|
|
[{ arch: "arm64" }, /different architecture/],
|
|
[{ archiveDigest: `sha256:${"f".repeat(64)}` }, /not the image the merge-group build recorded/],
|
|
]) assert.throws(() => verifyRecord({ record, sha, tree, arch: "amd64", archiveDigest: digest, ...change }), pattern);
|
|
assert.throws(() => verifyRecord({ record: { ...record, schema: "other" }, sha, tree, arch: "amd64", archiveDigest: digest }), /Unknown/);
|
|
assert.throws(() => verifyRecord({ record: { ...record, repository: "fork/paperclip" }, sha, tree, arch: "amd64", archiveDigest: digest }));
|
|
assert.throws(() => createRecord({ sha, tree: "HEAD", arch: "amd64", digest }));
|
|
});
|
|
|
|
test("a push that changes the merge-group pipeline is built from source, not promoted", () => {
|
|
assert.doesNotThrow(() => assertPipelineUnchanged([]));
|
|
assert.doesNotThrow(() => assertPipelineUnchanged(["Dockerfile", "server/src/index.ts", "scripts/standard-image-contract.mjs"]));
|
|
for (const file of [".github/workflows/docker-merge-group.yml", ".github/workflows/docker.yml", "scripts/merge-group-image.mjs", "scripts/assert-orphan-reaping.sh"]) {
|
|
assert.throws(() => assertPipelineUnchanged(["server/src/index.ts", file]), /changes the merge-group image pipeline/, file);
|
|
}
|
|
});
|
|
|
|
test("the pipeline check covers every commit the push landed, not only the last", () => {
|
|
const directory = mkdtempSync(path.join(tmpdir(), "merge-group-push-"));
|
|
const git = (...args) => execFileSync("git", ["-c", "user.name=t", "-c", "user.email=t@example.invalid", "-c", "commit.gpgsign=false", ...args],
|
|
{ cwd: directory, encoding: "utf8" }).trim();
|
|
const commit = (file, text) => {
|
|
mkdirSync(path.dirname(path.join(directory, file)), { recursive: true });
|
|
writeFileSync(path.join(directory, file), text);
|
|
git("add", "-A"); git("commit", "-q", "-m", file);
|
|
return git("rev-parse", "HEAD");
|
|
};
|
|
try {
|
|
git("init", "-q", "-b", "main");
|
|
const before = commit("scripts/merge-group-image.mjs", "v1");
|
|
// A merge group of two PRs lands in one push: the first edits the
|
|
// pipeline, the second (the push's HEAD) only edits app code.
|
|
commit("scripts/merge-group-image.mjs", "v2");
|
|
commit("server/src/index.ts", "app");
|
|
assert.deepEqual(changedSince(git("rev-parse", "HEAD~1"), directory), []);
|
|
assert.deepEqual(changedSince(before, directory), ["scripts/merge-group-image.mjs"]);
|
|
assert.throws(() => assertPipelineUnchanged(changedSince(before, directory)), /changes the merge-group image pipeline/);
|
|
assert.throws(() => changedSince("HEAD~2", directory), /full `before` SHA/);
|
|
git("checkout", "-q", "--orphan", "other"); const unrelated = commit("README.md", "x");
|
|
git("checkout", "-q", "main");
|
|
assert.throws(() => changedSince(unrelated, directory), "a non-ancestor `before` is refused");
|
|
} finally { rmSync(directory, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test("the CLI refuses to record outside a merge group or promote outside a canonical master push", () => {
|
|
const script = path.join(root, "scripts", "merge-group-image.mjs");
|
|
const run = (command, env) => {
|
|
try { execFileSync(process.execPath, [script, command, "--arch", "amd64", "--archive", "x", "--out", "y", "--dir", "z"],
|
|
{ env: { PATH: process.env.PATH, GITHUB_SHA: sha, ...env }, stdio: "pipe" }); return ""; }
|
|
catch (error) { return String(error.stderr); }
|
|
};
|
|
assert.match(run("record", { GITHUB_EVENT_NAME: "push" }), /only by merge-group builds/);
|
|
for (const env of [
|
|
{ GITHUB_EVENT_NAME: "merge_group", GITHUB_REPOSITORY: "paperclipai/paperclip", GITHUB_REF: "refs/heads/master" },
|
|
{ GITHUB_EVENT_NAME: "push", GITHUB_REPOSITORY: "fork/paperclip", GITHUB_REF: "refs/heads/master" },
|
|
{ GITHUB_EVENT_NAME: "push", GITHUB_REPOSITORY: "paperclipai/paperclip", GITHUB_REF: "refs/tags/v1" },
|
|
{ GITHUB_EVENT_NAME: "pull_request", GITHUB_REPOSITORY: "paperclipai/paperclip", GITHUB_REF: "refs/heads/master" },
|
|
]) for (const command of ["find", "verify"]) assert.match(run(command, env), /only for canonical master pushes/);
|
|
});
|
|
|
|
test("the merge-queue build has no publishing credentials or paid infrastructure", () => {
|
|
const workflow = readFileSync(path.join(root, ".github", "workflows", "docker-merge-group.yml"), "utf8");
|
|
const triggers = workflow.split("\non:\n")[1].split("\n\n")[0];
|
|
assert.equal(triggers.trim(), "merge_group:", "only the merge queue triggers this build");
|
|
assert.match(workflow, /^permissions: \{\}$/m);
|
|
const permissions = [...workflow.matchAll(/^ permissions:\n((?: {6}.+\n)+)/gm)].map(match => match[1].trim());
|
|
assert.ok(permissions.length > 0);
|
|
for (const block of permissions) assert.equal(block, "contents: read");
|
|
assert.doesNotMatch(workflow, /secrets\.|packages: write|id-token|attestations|docker\/login-action|cache-to:|push: true|environment:|runs-on\//);
|
|
assert.doesNotMatch(workflow, /pull_request_target|workflow_run|workflow_dispatch/);
|
|
assert.match(workflow, /persist-credentials: false/);
|
|
assert.match(workflow, /github\.event\.merge_group\.base_ref == 'refs\/heads\/master'/);
|
|
assert.match(workflow, /github\.repository_id == '1170821064'/);
|
|
assert.match(workflow, /push: false/);
|
|
assert.match(workflow, /scripts\/assert-orphan-reaping\.sh/);
|
|
assert.ok(workflow.indexOf("assert-orphan-reaping.sh") < workflow.indexOf("merge-group-image.mjs record"),
|
|
"the record is written only after the probe passes");
|
|
});
|
|
|
|
test("master promotes only after proof and otherwise builds exactly as before", () => {
|
|
const workflow = readFileSync(path.join(root, ".github", "workflows", "docker.yml"), "utf8");
|
|
const leg = workflow.split("\n build-and-push:\n")[1].split("\n publication_verification:\n")[0];
|
|
const steps = leg.split(/\n(?= - name: )/);
|
|
const step = name => { const found = steps.find(item => item.startsWith(` - name: ${name}\n`)); assert.ok(found, name); return found; };
|
|
const order = name => steps.indexOf(step(name));
|
|
assert.match(step("Find the merge-queue build of this commit"),
|
|
/if: github.repository == 'paperclipai\/paperclip' && github.repository_id == '1170821064' && github.event_name == 'push' && github.ref == 'refs\/heads\/master'/);
|
|
for (const name of ["Find the merge-queue build of this commit", "Download the merge-queue image", "Promote the merge-queue image"]) {
|
|
assert.match(step(name), /continue-on-error: true/, `${name} must fall back to the build`);
|
|
}
|
|
const promote = step("Promote the merge-queue image");
|
|
// Both helpers run master's copy from before the push, so a push cannot
|
|
// weaken the checks it must pass.
|
|
for (const name of ["Find the merge-queue build of this commit", "Promote the merge-queue image"]) {
|
|
assert.match(step(name), /BEFORE: \$\{\{ github.event.before \}\}/);
|
|
assert.match(step(name), /git show "\$BEFORE:scripts\/merge-group-image.mjs" > "\$trusted"/);
|
|
assert.doesNotMatch(step(name), /node scripts\/merge-group-image\.mjs/);
|
|
}
|
|
assert.match(promote, /node "\$trusted" verify --arch "\$ARCH" --dir "\$DIRECTORY" --since "\$BEFORE"/);
|
|
assert.ok(promote.indexOf('"$trusted" verify') < promote.indexOf("skopeo copy"));
|
|
assert.ok(promote.indexOf("skopeo copy --all --preserve-digests") < promote.indexOf('echo "digest=$digest" >> "$GITHUB_OUTPUT"'),
|
|
"the promoted digest becomes an output only after the exact bytes are pushed");
|
|
assert.match(promote, /GITHUB_OUTPUT='' node "\$trusted" verify/);
|
|
assert.ok(promote.indexOf("command -v skopeo") < promote.indexOf('"$trusted" verify'),
|
|
"a runner without skopeo reports that promotion is unavailable before it tries");
|
|
for (const name of ["Set up Docker Buildx", "Compute schema migration labels", "Docker meta", "Build and push by digest"]) {
|
|
assert.match(step(name), /if: steps.promote.outputs.digest == ''/, `${name} runs whenever nothing was promoted`);
|
|
assert.ok(order(name) > order("Promote the merge-queue image"));
|
|
}
|
|
assert.match(step("Select image digest"), /digest="\$\{PROMOTED:-\$BUILT\}"/);
|
|
assert.ok(order("Select image digest") < order("Verify PID 1 reaps orphaned processes"));
|
|
assert.match(step("Verify PID 1 reaps orphaned processes"), /IMAGE_DIGEST: \$\{\{ steps.image.outputs.digest \}\}/);
|
|
assert.match(step("Export digest"), /digest="\$\{\{ steps.image.outputs.digest \}\}"/);
|
|
assert.match(leg, /permissions:\n\s+contents: read\n\s+packages: write\n\s+actions: read/);
|
|
});
|