From db3d7223e088d08d5e80f76ce2b86e6a08aa0fda Mon Sep 17 00:00:00 2001 From: Dotta <34892728+cryppadotta@users.noreply.github.com> Date: Thu, 12 Nov 2026 23:03:39 -0600 Subject: [PATCH] fix(verify): report stale SDK public input pins locally, before CI (#21283) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - The Runner support suite proves the plugin SDK public types against pinned source. The pins are in `tests/runner-e2e/source-sdk-public-inputs.json`. > - The pins cover every file in `packages/shared/src` and `packages/plugins/sdk/src`, and the SDK build inputs (for example `pnpm-lock.yaml`). > - A PR that edits a pinned file and does not refresh the registry fails three files in the "Runner support suite" lane. > - Between 2026-11-12 10:27Z and 2026-11-13 01:14Z, this failure occurred in 14 CI runs on 12 PRs. > - The local check, `pnpm verify`, returned exit 2 ("let CI cover it") for these changes. It did not mention the pins. Authors pushed, and CI failed. > - This pull request makes `pnpm verify` find stale pins before the push. It also makes the opaque fixture error name the file and the fix. > - The benefit is that authors find and fix the problem in seconds, locally, instead of after a 6-minute CI lane. ## Linked Issues or Issue Description **What happened?** Three files in the "Runner support suite" lane failed together on many unrelated PRs: `source-sdk-evidence.test.ts`, `source-sdk-public-inputs.test.mjs` and `source-sdk-public-type.test.ts`. Two of the three failed with the opaque error `Reviewed SDK reference source changed`. **Root cause** The pins on master are not stale. The tests pass on master (58/58). Each failing PR edited a pinned input and did not refresh the registry. I compared the PR heads with their merge base: - All 14 failing heads (12 PRs) changed a pinned input. None of them changed `source-sdk-public-inputs.json`. - All 19 heads in the same window that changed a pinned input and passed this lane also refreshed the registry. This includes later heads of three PRs that failed first (#21119, #21121, #21156). - Two of the 12 PRs are Dependabot PRs that change only `pnpm-lock.yaml` (#19593, #19594). The lockfile refresh bot already resyncs the pins for lock changes on master. **Steps to reproduce** 1. Start from `origin/master`. 2. Add one line to `packages/shared/src/types/heartbeat.ts` and commit it. 3. Run `node node_modules/vitest/vitest.mjs run --config tests/runner-e2e/vitest.config.ts source-sdk-evidence.test.ts source-sdk-public-inputs.test.mjs source-sdk-public-type.test.ts`. 4. The result is the same as CI: 3 files fail, with the same 4 failures. 5. Run `pnpm verify --explain`. It returns exit 2 and does not mention the pins. **Expected behavior** `pnpm verify` reports the stale pins and the refresh command before the author pushes. ## What Changed - `tests/runner-e2e/source-sdk-public-inputs.mjs`: add `staleSdkPublicInputsInWorkingTree(root)`. It applies the existing drift guard to the working tree (tracked and untracked files that git does not ignore). Add `isSdkPublicInput(file)` and the shared failure message `staleSdkPublicInputsMessage(stale)`. The committed-tree guard keeps its behavior and now uses a shared comparison. - `scripts/local-verify.mjs`: when the diff touches a pinned input, the registry or `report-lock.json`, `pnpm verify` checks the pins first. If they are stale, it exits 1 and prints the files and the refresh command. The check reads files only. It does not write the registry. - `tests/runner-e2e/source-sdk-reviewed-fixture.ts`: the error `Reviewed SDK reference source changed` now names the file and gives the refresh command. - `tests/runner-e2e/source-sdk-public-inputs.test.mjs`: new test for the working-tree guard (uncommitted edit, untracked file, ignored file). The CI drift test uses the shared message. - `doc/DEVELOPING.md`: document the new check under "Incremental local verification". No assertion is weakened. No pin is changed. No file under `.github/` is changed. ## Verification - Master, without this change: the three files pass (58/58). - Red: on master plus a one-line edit to `packages/shared/src/types/heartbeat.ts`, the three files fail with the CI signature. `pnpm verify --explain` returns exit 2 and does not mention the pins. - With this change on the same red commit: `pnpm verify` exits 1 in about 15 s and prints `tests/runner-e2e/source-sdk-public-inputs.json is stale for 1 pinned input(s): packages/shared/src/types/heartbeat.ts (changed). Commit your change, run ... --write, and commit the updated registry.` - Green: I followed the printed command (`node tests/runner-e2e/source-sdk-public-inputs.mjs --write`, then commit). The three files then pass (59/59, with the new test). - `node --test scripts/__tests__/local-verify.test.mjs`: 14/14 pass. - `pnpm verify` on this branch returns exit 2 because `scripts/local-verify.mjs` is a global CI input. Required CI supplies the broad coverage. ## Risks - Low risk. The new check only reads files. It runs only when the diff touches a pinned input. - `pnpm verify` now fails (exit 1) for a change that also fails in CI. Before, it returned exit 2. - The check needs a working `git ls-files` in the repository. `pnpm verify` already needs git. - Dependabot lock PRs still fail this lane until the lockfile bot refreshes the pins. This PR does not change that path. > For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and discuss it in `#dev` before opening the PR. Feature PRs that overlap with planned core work may need to be redirected — check the roadmap first. See `CONTRIBUTING.md`. ## Model Used - Claude (Anthropic), Claude Code agent with tool use (shell, git, GitHub CLI). Commits are attributed to Claude Fable 5.2. ## 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 - [x] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5.2 --- doc/DEVELOPING.md | 8 +++ scripts/__tests__/local-verify.test.mjs | 44 +++++++++++++++++ scripts/local-verify.mjs | 24 ++++++++- tests/runner-e2e/source-sdk-public-inputs.mjs | 49 +++++++++++++++++-- .../source-sdk-public-inputs.test.mjs | 33 +++++++++++-- .../runner-e2e/source-sdk-reviewed-fixture.ts | 3 +- 6 files changed, 151 insertions(+), 10 deletions(-) diff --git a/doc/DEVELOPING.md b/doc/DEVELOPING.md index 7bb129325df..a3bcc6eccca 100644 --- a/doc/DEVELOPING.md +++ b/doc/DEVELOPING.md @@ -1255,6 +1255,14 @@ graph, exact Vitest specifications, and stable test runner are shared with CI. Serialized server tests retain their owner. Native server tests remain in local coverage. Selected chat tests retain six sequential isolated line shards. +When the change touches `packages/shared/src`, `packages/plugins/sdk/src`, or an +SDK build input such as `pnpm-lock.yaml`, the command first checks the committed +SDK public input pins (`tests/runner-e2e/source-sdk-public-inputs.json`) against +the working tree. If they are stale it exits 1 and prints the refresh command: +commit the change, run +`node tests/runner-e2e/source-sdk-public-inputs.mjs $(git rev-parse HEAD) --write`, +and commit the updated registry. Otherwise the Runner support suite fails in CI. + Successful selected checks with complete input graphs are reusable in this worktree. Opaque filesystem, subprocess, network, generated/untracked-module, and unreviewed dependency consumers continue to run fresh. A selected pass never diff --git a/scripts/__tests__/local-verify.test.mjs b/scripts/__tests__/local-verify.test.mjs index 0e5e55b92c5..c60a3731b70 100644 --- a/scripts/__tests__/local-verify.test.mjs +++ b/scripts/__tests__/local-verify.test.mjs @@ -1,5 +1,6 @@ import assert from "node:assert/strict"; import { execFileSync, spawn, spawnSync } from "node:child_process"; +import { createHash } from "node:crypto"; import { chmodSync, cpSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, utimesSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import path from "node:path"; @@ -288,6 +289,49 @@ process.stdout.write(result); assert.doesNotMatch(result.text, /Local Vitest verification passed/); }); +test("stale SDK public input pins stop verification before selection; fresh pins and unrelated changes continue", async t => { + const f = fixture(t); + const sdkInputs = "tests/runner-e2e/source-sdk-public-inputs.mjs", registry = "tests/runner-e2e/source-sdk-public-inputs.json"; + const blob = text => createHash("sha1").update(`blob ${Buffer.byteLength(text)}\0`).update(text).digest("hex"); + const outputSha256 = "a".repeat(64); + f.write(sdkInputs, readFileSync(path.join(repository, sdkInputs), "utf8")); + f.write("tests/runner-e2e/report-lock.json", `${JSON.stringify({ inputSha256: "b".repeat(64), outputSha256 })}\n`); + f.write("packages/shared/src/schema.ts", "export const schema = 1;\n"); + const writeRegistry = schema => f.write(registry, `${JSON.stringify({ lockSha256: outputSha256, inputs: { + "package.json": blob(readFileSync(path.join(f.root, "package.json"), "utf8")), "packages/shared/src/schema.ts": blob(schema) } }, null, 2)}\n`); + writeRegistry("export const schema = 1;\n"); + f.git("add", "."); f.git("-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "-qm", "sdk pin baseline"); + const base = f.git("rev-parse", "HEAD"); + const run = args => { + const result = spawnSync(process.execPath, [path.join(f.root, "scripts/local-verify.mjs"), "--base", base, ...args], { + cwd: f.root, env: f.env, encoding: "utf8", timeout: 120_000, maxBuffer: 8 * 1024 * 1024 }); + assert.equal(result.error, undefined); + return { ...result, text: stripVTControlCharacters(result.stdout + result.stderr) }; + }; + // Unrelated change: the pin check does not run, even with a stale registry in the tree. + f.write("ui/src/leaf.ts", "export const value = 3;\n"); + f.write("packages/shared/src/schema.ts", "export const schema = 2;\n"); + f.git("add", "packages/shared/src/schema.ts"); f.git("-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "-qm", "untracked drift"); + const unrelatedBase = f.git("rev-parse", "HEAD"); + const unrelated = spawnSync(process.execPath, [path.join(f.root, "scripts/local-verify.mjs"), "--base", unrelatedBase, "--explain"], { + cwd: f.root, env: f.env, encoding: "utf8", timeout: 120_000, maxBuffer: 8 * 1024 * 1024 }); + assert.doesNotMatch(unrelated.stdout + unrelated.stderr, /is stale/); + // Pinned input changed without a registry refresh: exit 1, name the input and the command, write nothing. + const before = readFileSync(path.join(f.root, registry)); + const stale = run(["--explain"]); + assert.equal(stale.status, 1, stale.text); + assert.match(stale.text, /source-sdk-public-inputs\.json is stale for 1 pinned input\(s\): packages\/shared\/src\/schema\.ts \(changed\)/); + assert.match(stale.text, /source-sdk-public-inputs\.mjs \$\(git rev-parse HEAD\) --write/); + assert.doesNotMatch(stale.text, /Vitest test files selected|Broader verification required/); + assert.deepEqual(readFileSync(path.join(f.root, registry)), before); + // Refreshed pins: verification continues to selection. + writeRegistry("export const schema = 2;\n"); + const fresh = run(["--explain"]); + assert.doesNotMatch(fresh.text, /is stale/); + assert.match(fresh.text, /Vitest test files selected|Broader verification required/); + assert.notEqual(fresh.status, 1, fresh.text); +}); + test("documentation-only changes and empty diffs do not start a full suite", async t => { const f = fixture(t); f.write("ui/src/leaf.ts", "export const value = 1;\n"); diff --git a/scripts/local-verify.mjs b/scripts/local-verify.mjs index 09d385aa6fa..ef94f4e5fff 100644 --- a/scripts/local-verify.mjs +++ b/scripts/local-verify.mjs @@ -1,6 +1,7 @@ #!/usr/bin/env node -import { realpathSync } from "node:fs"; -import { fileURLToPath } from "node:url"; +import { existsSync, realpathSync } from "node:fs"; +import path from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; import { parseArgs } from "node:util"; import { createHash } from "node:crypto"; import { comparison, localEnvironment, protocolVersion, requestKey, snapshot } from "./local-verify/inputs.mjs"; @@ -16,12 +17,31 @@ function describe(plan, cached) { console.log("[verify] Local Vitest coverage does not replace required CI, typecheck/build, browser, release, or platform-specific checks."); } +// A change to packages/shared/src, the plugin SDK source, or an SDK build input must +// refresh the committed SDK public input pins, or every SDK-dependent Runner suite +// fails in CI. The check reads only the working tree, so report it before selection. +const sdkPublicInputs = "tests/runner-e2e/source-sdk-public-inputs.mjs"; +async function staleSdkPublicInputPins(root, changed) { + const module = path.join(root, sdkPublicInputs); + if (!existsSync(module)) return null; + const { isSdkPublicInput, staleSdkPublicInputsInWorkingTree, staleSdkPublicInputsMessage } = await import(pathToFileURL(module).href); + const pins = ["tests/runner-e2e/source-sdk-public-inputs.json", "tests/runner-e2e/report-lock.json"]; + if (!changed.some(file => isSdkPublicInput(file) || pins.includes(file))) return null; + const stale = await staleSdkPublicInputsInWorkingTree(root); + return stale.length ? staleSdkPublicInputsMessage(stale) : null; +} + export async function verify({ root = process.cwd(), base, full = false, explain = false, noCache = false, env = localEnvironment() } = {}) { root = realpathSync(root); const before = snapshot(root, env), diff = comparison(root, base), key = requestKey(before, diff, full); const canReuse = !noCache && before.cacheable && mayReuseAttempt(root, key); const cached = canReuse ? readPass(root, key) : null; console.log(`[verify] Base ${diff.base.slice(0, 12)}; ${diff.changed.length} changed paths, including local edits`); + const staleSdkPins = await staleSdkPublicInputPins(root, diff.changed); + if (staleSdkPins) { + console.error(`[verify] ${staleSdkPins}`); + return 1; + } if (cached) { if (snapshot(root, env).hash !== before.hash) throw new Error("Inputs changed during cache lookup. Run verification again."); describe(cached.plan, true); diff --git a/tests/runner-e2e/source-sdk-public-inputs.mjs b/tests/runner-e2e/source-sdk-public-inputs.mjs index d20306f504a..830cb86cab3 100644 --- a/tests/runner-e2e/source-sdk-public-inputs.mjs +++ b/tests/runner-e2e/source-sdk-public-inputs.mjs @@ -94,21 +94,62 @@ export async function synchronizeSdkPublicInputs(root, revision, { write = false */ export async function staleSdkPublicInputs(root, revision = "HEAD") { const registry = JSON.parse(await readFile(path.join(root, registryPath), "utf8")); - const pinned = registry.inputs ?? {}; const committed = {}; for (const entry of git(root, ["ls-tree", "-rz", revision, "--", ...sourceRoots, ...buildInputs]).split("\0").filter(Boolean)) { const match = /^\d+ blob ([a-f0-9]{40})\t(.+)$/.exec(entry); if (match) committed[match[2]] = match[1]; } - const stale = [...new Set([...Object.keys(pinned), ...Object.keys(committed)])].sort() - .filter(file => pinned[file] !== committed[file]) - .map(file => ({ file, change: !pinned[file] ? "unpinned" : !committed[file] ? "removed" : "changed" })); // A lockfile refresh rewrites report-lock.json; lockSha256 must follow its output hash. const policy = JSON.parse(git(root, ["show", `${revision}:${reportLockPath}`])); + return compareSdkPublicInputs(registry, committed, policy); +} + +function compareSdkPublicInputs(registry, actual, policy) { + const pinned = registry.inputs ?? {}; + const stale = [...new Set([...Object.keys(pinned), ...Object.keys(actual)])].sort() + .filter(file => pinned[file] !== actual[file]) + .map(file => ({ file, change: !pinned[file] ? "unpinned" : !actual[file] ? "removed" : "changed" })); if (registry.lockSha256 !== policy.outputSha256) stale.push({ file: `${reportLockPath} outputSha256`, change: "lockSha256 changed" }); return stale; } +const committedLockBlob = root => { + try { return git(root, ["rev-parse", "--verify", "--quiet", "HEAD:pnpm-lock.yaml"]).trim(); } + catch { return null; } +}; + +/** True when a repository path is one of the inputs the registry pins. */ +export const isSdkPublicInput = file => sourcePath(file) || buildInputs.includes(file); + +/** + * The same drift guard over the working tree (tracked and untracked, non-ignored + * files), so local verification reports a missing registry refresh before the + * change is pushed. CI runs the committed-tree guard in the Runner support suite. + */ +export async function staleSdkPublicInputsInWorkingTree(root) { + const registry = JSON.parse(await readFile(path.join(root, registryPath), "utf8")); + const actual = {}; + const listed = git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...sourceRoots, ...buildInputs]); + for (const file of [...new Set(listed.split("\0").filter(Boolean))]) { + try { + const bytes = await readFile(path.join(root, file)); + // Preserve the authenticated restored-lock exception: prepare-report-lock.mjs may leave the + // reviewed output lock in the working tree while the registry keeps the committed input pin. + // It applies only as an uncommitted overlay over a committed lock that matches its pin. + actual[file] = file === "pnpm-lock.yaml" && hex64(registry.lockSha256) && sha256(bytes) === registry.lockSha256 + && committedLockBlob(root) === registry.inputs?.[file] ? registry.inputs[file] : blob(bytes); + } catch (error) { if (error.code !== "ENOENT") throw error; } + } + const policy = JSON.parse(await readFile(path.join(root, reportLockPath), "utf8")); + return compareSdkPublicInputs(registry, actual, policy); +} + +/** The actionable failure text shared by the CI drift guard and local verification. */ +export function staleSdkPublicInputsMessage(stale) { + return `${registryPath} is stale for ${stale.length} pinned input(s): ${stale.slice(0, 10).map(row => `${row.file} (${row.change})`).join(", ")}${stale.length > 10 ? ", ..." : ""}. ` + + "Commit your change, run `node tests/runner-e2e/source-sdk-public-inputs.mjs $(git rev-parse HEAD) --write`, and commit the updated registry."; +} + if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) { const [revision, mode] = process.argv.slice(2); if (process.argv.length !== 4 || !["--check", "--write"].includes(mode)) throw new Error("Usage: node tests/runner-e2e/source-sdk-public-inputs.mjs --check|--write"); diff --git a/tests/runner-e2e/source-sdk-public-inputs.test.mjs b/tests/runner-e2e/source-sdk-public-inputs.test.mjs index 98c3cfc68ad..9ca1a501bfc 100644 --- a/tests/runner-e2e/source-sdk-public-inputs.test.mjs +++ b/tests/runner-e2e/source-sdk-public-inputs.test.mjs @@ -6,7 +6,7 @@ import os from "node:os"; import path from "node:path"; import { afterEach, test } from "vitest"; import { fileURLToPath } from "node:url"; -import { staleSdkPublicInputs, synchronizeSdkPublicInputs } from "./source-sdk-public-inputs.mjs"; +import { isSdkPublicInput, staleSdkPublicInputs, staleSdkPublicInputsInWorkingTree, staleSdkPublicInputsMessage, synchronizeSdkPublicInputs } from "./source-sdk-public-inputs.mjs"; const registry = "tests/runner-e2e/source-sdk-public-inputs.json"; const reportLock = "tests/runner-e2e/report-lock.json"; @@ -116,8 +116,35 @@ test("refuses a committed lock that the report-lock policy does not review", asy test("the committed SDK public source pins match this checkout's committed tree", async () => { const root = fileURLToPath(new URL("../..", import.meta.url)); const stale = await staleSdkPublicInputs(root); - assert.deepEqual(stale, [], `${registry} is stale for ${stale.length} pinned input(s): ${stale.slice(0, 10).map(row => `${row.file} (${row.change})`).join(", ")}${stale.length > 10 ? ", ..." : ""}. ` - + "Commit your change, run `node tests/runner-e2e/source-sdk-public-inputs.mjs $(git rev-parse HEAD) --write`, and commit the updated registry."); + assert.deepEqual(stale, [], staleSdkPublicInputsMessage(stale)); +}); +// pnpm verify reads the working tree, so an uncommitted or unpushed edit to a +// pinned input is reported locally instead of failing the Runner support suite in CI. +test("the working-tree drift guard sees uncommitted and untracked pinned inputs", async () => { + const { root, revision } = await fixture(); + await synchronizeSdkPublicInputs(root, revision, { write: true }); commit(root, "resync"); + assert.deepEqual(await staleSdkPublicInputsInWorkingTree(root), []); + await put(root, "packages/shared/src/schema.ts", "uncommitted synthetic edit\n"); + await put(root, "packages/shared/src/untracked.ts", "untracked synthetic source\n"); + await put(root, "packages/shared/src/ignored.ts", "ignored synthetic source\n"); await put(root, ".gitignore", "packages/shared/src/ignored.ts\n"); + const stale = await staleSdkPublicInputsInWorkingTree(root); + assert.deepEqual(stale, [{ file: "packages/shared/src/schema.ts", change: "changed" }, { file: "packages/shared/src/untracked.ts", change: "unpinned" }]); + assert.match(staleSdkPublicInputsMessage(stale), /packages\/shared\/src\/schema\.ts \(changed\).*source-sdk-public-inputs\.mjs \$\(git rev-parse HEAD\) --write/); + assert.deepEqual(await staleSdkPublicInputs(root), [], "the committed-tree guard is unaffected by uncommitted edits"); + git(root, "checkout", "--", "packages/shared/src/schema.ts"); + await rm(path.join(root, "packages/shared/src/untracked.ts")); + // The reviewed restored lock overlay in the working tree is not drift; any other lock edit is. + await writeFile(path.join(root, "pnpm-lock.yaml"), "synthetic authenticated restored lock"); + assert.deepEqual(await staleSdkPublicInputsInWorkingTree(root), []); + await writeFile(path.join(root, "pnpm-lock.yaml"), "synthetic unreviewed lock edit\n"); + assert.deepEqual(await staleSdkPublicInputsInWorkingTree(root), [{ file: "pnpm-lock.yaml", change: "changed" }]); + // Committing the reviewed output lock without a registry refresh is drift: CI's committed-tree guard reports it, so must this one. + await writeFile(path.join(root, "pnpm-lock.yaml"), "synthetic authenticated restored lock"); commit(root, "commit reviewed output lock"); + assert.deepEqual(await staleSdkPublicInputs(root), [{ file: "pnpm-lock.yaml", change: "changed" }]); + assert.deepEqual(await staleSdkPublicInputsInWorkingTree(root), [{ file: "pnpm-lock.yaml", change: "changed" }]); + assert.equal(isSdkPublicInput("packages/shared/src/types/heartbeat.ts"), true); + assert.equal(isSdkPublicInput("pnpm-lock.yaml"), true); + assert.equal(isSdkPublicInput("server/src/index.ts"), false); }); test("the drift guard names changed, unpinned and removed inputs and clears after a resync", async () => { const { root, revision } = await fixture(); diff --git a/tests/runner-e2e/source-sdk-reviewed-fixture.ts b/tests/runner-e2e/source-sdk-reviewed-fixture.ts index 2eabe2a4571..8019330403d 100644 --- a/tests/runner-e2e/source-sdk-reviewed-fixture.ts +++ b/tests/runner-e2e/source-sdk-reviewed-fixture.ts @@ -44,7 +44,8 @@ export async function prepareReviewedSdkReference(original:string,directory:stri if(![policy.inputSha256,policy.outputSha256].includes(sha(committed)))throw new Error("Committed SDK reference lock is not reviewed"); for(const [file,expected]of Object.entries(pins.inputs)){ const bytes=file==="pnpm-lock.yaml"?committed:await readFile(path.join(original,file)); - if(file!=="pnpm-lock.yaml"&&blob(bytes)!==expected)throw new Error("Reviewed SDK reference source changed"); + if(file!=="pnpm-lock.yaml"&&blob(bytes)!==expected)throw new Error(`Reviewed SDK reference source changed: ${file} does not match its pin in tests/runner-e2e/source-sdk-public-inputs.json. ` + +"Commit your change, run `node tests/runner-e2e/source-sdk-public-inputs.mjs $(git rev-parse HEAD) --write`, and commit the updated registry."); const target=path.join(directory,file);await mkdir(path.dirname(target),{recursive:true}); if(file==="pnpm-lock.yaml")await writeFile(target,bytes);else await copyFile(path.join(original,file),target); }