claudeup 6.2.1 → 6.3.0

package/src/__tests__/catalog-cache-store.test.ts

@@ -1,28 +1,22 @@
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import {
-  CATALOG_TTL_MS,
-  clearCachedCatalogs,
-  clearStoredCooldown,
-  readCachedCatalog,
-  readStoredCooldowns,
-  resetCatalogCacheMemo,
-  writeCachedCatalog,
-  writeStoredCooldown,
+	CATALOG_TTL_MS,
+	clearCachedCatalogs,
+	clearStoredCooldown,
+	readCachedCatalog,
+	readStoredCooldowns,
+	resetCatalogCacheMemo,
+	writeCachedCatalog,
+	writeStoredCooldown,
 } from "../services/catalog-cache-store";
 import {
-  cooldownFor,
-  hydrateGitHubBudget,
-  recordRateLimit,
-  resetGitHubBudget,
+	cooldownFor,
+	hydrateGitHubBudget,
+	recordRateLimit,
+	resetGitHubBudget,
 } from "../services/github-budget";
 import type { MarketplacePlugin } from "../services/marketplace-catalog";
 
@@ -48,262 +42,268 @@ let prevConfigDir: string | undefined;
 const NOW = 1_786_980_000_000;
 
 function plugin(name: string, version: string): MarketplacePlugin {
-  return { name, version, description: "" };
+	return { name, version, description: "" };
 }
 
 beforeEach(() => {
-  configDir = fs.mkdtempSync(path.join(os.tmpdir(), "catalog-cache-"));
-  prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
-  process.env.CLAUDE_CONFIG_DIR = configDir;
-  resetCatalogCacheMemo();
-  resetGitHubBudget();
+	configDir = fs.mkdtempSync(path.join(os.tmpdir(), "catalog-cache-"));
+	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	process.env.CLAUDE_CONFIG_DIR = configDir;
+	resetCatalogCacheMemo();
+	resetGitHubBudget();
 });
 
 afterEach(() => {
-  if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-  else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
-  fs.rmSync(configDir, { recursive: true, force: true });
+	// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+	if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+	fs.rmSync(configDir, { recursive: true, force: true });
 });
 
 describe("catalog cache — survives a relaunch", () => {
-  it("serves a catalog written by a previous process", async () => {
-    await writeCachedCatalog("magus", [plugin("terminal", "4.1.6")], "remote");
-
-    // Stand in for a relaunch: in-memory state gone, file intact.
-    resetCatalogCacheMemo();
-
-    const cached = await readCachedCatalog("magus");
-    expect(cached).not.toBeNull();
-    expect(cached?.plugins).toHaveLength(1);
-    expect(cached?.plugins[0]?.version).toBe("4.1.6");
-    expect(cached?.source).toBe("remote");
-  });
-
-  it("keeps the source, so a cached answer is still labelled honestly", async () => {
-    // A `remote-git` answer stays `remote-git` after a round trip through disk.
-    // Flattening it to "cached" would lose the authoritative/unverified
-    // distinction the whole fix rests on.
-    await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote-git");
-    resetCatalogCacheMemo();
-    expect((await readCachedCatalog("magus"))?.source).toBe("remote-git");
-  });
-
-  it("expires once past the TTL", async () => {
-    await writeCachedCatalog(
-      "magus",
-      [plugin("terminal", "4.1.6")],
-      "remote",
-      NOW,
-    );
-    resetCatalogCacheMemo();
-
-    expect(await readCachedCatalog("magus", NOW + CATALOG_TTL_MS - 1000)).not.toBeNull();
-    expect(await readCachedCatalog("magus", NOW + CATALOG_TTL_MS + 1000)).toBeNull();
-  });
-
-  it("ignores an entry stamped in the future", async () => {
-    // A clock that jumped backwards must not pin a cache entry forever.
-    await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote", NOW);
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus", NOW - 60_000)).toBeNull();
-  });
-
-  it("never caches an empty catalog", async () => {
-    // An empty list is indistinguishable from an unclassified failure. Caching it
-    // would serve "this marketplace has no plugins" for an hour — the original bug
-    // with a longer memory.
-    await writeCachedCatalog("magus", [], "remote");
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus")).toBeNull();
-  });
-
-  it("is dropped by an explicit refresh", async () => {
-    await writeCachedCatalog("magus", [plugin("terminal", "4.1.6")], "remote");
-    await clearCachedCatalogs();
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus")).toBeNull();
-  });
-
-  it("survives a corrupt cache file instead of throwing", async () => {
-    fs.writeFileSync(
-      path.join(configDir, "claudeup-catalog-cache.json"),
-      "{ not json",
-    );
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus")).toBeNull();
-
-    // And it must recover: a bad file cannot poison later writes.
-    await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote");
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus")).not.toBeNull();
-  });
+	it("serves a catalog written by a previous process", async () => {
+		await writeCachedCatalog("magus", [plugin("terminal", "4.1.6")], "remote");
+
+		// Stand in for a relaunch: in-memory state gone, file intact.
+		resetCatalogCacheMemo();
+
+		const cached = await readCachedCatalog("magus");
+		expect(cached).not.toBeNull();
+		expect(cached?.plugins).toHaveLength(1);
+		expect(cached?.plugins[0]?.version).toBe("4.1.6");
+		expect(cached?.source).toBe("remote");
+	});
+
+	it("keeps the source, so a cached answer is still labelled honestly", async () => {
+		// A `remote-git` answer stays `remote-git` after a round trip through disk.
+		// Flattening it to "cached" would lose the authoritative/unverified
+		// distinction the whole fix rests on.
+		await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote-git");
+		resetCatalogCacheMemo();
+		expect((await readCachedCatalog("magus"))?.source).toBe("remote-git");
+	});
+
+	it("expires once past the TTL", async () => {
+		await writeCachedCatalog(
+			"magus",
+			[plugin("terminal", "4.1.6")],
+			"remote",
+			NOW,
+		);
+		resetCatalogCacheMemo();
+
+		expect(
+			await readCachedCatalog("magus", NOW + CATALOG_TTL_MS - 1000),
+		).not.toBeNull();
+		expect(
+			await readCachedCatalog("magus", NOW + CATALOG_TTL_MS + 1000),
+		).toBeNull();
+	});
+
+	it("ignores an entry stamped in the future", async () => {
+		// A clock that jumped backwards must not pin a cache entry forever.
+		await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote", NOW);
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus", NOW - 60_000)).toBeNull();
+	});
+
+	it("never caches an empty catalog", async () => {
+		// An empty list is indistinguishable from an unclassified failure. Caching it
+		// would serve "this marketplace has no plugins" for an hour — the original bug
+		// with a longer memory.
+		await writeCachedCatalog("magus", [], "remote");
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus")).toBeNull();
+	});
+
+	it("is dropped by an explicit refresh", async () => {
+		await writeCachedCatalog("magus", [plugin("terminal", "4.1.6")], "remote");
+		await clearCachedCatalogs();
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus")).toBeNull();
+	});
+
+	it("survives a corrupt cache file instead of throwing", async () => {
+		fs.writeFileSync(
+			path.join(configDir, "claudeup-catalog-cache.json"),
+			"{ not json",
+		);
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus")).toBeNull();
+
+		// And it must recover: a bad file cannot poison later writes.
+		await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote");
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus")).not.toBeNull();
+	});
 });
 
 describe("rate-limit cooldown — survives a relaunch", () => {
-  /**
-   * Anchored to the real clock, not the fixed NOW the catalog tests use.
-   * `hydrateGitHubBudget()` takes no clock parameter — it filters expired entries
-   * against `Date.now()`, exactly as it does in production — so a cooldown stamped
-   * relative to a fixed past NOW would be discarded as expired before the
-   * assertion ever ran.
-   */
-  let base: number;
-  beforeEach(() => {
-    base = Date.now();
-  });
-
-  /**
-   * Wait until a write-behind cooldown has actually reached disk.
-   *
-   * This used to be `setTimeout(80)` — a guess at how long an unawaited write
-   * takes, which is not a synchronisation point. `recordRateLimit` persists
-   * fire-and-forget by design (`github-budget.ts` explains why), so on a loaded
-   * runner the write had not landed when the next `hydrateGitHubBudget()` read,
-   * and the restored strike count came back low. That failed CI as
-   * `Expected: 3, Received: 2` on Linux while passing 15/15 on a quiet macOS
-   * laptop — the signature of a timing guess, not of a real defect.
-   *
-   * Polling the store itself removes the guess: it returns as soon as the value
-   * is observable, and only gives up after a deadline no healthy machine
-   * reaches. `expected` is the strike count the caller just recorded; passing
-   * nothing waits for any persisted entry at all.
-   */
-  const flush = async (
-    host: string,
-    expected?: number,
-  ): Promise<void> => {
-    const deadline = Date.now() + 5000;
-    for (;;) {
-      // `base` keeps the read on the same clock the writes used: cooldowns are
-      // dropped on read once expired, so reading with a later `now` could hide
-      // an entry that is genuinely there.
-      const stored = (await readStoredCooldowns(base))[host];
-      if (stored && (expected === undefined || stored.strikes >= expected)) {
-        return;
-      }
-      if (Date.now() > deadline) {
-        throw new Error(
-          `cooldown for ${host} never reached disk (wanted strikes >= ${expected ?? "any"}, got ${stored?.strikes ?? "nothing"})`,
-        );
-      }
-      await new Promise((r) => setTimeout(r, 10));
-    }
-  };
-
-  // Teardown hygiene, NOT a synchronisation point — which is why it is a plain
-  // sleep and `flush` is not. Its only job is to let an in-flight write land
-  // before the temp config dir is removed; a write that arrives afterwards
-  // recreates a file in a deleted directory and harms nothing. Polling for a
-  // specific host here would be wrong: several tests in this block end with
-  // nothing on disk on purpose.
-  afterEach(() => new Promise((r) => setTimeout(r, 50)));
-
-  it("is still in force in the next process", async () => {
-    // THE defect this store exists to fix. Without persistence, launch two fired
-    // six more doomed requests at a host it had already been refused by.
-    recordRateLimit("raw.githubusercontent.com", new Headers(), base);
-    await flush("raw.githubusercontent.com");
-
-    resetGitHubBudget();
-    resetCatalogCacheMemo();
-    expect(cooldownFor("raw.githubusercontent.com", base)).toBeNull(); // memory only
-
-    await hydrateGitHubBudget();
-    const restored = cooldownFor("raw.githubusercontent.com", base);
-    expect(restored).not.toBeNull();
-    expect(restored?.until).toBeGreaterThan(base);
-  });
-
-  it("keeps escalating the backoff across relaunches", async () => {
-    // Without the strike count surviving, every relaunch restarts the backoff at
-    // 30s — so a tool that is relaunched often never actually backs off, which is
-    // the behaviour that got the IP rate-limited in the first place.
-    //
-    // Written as one strike per launch, which is the real shape: a launch makes its
-    // requests, learns it is limited once, and exits.
-    const first = recordRateLimit("raw.githubusercontent.com", undefined, base);
-    expect(first.strikes).toBe(1);
-    await flush("raw.githubusercontent.com", 1);
-
-    resetGitHubBudget();
-    resetCatalogCacheMemo();
-    await hydrateGitHubBudget();
-
-    const second = recordRateLimit("raw.githubusercontent.com", undefined, base);
-    expect(second.strikes).toBe(2);
-    expect(second.until).toBeGreaterThan(first.until);
-    await flush("raw.githubusercontent.com", 2);
-
-    resetGitHubBudget();
-    resetCatalogCacheMemo();
-    await hydrateGitHubBudget();
-
-    const third = recordRateLimit("raw.githubusercontent.com", undefined, base);
-    expect(third.strikes).toBe(3);
-    expect(third.until).toBeGreaterThan(second.until);
-  });
-
-  it("preserves whether the timing was GitHub's or ours", async () => {
-    // `exact` decides between "resets in 4m" and "next attempt in 4m". Losing it
-    // across a relaunch would make the UI state a claim GitHub never made.
-    recordRateLimit(
-      "api.github.com",
-      new Headers({ "retry-after": "600" }),
-      base,
-    );
-    await flush("api.github.com");
-
-    resetGitHubBudget();
-    await hydrateGitHubBudget();
-    expect(cooldownFor("api.github.com", base)?.exact).toBe(true);
-  });
-
-  it("drops an expired cooldown rather than restoring it", async () => {
-    await writeStoredCooldown("raw.githubusercontent.com", {
-      until: NOW - 1000,
-      exact: false,
-      strikes: 4,
-    });
-    resetCatalogCacheMemo();
-
-    // Expired entries are not returned, so a stale strike count from yesterday
-    // cannot make today's first failure back off for ten minutes.
-    expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([]);
-  });
-
-  it("is cleared for a host that recovers", async () => {
-    await writeStoredCooldown("raw.githubusercontent.com", {
-      until: NOW + 60_000,
-      exact: false,
-      strikes: 1,
-    });
-    await clearStoredCooldown("raw.githubusercontent.com");
-    resetCatalogCacheMemo();
-    expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([]);
-  });
-
-  it("keeps catalogs when only the cooldown is cleared, and vice versa", async () => {
-    // They share one file; a write to either must not clobber the other.
-    await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote");
-    await writeStoredCooldown("raw.githubusercontent.com", {
-      until: NOW + 60_000,
-      exact: false,
-      strikes: 1,
-    });
-
-    await clearStoredCooldown("raw.githubusercontent.com");
-    resetCatalogCacheMemo();
-    expect(await readCachedCatalog("magus")).not.toBeNull();
-
-    await writeStoredCooldown("raw.githubusercontent.com", {
-      until: NOW + 60_000,
-      exact: false,
-      strikes: 1,
-    });
-    await clearCachedCatalogs();
-    resetCatalogCacheMemo();
-    expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([
-      "raw.githubusercontent.com",
-    ]);
-  });
+	/**
+	 * Anchored to the real clock, not the fixed NOW the catalog tests use.
+	 * `hydrateGitHubBudget()` takes no clock parameter — it filters expired entries
+	 * against `Date.now()`, exactly as it does in production — so a cooldown stamped
+	 * relative to a fixed past NOW would be discarded as expired before the
+	 * assertion ever ran.
+	 */
+	let base: number;
+	beforeEach(() => {
+		base = Date.now();
+	});
+
+	/**
+	 * Wait until a write-behind cooldown has actually reached disk.
+	 *
+	 * This used to be `setTimeout(80)` — a guess at how long an unawaited write
+	 * takes, which is not a synchronisation point. `recordRateLimit` persists
+	 * fire-and-forget by design (`github-budget.ts` explains why), so on a loaded
+	 * runner the write had not landed when the next `hydrateGitHubBudget()` read,
+	 * and the restored strike count came back low. That failed CI as
+	 * `Expected: 3, Received: 2` on Linux while passing 15/15 on a quiet macOS
+	 * laptop — the signature of a timing guess, not of a real defect.
+	 *
+	 * Polling the store itself removes the guess: it returns as soon as the value
+	 * is observable, and only gives up after a deadline no healthy machine
+	 * reaches. `expected` is the strike count the caller just recorded; passing
+	 * nothing waits for any persisted entry at all.
+	 */
+	const flush = async (host: string, expected?: number): Promise<void> => {
+		const deadline = Date.now() + 5000;
+		for (;;) {
+			// `base` keeps the read on the same clock the writes used: cooldowns are
+			// dropped on read once expired, so reading with a later `now` could hide
+			// an entry that is genuinely there.
+			const stored = (await readStoredCooldowns(base))[host];
+			if (stored && (expected === undefined || stored.strikes >= expected)) {
+				return;
+			}
+			if (Date.now() > deadline) {
+				throw new Error(
+					`cooldown for ${host} never reached disk (wanted strikes >= ${expected ?? "any"}, got ${stored?.strikes ?? "nothing"})`,
+				);
+			}
+			await new Promise((r) => setTimeout(r, 10));
+		}
+	};
+
+	// Teardown hygiene, NOT a synchronisation point — which is why it is a plain
+	// sleep and `flush` is not. Its only job is to let an in-flight write land
+	// before the temp config dir is removed; a write that arrives afterwards
+	// recreates a file in a deleted directory and harms nothing. Polling for a
+	// specific host here would be wrong: several tests in this block end with
+	// nothing on disk on purpose.
+	afterEach(() => new Promise((r) => setTimeout(r, 50)));
+
+	it("is still in force in the next process", async () => {
+		// THE defect this store exists to fix. Without persistence, launch two fired
+		// six more doomed requests at a host it had already been refused by.
+		recordRateLimit("raw.githubusercontent.com", new Headers(), base);
+		await flush("raw.githubusercontent.com");
+
+		resetGitHubBudget();
+		resetCatalogCacheMemo();
+		expect(cooldownFor("raw.githubusercontent.com", base)).toBeNull(); // memory only
+
+		await hydrateGitHubBudget();
+		const restored = cooldownFor("raw.githubusercontent.com", base);
+		expect(restored).not.toBeNull();
+		expect(restored?.until).toBeGreaterThan(base);
+	});
+
+	it("keeps escalating the backoff across relaunches", async () => {
+		// Without the strike count surviving, every relaunch restarts the backoff at
+		// 30s — so a tool that is relaunched often never actually backs off, which is
+		// the behaviour that got the IP rate-limited in the first place.
+		//
+		// Written as one strike per launch, which is the real shape: a launch makes its
+		// requests, learns it is limited once, and exits.
+		const first = recordRateLimit("raw.githubusercontent.com", undefined, base);
+		expect(first.strikes).toBe(1);
+		await flush("raw.githubusercontent.com", 1);
+
+		resetGitHubBudget();
+		resetCatalogCacheMemo();
+		await hydrateGitHubBudget();
+
+		const second = recordRateLimit(
+			"raw.githubusercontent.com",
+			undefined,
+			base,
+		);
+		expect(second.strikes).toBe(2);
+		expect(second.until).toBeGreaterThan(first.until);
+		await flush("raw.githubusercontent.com", 2);
+
+		resetGitHubBudget();
+		resetCatalogCacheMemo();
+		await hydrateGitHubBudget();
+
+		const third = recordRateLimit("raw.githubusercontent.com", undefined, base);
+		expect(third.strikes).toBe(3);
+		expect(third.until).toBeGreaterThan(second.until);
+	});
+
+	it("preserves whether the timing was GitHub's or ours", async () => {
+		// `exact` decides between "resets in 4m" and "next attempt in 4m". Losing it
+		// across a relaunch would make the UI state a claim GitHub never made.
+		recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": "600" }),
+			base,
+		);
+		await flush("api.github.com");
+
+		resetGitHubBudget();
+		await hydrateGitHubBudget();
+		expect(cooldownFor("api.github.com", base)?.exact).toBe(true);
+	});
+
+	it("drops an expired cooldown rather than restoring it", async () => {
+		await writeStoredCooldown("raw.githubusercontent.com", {
+			until: NOW - 1000,
+			exact: false,
+			strikes: 4,
+		});
+		resetCatalogCacheMemo();
+
+		// Expired entries are not returned, so a stale strike count from yesterday
+		// cannot make today's first failure back off for ten minutes.
+		expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([]);
+	});
+
+	it("is cleared for a host that recovers", async () => {
+		await writeStoredCooldown("raw.githubusercontent.com", {
+			until: NOW + 60_000,
+			exact: false,
+			strikes: 1,
+		});
+		await clearStoredCooldown("raw.githubusercontent.com");
+		resetCatalogCacheMemo();
+		expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([]);
+	});
+
+	it("keeps catalogs when only the cooldown is cleared, and vice versa", async () => {
+		// They share one file; a write to either must not clobber the other.
+		await writeCachedCatalog("magus", [plugin("dev", "4.0.1")], "remote");
+		await writeStoredCooldown("raw.githubusercontent.com", {
+			until: NOW + 60_000,
+			exact: false,
+			strikes: 1,
+		});
+
+		await clearStoredCooldown("raw.githubusercontent.com");
+		resetCatalogCacheMemo();
+		expect(await readCachedCatalog("magus")).not.toBeNull();
+
+		await writeStoredCooldown("raw.githubusercontent.com", {
+			until: NOW + 60_000,
+			exact: false,
+			strikes: 1,
+		});
+		await clearCachedCatalogs();
+		resetCatalogCacheMemo();
+		expect(Object.keys(await readStoredCooldowns(NOW))).toEqual([
+			"raw.githubusercontent.com",
+		]);
+	});
 });