fix(registry): retry transient registry-server faults (#109)

One dropped connection out of ~58 packages was exiting the nightly publish
non-zero. The two fetches to our own registry server had no retry, unlike the
public-registry calls in version-check.ts; both now use the same p-retry
pattern, with 4xx aborting immediately. Error messages carry the server's
response body, which the existence check previously discarded.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: moshest

packages/registry/src/publish.test.ts

@@ -0,0 +1,77 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { createServer, type Server } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { checkPackageExists, publishPackage } from "./publish.js";
+
+/** A server that drops the first `failures` connections, then answers `status`. */
+function flakyServer(failures: number, status: number) {
+  let seen = 0;
+  const server = createServer((_req, res) => {
+    seen++;
+    if (seen <= failures) {
+      res.socket?.destroy();
+      return;
+    }
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end("{}");
+  });
+
+  return new Promise<{ server: Server; url: string; hits: () => number }>(
+    (resolve) => {
+      server.listen(0, () => {
+        const address = server.address();
+        const port = typeof address === "object" && address ? address.port : 0;
+        resolve({
+          server,
+          url: `http://127.0.0.1:${port}`,
+          hits: () => seen,
+        });
+      });
+    },
+  );
+}
+
+describe("publish", () => {
+  let running: Server | undefined;
+
+  afterEach(() => {
+    running?.close();
+    running = undefined;
+  });
+
+  const dbPath = join(mkdtempSync(join(tmpdir(), "publish-test-")), "pkg.db");
+  writeFileSync(dbPath, "x");
+
+  // One dropped connection out of ~58 packages used to fail the whole nightly
+  // publish, so transient faults have to survive rather than abort the run.
+  it("retries a dropped connection instead of failing the package", async () => {
+    const { server, url, hits } = await flakyServer(2, 404);
+    running = server;
+    process.env.REGISTRY_SERVER_URL = url;
+    process.env.REGISTRY_PUBLISH_KEY = "test-key";
+
+    await expect(checkPackageExists("npm", "preact", "latest")).resolves.toBe(
+      null,
+    );
+    expect(hits()).toBe(3);
+  });
+
+  it("gives up immediately on a 4xx and keeps the server's message", async () => {
+    const server = createServer((_req, res) => {
+      res.writeHead(403);
+      res.end("bad key");
+    });
+    running = server;
+    await new Promise<void>((resolve) => server.listen(0, () => resolve()));
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    process.env.REGISTRY_SERVER_URL = `http://127.0.0.1:${port}`;
+    process.env.REGISTRY_PUBLISH_KEY = "test-key";
+
+    await expect(
+      publishPackage("npm", "preact", "latest", dbPath),
+    ).rejects.toThrow(/403 Forbidden — bad key/);
+  });
+});

packages/registry/src/publish.ts

@@ -7,9 +7,37 @@
  */
 
 import { readFileSync } from "node:fs";
+import pRetry, { AbortError } from "p-retry";
 
 const DEFAULT_SERVER_URL = "https://api.context.neuledge.com";
 
+/**
+ * The registry server occasionally drops a connection or returns 5xx under load.
+ * A single blip used to fail the whole nightly publish — 48 packages succeed and
+ * one `fetch failed` exits non-zero — so retry transient faults with backoff.
+ * 4xx is the server's considered answer and aborts immediately.
+ */
+function requestWithRetry(
+  url: string,
+  init: RequestInit,
+  describe: () => string,
+): Promise<Response> {
+  return pRetry(
+    async () => {
+      const response = await fetch(url, init);
+      if (response.ok || response.status === 404) return response;
+
+      const body = await response.text().catch(() => "");
+      const error = new Error(
+        `${describe()}: ${response.status} ${response.statusText}${body ? ` — ${body}` : ""}`,
+      );
+      if (response.status < 500) throw new AbortError(error);
+      throw error;
+    },
+    { retries: 3 },
+  );
+}
+
 function getServerUrl(): string {
   return process.env.REGISTRY_SERVER_URL?.trim() || DEFAULT_SERVER_URL;
 }
@@ -48,18 +76,16 @@ export async function checkPackageExists(
     headers.Authorization = `Bearer ${key}`;
   }
 
-  const response = await fetch(url, { headers });
+  const response = await requestWithRetry(
+    url,
+    { headers },
+    () => `Server error checking ${registry}/${name}@${version}`,
+  );
 
   if (response.status === 404) {
     return null;
   }
 
-  if (!response.ok) {
-    throw new Error(
-      `Server error checking ${registry}/${name}@${version}: ${response.status} ${response.statusText}`,
-    );
-  }
-
   return (await response.json()) as PackageMetadata;
 }
 
@@ -75,19 +101,19 @@ export async function publishPackage(
   const url = `${getServerUrl()}/packages/${encodeURIComponent(registry)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}`;
   const body = readFileSync(dbPath);
 
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${getPublishKey()}`,
-      "Content-Type": "application/octet-stream",
+  // Re-uploading an identical package is safe: the server keys on
+  // registry/name/version, so a retry after a dropped connection overwrites
+  // rather than duplicating.
+  await requestWithRetry(
+    url,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${getPublishKey()}`,
+        "Content-Type": "application/octet-stream",
+      },
+      body,
     },
-    body,
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(
-      `Failed to publish ${registry}/${name}@${version}: ${response.status} ${response.statusText}${text ? ` — ${text}` : ""}`,
-    );
-  }
+    () => `Failed to publish ${registry}/${name}@${version}`,
+  );
 }