claudeup 4.35.1 → 4.37.0

package/src/__tests__/plugin-manager-fallback.test.ts

@@ -1,13 +1,43 @@
-import { describe, it, expect, beforeEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterAll, beforeAll } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import {
-  resolveMarketplacePlugins,
   clearMarketplaceCache,
+  fetchMarketplacePlugins,
+  getMarketplaceFetchFailures,
+  resolveMarketplacePlugins,
 } from "../services/marketplace-fetcher";
+import { resetGitHubBudget } from "../services/github-budget";
 import type {
   LocalMarketplace,
   LocalMarketplacePlugin,
 } from "../services/local-marketplace";
 
+/**
+ * Point the marketplace-clone lookup at an EMPTY temp directory.
+ *
+ * `resolveMarketplacePlugins` now consults a git remote ref before falling back
+ * to the checked-out clone. Without this, these tests found the operator's real
+ * `magus` clone, performed a live `git fetch`, and asserted against whatever
+ * happened to be published — 17 real plugins instead of the 2 in the fixture, and
+ * three seconds per test.
+ */
+let prevConfigDir: string | undefined;
+let emptyConfigDir: string;
+
+beforeAll(() => {
+  emptyConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "mp-fallback-"));
+  prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+  process.env.CLAUDE_CONFIG_DIR = emptyConfigDir;
+});
+
+afterAll(() => {
+  if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+  fs.rmSync(emptyConfigDir, { recursive: true, force: true });
+});
+
 /**
  * Regression coverage for the "deprecated everything" bug.
  *
@@ -33,6 +63,10 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
     // Session-level cache could otherwise carry over a previous test's
     // successful fetch and short-circuit the fallback path.
     clearMarketplaceCache();
+    // The per-host cooldown is deliberately NOT cleared by clearMarketplaceCache
+    // — it reflects GitHub's state, not ours — so a 429 in one test would
+    // otherwise gate every fetch in the next for the full backoff.
+    resetGitHubBudget();
   });
 
   it("falls back to the local cache when the remote fetch returns empty", async () => {
@@ -64,18 +98,45 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
       local,
     );
 
-    expect(resolved).toHaveLength(2);
-    expect(resolved.map((p) => p.name).sort()).toEqual([
+    expect(resolved.plugins).toHaveLength(2);
+    expect(resolved.plugins.map((p) => p.name).sort()).toEqual([
       "code-analysis",
       "dev",
     ]);
-    const codeAnalysis = resolved.find((p) => p.name === "code-analysis");
+    const codeAnalysis = resolved.plugins.find(
+      (p) => p.name === "code-analysis",
+    );
     expect(codeAnalysis?.version).toBe("5.3.0");
     expect(codeAnalysis?.description).toBe("Codebase investigation tools");
     expect(codeAnalysis?.category).toBe("development");
     expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
   });
 
+  it("labels the fallback answer as local-clone, not remote", async () => {
+    // The regression this guards: the fallback plugins were returned in the
+    // same shape as a successful remote fetch, so the caller compared installed
+    // versions against a clone nothing refreshes and reported "up to date".
+    // The source must travel with the data.
+    const local = new Map<string, LocalMarketplace>([
+      [
+        "magus",
+        buildLocalMarketplace("magus", [
+          { name: "terminal", version: "4.1.4", description: "" },
+        ]),
+      ],
+    ]);
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+
+    expect(resolved.source).toBe("local-clone");
+    expect(resolved.failure).toBeDefined();
+    expect(resolved.failure?.kind).toBe("invalid-repo");
+    expect(resolved.failure?.marketplace).toBe("magus");
+  });
+
   it("returns empty when both remote and cache are empty", async () => {
     const local = new Map<string, LocalMarketplace>();
     const resolved = await resolveMarketplacePlugins(
@@ -83,7 +144,9 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
       "not a valid repo string",
       local,
     );
-    expect(resolved).toEqual([]);
+    expect(resolved.plugins).toEqual([]);
+    expect(resolved.source).toBe("none");
+    expect(resolved.failure).toBeDefined();
   });
 
   it("returns empty when remote fails AND cache exists but has no plugins", async () => {
@@ -95,7 +158,8 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
       "not a valid repo string",
       local,
     );
-    expect(resolved).toEqual([]);
+    expect(resolved.plugins).toEqual([]);
+    expect(resolved.source).toBe("none");
   });
 
   it("does not consult the cache when the remote returns plugins", async () => {
@@ -115,6 +179,134 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
       "not a valid repo string",
       local,
     );
-    expect(resolved).toEqual([]);
+    expect(resolved.plugins).toEqual([]);
+    expect(resolved.source).toBe("none");
+  });
+});
+
+/**
+ * The defect class these cover: a failed check that renders as a passed one.
+ *
+ * `fetchMarketplacePlugins` used to return `[]` for a rate limit, a timeout, a
+ * bad repo string and a genuinely empty marketplace alike. Every caller then had
+ * to guess, and all of them guessed "fine".
+ */
+describe("fetchMarketplacePlugins — failures are values", () => {
+  beforeEach(() => {
+    clearMarketplaceCache();
+    resetGitHubBudget();
+  });
+
+  it("classifies a rate limit distinctly from a network problem", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response("rate limited", {
+        status: 429,
+        statusText: "Too Many Requests",
+      })) as typeof globalThis.fetch;
+    try {
+      const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+      expect(result.plugins).toEqual([]);
+      expect(result.failure?.kind).toBe("rate-limited");
+      expect(result.failure?.httpStatus).toBe(429);
+      expect(result.failure?.detail).toContain("rate limit");
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("records the failure so the UI can report it without re-fetching", async () => {
+    const original = globalThis.fetch;
+    let calls = 0;
+    globalThis.fetch = (async () => {
+      calls++;
+      return new Response("nope", { status: 500, statusText: "Server Error" });
+    }) as typeof globalThis.fetch;
+    try {
+      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+
+      const failures = getMarketplaceFetchFailures();
+      expect(failures.map((f) => f.marketplace)).toContain("magus");
+      expect(failures.find((f) => f.marketplace === "magus")?.kind).toBe("http");
+
+      // Second call must be served from the negative cache. Re-attempting on
+      // every screen mount is what cost 30-45s of "Loading..." per tab switch.
+      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+      expect(calls).toBe(1);
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("reports no failures when the fetch succeeds", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      Response.json({
+        metadata: { version: "9.0.3" },
+        plugins: [{ name: "terminal", version: "4.1.6" }],
+      })) as typeof globalThis.fetch;
+    try {
+      const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+      expect(result.failure).toBeUndefined();
+      expect(result.plugins).toHaveLength(1);
+      expect(getMarketplaceFetchFailures()).toEqual([]);
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("does not send a request while the rate-limit window is still open", async () => {
+    // Deliberate: an explicit refresh clears OUR caches but not GitHub's limit.
+    // Retrying inside a known window cannot succeed, and on some endpoints a
+    // rejected request extends the penalty — so the screen waits and counts down
+    // instead. `clearMarketplaceCache()` must not be a way around that.
+    const original = globalThis.fetch;
+    let calls = 0;
+    globalThis.fetch = (async () => {
+      calls++;
+      return new Response("nope", { status: 429 });
+    }) as typeof globalThis.fetch;
+    try {
+      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+      expect(calls).toBe(1);
+
+      clearMarketplaceCache();
+      const second = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+
+      expect(calls).toBe(1); // no second request went out
+      expect(second.failure?.kind).toBe("rate-limited");
+      expect(second.failure?.retryAt).toBeGreaterThan(Date.now());
+    } finally {
+      globalThis.fetch = original;
+    }
+  });
+
+  it("clears the recorded failure once the window passes and the fetch succeeds", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response("nope", { status: 429 })) as typeof globalThis.fetch;
+    try {
+      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+      expect(getMarketplaceFetchFailures()).toHaveLength(1);
+
+      // The cooldown expiring is what unblocks the retry — this stands in for the
+      // clock reaching `retryAt`, which is when the screen refetches by itself.
+      resetGitHubBudget();
+      clearMarketplaceCache();
+      globalThis.fetch = (async () =>
+        Response.json({
+          plugins: [{ name: "terminal", version: "4.2.0" }],
+        })) as typeof globalThis.fetch;
+
+      const recovered = await fetchMarketplacePlugins(
+        "magus",
+        "MadAppGang/magus",
+      );
+      expect(recovered.failure).toBeUndefined();
+      expect(recovered.plugins).toHaveLength(1);
+      expect(getMarketplaceFetchFailures()).toEqual([]);
+    } finally {
+      globalThis.fetch = original;
+    }
   });
 });

package/src/__tests__/scope-squares.test.tsx

@@ -0,0 +1,165 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type React from "react";
+import { ScopeSquares } from "../ui/components/primitives/ScopeSquares.js";
+import {
+	SCOPE_OFF_FALLBACK,
+	SCOPE_OFF_FILL,
+	resetThemeMode,
+	setThemeMode,
+} from "../ui/theme-mode.js";
+import { CONTRAST_REFERENCE, theme } from "../ui/theme.js";
+
+/**
+ * The scope bar is three filled segments; only the fill says lit or unlit.
+ *
+ * Its unlit fill was `theme.colors.muted` (#6B7280) — the same mid-dark grey as
+ * de-emphasised text. On a light page that is a *dark* block, so an unlit segment
+ * carried the same visual weight as a lit one and the bar read as three similar
+ * blobs: "non installed state is dark as well - confusing".
+ *
+ * An unlit segment has to recede toward the page, which is exactly what a fixed
+ * colour cannot do — a pale fill that sits quietly on cream is a bright block on
+ * near-black. So the fill follows the detected terminal, and these tests pin both
+ * that behaviour and its fallback.
+ */
+
+interface SpanLike {
+	props: { fg: string; children: string };
+}
+
+function segments(el: React.ReactElement): SpanLike[] {
+	const children = (el.props as { children: unknown }).children;
+	return (Array.isArray(children) ? children : [children]) as SpanLike[];
+}
+
+const glyphs = (el: React.ReactElement) =>
+	segments(el).map((c) => c.props.children);
+const fills = (el: React.ReactElement) => segments(el).map((c) => c.props.fg);
+
+function relativeLuminance(hex: string): number {
+	const n = hex.replace("#", "");
+	const ch = [0, 2, 4].map((i) => Number.parseInt(n.slice(i, i + 2), 16) / 255);
+	const lin = ch.map((c) =>
+		c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4,
+	);
+	return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
+}
+
+afterEach(() => resetThemeMode());
+
+describe("every segment is a filled block", () => {
+	test("lit and unlit alike use the filled glyph", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: true, project: false, local: true });
+		expect(glyphs(el)).toEqual(["■", "■", "■"]);
+	});
+
+	test("local is omitted when the caller does not pass it", () => {
+		setThemeMode("light");
+		expect(glyphs(ScopeSquares({ user: true, project: false }))).toEqual([
+			"■",
+			"■",
+		]);
+	});
+});
+
+describe("fill distinguishes lit from unlit", () => {
+	test("each lit segment keeps its own scope hue", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: true, project: true, local: true });
+		expect(fills(el)).toEqual([
+			theme.scopes.user,
+			theme.scopes.project,
+			theme.scopes.local,
+		]);
+	});
+
+	test("unlit segments take the page-relative off fill", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.light]));
+
+		setThemeMode("dark");
+		const dark = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(dark))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
+	});
+
+	test("a mixed bar shows lit and unlit fills side by side", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({ user: false, project: true, local: false });
+		expect(fills(el)).toEqual([
+			SCOPE_OFF_FILL.light,
+			theme.scopes.project,
+			SCOPE_OFF_FILL.light,
+		]);
+	});
+
+	test("an undetected terminal still gets a visible fill, never nothing", () => {
+		resetThemeMode();
+		const el = ScopeSquares({ user: false, project: false, local: false });
+		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FALLBACK]));
+	});
+});
+
+describe("the unlit fill recedes toward the page it is on", () => {
+	/**
+	 * How far a fill sits from the page, relative to the NEAREST lit segment.
+	 *
+	 * The naive property — "unlit is closer to the page than a lit colour" — is
+	 * too weak, and measurably so: the old #6B7280 satisfied it on a light page
+	 * (0.766 vs 0.774) while still looking wrong. What made the bar read as three
+	 * similar blobs was that unlit sat **99% as far** from the page as a lit
+	 * segment: essentially the same visual weight. Ratio, not order, is the
+	 * property that captures the defect.
+	 */
+	const pageDistanceRatio = (fill: string, page: string) => {
+		const d = (hex: string) =>
+			Math.abs(relativeLuminance(hex) - relativeLuminance(page));
+		const nearestLit = Math.min(...Object.values(theme.scopes).map(d));
+		return d(fill) / nearestLit;
+	};
+
+	/** Unlit must be at most half as far from the page as the nearest lit segment. */
+	const MAX_RATIO = 0.5;
+
+	test("light page: unlit recedes (measured 0.32)", () => {
+		expect(
+			pageDistanceRatio(SCOPE_OFF_FILL.light, CONTRAST_REFERENCE.light),
+		).toBeLessThan(MAX_RATIO);
+	});
+
+	test("dark page: unlit recedes (measured 0.22)", () => {
+		expect(
+			pageDistanceRatio(SCOPE_OFF_FILL.dark, CONTRAST_REFERENCE.dark),
+		).toBeLessThan(MAX_RATIO);
+	});
+
+	test("the old mid-grey fails the property on BOTH pages", () => {
+		// Pins why the value changed, and guards against anyone reinstating it:
+		// 0.99 on cream and 1.10 on near-black — an unlit segment as heavy as a lit
+		// one, or heavier.
+		expect(
+			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.light),
+		).toBeGreaterThan(MAX_RATIO);
+		expect(
+			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.dark),
+		).toBeGreaterThan(MAX_RATIO);
+	});
+});
+
+describe("selected rows", () => {
+	test("unlit segments recede into the selection block, lit take its ink", () => {
+		setThemeMode("light");
+		const el = ScopeSquares({
+			user: true,
+			project: false,
+			local: true,
+			selected: true,
+		});
+		expect(fills(el)).toEqual([
+			theme.selection.fg,
+			theme.selection.bg,
+			theme.selection.fg,
+		]);
+	});
+});