fix: tolerate npm registry propagation delays [policy]

Change-Id: I2fda5eedb254b1b2caa0a624b45a96d496db530d

Author: heimanba

.github/workflows/release.yml

@@ -121,6 +121,7 @@ jobs:
   registry-ready:
     needs: [preflight, publish]
     runs-on: ubuntu-latest
+    timeout-minutes: 20
     permissions:
       contents: read
     steps:

scripts/open-source.test.ts

@@ -150,6 +150,7 @@ describe("open-source repository invariants", () => {
 		expect(workflow).toContain('git config user.name "github-actions[bot]"');
 		expect(workflow).toContain("github-actions[bot]@users.noreply.github.com");
 		expect(workflow).toContain("registry-ready:");
+		expect(workflow).toMatch(/registry-ready:[\s\S]*?timeout-minutes: 20/);
 		expect(workflow).toContain("post-release-consumer:");
 		expect(workflow).toContain("os: [ubuntu-latest, windows-latest, macos-latest]");
 		expect(workflow).toContain("node: [22, 24]");

scripts/release/consumer-smoke.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { commonRegistryVersion, packageName, registryVersion } from "./consumer-smoke.ts";
+import { commonRegistryVersion, packageName, registryVersion, waitForRegistry } from "./consumer-smoke.ts";
 
 describe("published consumer smoke", () => {
 	test("builds canonical package names", () => {
@@ -8,7 +8,9 @@ describe("published consumer smoke", () => {
 
 	test("reads an exact registry version", () => {
 		expect(registryVersion('"1.2.3"', "@openagentpack/sdk")).toBe("1.2.3");
-		expect(() => registryVersion("[]", "@openagentpack/sdk")).toThrow("invalid version");
+		const invalidVersion = () => registryVersion("[]", "@openagentpack/sdk");
+		expect(invalidVersion).toThrow("invalid version for @openagentpack/sdk");
+		expect(invalidVersion).toThrow("received: []");
 	});
 
 	test("requires the fixed release group to resolve one version", () => {
@@ -25,4 +27,71 @@ describe("published consumer smoke", () => {
 			]),
 		).toThrow("versions must match");
 	});
+
+	test("waits through transient registry propagation", async () => {
+		let queries = 0;
+		const delays: number[] = [];
+		const version = await waitForRegistry(
+			"1.2.3",
+			{ attempts: 3, delayMs: 25 },
+			{
+				resolve: () => {
+					queries++;
+					if (queries < 3) throw new Error("@openagentpack/sdk is not visible yet");
+					return "1.2.3";
+				},
+				sleep: async (delayMs) => {
+					delays.push(delayMs);
+				},
+				log: () => {},
+			},
+		);
+
+		expect(version).toBe("1.2.3");
+		expect(queries).toBe(3);
+		expect(delays).toEqual([25, 25]);
+	});
+
+	test("reports the transient registry error while waiting", async () => {
+		let queries = 0;
+		const messages: string[] = [];
+		await waitForRegistry(
+			"1.2.3",
+			{ attempts: 2, delayMs: 0 },
+			{
+				resolve: () => {
+					queries++;
+					if (queries === 1) throw new Error("@openagentpack/sdk returned []");
+					return "1.2.3";
+				},
+				sleep: async () => {},
+				log: (message) => messages.push(message),
+			},
+		);
+
+		expect(messages[0]).toContain("@openagentpack/sdk returned []");
+	});
+
+	test("allows fifteen minutes for registry propagation by default", async () => {
+		let queries = 0;
+		let delays = 0;
+		const waiting = waitForRegistry(
+			"1.2.3",
+			{},
+			{
+				resolve: () => {
+					queries++;
+					throw new Error("not visible");
+				},
+				sleep: async () => {
+					delays++;
+				},
+				log: () => {},
+			},
+		);
+
+		await expect(waiting).rejects.toThrow("not visible");
+		expect(queries).toBe(90);
+		expect(delays).toBe(89);
+	});
 });

scripts/release/consumer-smoke.ts

@@ -25,7 +25,8 @@ export function registryVersion(raw: string, name: string): string {
 	} catch {
 		// Fall through to the stable error below.
 	}
-	throw new Error(`npm registry returned an invalid version for ${name}`);
+	const summary = raw.trim().replaceAll(/\s+/g, " ").slice(0, 200) || "<empty>";
+	throw new Error(`npm registry returned an invalid version for ${name}; received: ${summary}`);
 }
 
 export function commonRegistryVersion(entries: ReadonlyArray<{ name: string; version: string }>): string {
@@ -46,11 +47,14 @@ function run(command: string[], cwd: string, stdout: "inherit" | "pipe" = "inher
 }
 
 function npmVersion(name: string, requested: string): string {
-	const result = Bun.spawnSync(["npm", "view", `${name}@${requested}`, "version", "--json", "--registry", REGISTRY], {
-		cwd: root,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+	const result = Bun.spawnSync(
+		["npm", "view", `${name}@${requested}`, "version", "--json", "--prefer-online", "--registry", REGISTRY],
+		{
+			cwd: root,
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
 	if (result.exitCode !== 0) {
 		throw new Error(result.stderr.toString().trim() || `${name}@${requested} is not visible in the npm registry`);
 	}
@@ -72,20 +76,29 @@ export function resolvePublishedVersion(requested: string): string {
 export async function waitForRegistry(
 	requested: string,
 	options: { attempts?: number; delayMs?: number } = {},
+	dependencies: {
+		resolve?: (requested: string) => string;
+		sleep?: (delayMs: number) => Promise<void>;
+		log?: (message: string) => void;
+	} = {},
 ): Promise<string> {
-	const attempts = options.attempts ?? 30;
+	const attempts = options.attempts ?? 90;
 	const delayMs = options.delayMs ?? 10_000;
+	const resolve = dependencies.resolve ?? resolvePublishedVersion;
+	const sleep = dependencies.sleep ?? Bun.sleep;
+	const log = dependencies.log ?? console.log;
 	let lastError: unknown;
 	for (let attempt = 1; attempt <= attempts; attempt++) {
 		try {
-			const version = resolvePublishedVersion(requested);
-			console.log(`✓ All published packages are visible at ${version}`);
+			const version = resolve(requested);
+			log(`✓ All published packages are visible at ${version}`);
 			return version;
 		} catch (error) {
 			lastError = error;
 			if (attempt === attempts) break;
-			console.log(`Registry not ready (${attempt}/${attempts}); retrying in ${delayMs / 1000}s...`);
-			await Bun.sleep(delayMs);
+			const reason = error instanceof Error ? error.message : String(error);
+			log(`Registry not ready (${attempt}/${attempts}): ${reason}; retrying in ${delayMs / 1000}s...`);
+			await sleep(delayMs);
 		}
 	}
 	throw lastError;