Skip to content

Write HTML. Render video. Built for agents.

ci(repo): the packed consumer check stops failing on npm versions published minutes ago (#5905)

Miguel Ángel501b2d29c214
diff --git a/scripts/verify-packed-manifests.mjs b/scripts/verify-packed-manifests.mjs
index e533a401ef..c24408182f 100644
--- a/scripts/verify-packed-manifests.mjs
+++ b/scripts/verify-packed-manifests.mjs
@@ -474,13 +474,44 @@ function writeConsumerFixture(packDir, packedWorkspaces) {
return fixtureDir;
}
+// npm lists a new version before every mirror serves its tarball, so resolving one published minutes ago
+// can 404 and fail the install. The consumer gets the third-party versions that were on npm a day ago.
+export const CONSUMER_MIN_RELEASE_AGE_SECONDS = 24 * 60 * 60;
+
+const BLOCKED_BY_AGE =
+ /No version matching "([^"]+)" found for specifier "[^"]*" \(blocked by minimum-release-age/g;
+
+export function installConsumer(dir, { args = [], env = process.env } = {}) {
+ const install = () =>
+ execFileSync(
+ "bun",
+ [
+ "install",
+ "--ignore-scripts",
+ `--minimum-release-age=${CONSUMER_MIN_RELEASE_AGE_SECONDS}`,
+ ...args,
+ ],
+ { cwd: dir, encoding: "utf8", stdio: "pipe", env },
+ );
+ try {
+ install();
+ } catch (error) {
+ // A same-day dependency bump: every version its range allows is younger than the age, and the repo
+ // installed it already, so its tarball is served. Only those packages skip the age.
+ const blocked = [...`${error.stderr ?? ""}`.matchAll(BLOCKED_BY_AGE)].map((m) => m[1]);
+ if (!blocked.length) throw error;
+ console.log(`Consumer install: newer than the release age, allowed: ${blocked.join(", ")}`);
+ writeFileSync(
+ join(dir, "bunfig.toml"),
+ `[install]\nminimumReleaseAgeExcludes = ${JSON.stringify(blocked)}\n`,
+ );
+ install();
+ }
+}
+
function verifyPackedConsumer(packDir, packedWorkspaces) {
const fixtureDir = writeConsumerFixture(packDir, packedWorkspaces);
- execFileSync("bun", ["install", "--ignore-scripts"], {
- cwd: fixtureDir,
- encoding: "utf8",
- stdio: "pipe",
- });
+ installConsumer(fixtureDir);
typecheckPackedConsumer(fixtureDir);
const smokeOutput = execFileSync("node", ["consumer-smoke.mjs"], {
cwd: fixtureDir,
diff --git a/scripts/verify-packed-manifests.test.mjs b/scripts/verify-packed-manifests.test.mjs
index 6d9bb96fc6..fb05b1a15c 100644
--- a/scripts/verify-packed-manifests.test.mjs
+++ b/scripts/verify-packed-manifests.test.mjs
@@ -1,12 +1,15 @@
import assert from "node:assert/strict";
import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { describe, it } from "node:test";
+import { Worker } from "node:worker_threads";
import {
CONSUMER_TSCONFIG,
countTypeErrorsByPackage,
+ installConsumer,
listPackedExportContracts,
listPackageSizeIssues,
listPackedJavaScriptImportIssues,
@@ -294,3 +297,105 @@ describe("packed manifest verifier", () => {
assert.equal(typecheckConsumerOf('export type { Example } from "./types.js";\n'), "");
});
});
+
+// The install is synchronous, so the registry answers from a worker thread.
+const REGISTRY = `
+const { createServer } = require("node:http");
+const { parentPort, workerData } = require("node:worker_threads");
+const { packuments, tarballs } = workerData;
+const server = createServer((req, res) => {
+ const path = decodeURIComponent(req.url.slice(1));
+ const body = path.includes("/-/") ? tarballs[path] : packuments[path];
+ if (!body) return res.writeHead(404).end();
+ if (typeof body !== "string") return res.writeHead(200).end(Buffer.from(body));
+ res.writeHead(200).end(body.replaceAll("{{origin}}", "http://" + req.headers.host));
+});
+server.listen(0, "127.0.0.1", () => parentPort.postMessage(server.address().port));
+`;
+
+function packTarball(dir, name, version) {
+ const pkgDir = join(dir, `${name}-${version}`, "package");
+ mkdirSync(pkgDir, { recursive: true });
+ writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ name, version }));
+ const file = join(dir, `${name}-${version}.tgz`);
+ execFileSync("tar", ["-czf", file, "-C", dirname(pkgDir), "package"]);
+ return readFileSync(file);
+}
+
+/** `versions`: version -> { daysOld, served }; a version not served lists but its tarball 404s. */
+async function withRegistry(name, versions, run) {
+ const dir = mkdtempSync(join(tmpdir(), "fake-registry-"));
+ const tarballs = {};
+ const packument = { name, "dist-tags": {}, versions: {}, time: {} };
+ for (const [version, { daysOld, served }] of Object.entries(versions)) {
+ const tgz = packTarball(dir, name, version);
+ const integrity = `sha512-${createHash("sha512").update(tgz).digest("base64")}`;
+ const path = `${name}/-/${name}-${version}.tgz`;
+ if (served) tarballs[path] = tgz;
+ packument.versions[version] = {
+ name,
+ version,
+ dist: { tarball: `{{origin}}/${path}`, integrity },
+ };
+ packument.time[version] = new Date(Date.now() - daysOld * 86_400_000).toISOString();
+ packument["dist-tags"].latest = version;
+ }
+ const worker = new Worker(REGISTRY, {
+ eval: true,
+ workerData: { packuments: { [name]: JSON.stringify(packument) }, tarballs },
+ });
+ try {
+ const port = await new Promise((resolve) => worker.once("message", resolve));
+ return await run(`http://127.0.0.1:${port}`, dir);
+ } finally {
+ await worker.terminate();
+ rmSync(dir, { recursive: true, force: true });
+ }
+}
+
+describe("packed consumer install", () => {
+ /** Installs `deps` into a fresh consumer against the registry; returns the installed fake-dep version. */
+ function install(registry, dir, deps) {
+ const consumer = join(dir, "consumer");
+ mkdirSync(consumer);
+ writeFileSync(
+ join(consumer, "package.json"),
+ JSON.stringify({ name: "c", dependencies: deps }),
+ );
+ const env = { ...process.env, BUN_INSTALL_CACHE_DIR: join(dir, "cache") };
+ installConsumer(consumer, { args: ["--registry", registry], env });
+ const installed = join(consumer, "node_modules", "fake-dep", "package.json");
+ return JSON.parse(readFileSync(installed, "utf8")).version;
+ }
+
+ it("skips a version published minutes ago whose tarball is not served yet", async () => {
+ const versions = {
+ "1.0.0": { daysOld: 10, served: true },
+ "1.1.0": { daysOld: 0, served: false },
+ };
+ const version = await withRegistry("fake-dep", versions, (registry, dir) =>
+ install(registry, dir, { "fake-dep": "^1.0.0" }),
+ );
+ assert.equal(version, "1.0.0");
+ });
+
+ it("installs a same-day dependency bump whose only matching version is an hour old", async () => {
+ const fresh = { daysOld: 1 / 24, served: true };
+ for (const versions of [
+ { "1.1.0": fresh },
+ { "1.0.0": { daysOld: 10, served: true }, "1.1.0": fresh },
+ ]) {
+ const version = await withRegistry("fake-dep", versions, (registry, dir) =>
+ install(registry, dir, { "fake-dep": "^1.1.0" }),
+ );
+ assert.equal(version, "1.1.0");
+ }
+ });
+
+ it("still fails on a package the registry does not have", async () => {
+ const versions = { "1.0.0": { daysOld: 10, served: true } };
+ await withRegistry("fake-dep", versions, (registry, dir) =>
+ assert.throws(() => install(registry, dir, { "missing-dep": "^1.0.0" }), /missing-dep/),
+ );
+ });
+});