claudeup 6.2.0 → 6.3.0

package/src/__tests__/catalog-notice.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect } from "bun:test";
-import { buildCatalogNoticeText } from "../ui/adapters/catalogNotice";
+import { describe, expect, it } from "bun:test";
 import type { MarketplaceFetchFailure } from "../services/marketplace-fetcher";
+import { buildCatalogNoticeText } from "../ui/adapters/catalogNotice";
 
 /**
  * The banner is the only thing standing between the user and a screen that
@@ -17,139 +17,139 @@ import type { MarketplaceFetchFailure } from "../services/marketplace-fetcher";
 const NOW = 1_786_980_000_000;
 
 function failure(
-  marketplace: string,
-  kind: MarketplaceFetchFailure["kind"] = "rate-limited",
-  retryAt?: number,
+	marketplace: string,
+	kind: MarketplaceFetchFailure["kind"] = "rate-limited",
+	retryAt?: number,
 ): MarketplaceFetchFailure {
-  return { marketplace, kind, detail: `${kind} detail`, retryAt };
+	return { marketplace, kind, detail: `${kind} detail`, retryAt };
 }
 
 describe("buildCatalogNoticeText", () => {
-  it("says nothing when every catalog was actually checked", () => {
-    // The negative control. A banner that is always on carries no information.
-    expect(
-      buildCatalogNoticeText({
-        failures: [],
-        unverifiedPlugins: 0,
-        width: 120,
-        now: NOW,
-      }),
-    ).toBeNull();
-  });
+	it("says nothing when every catalog was actually checked", () => {
+		// The negative control. A banner that is always on carries no information.
+		expect(
+			buildCatalogNoticeText({
+				failures: [],
+				unverifiedPlugins: 0,
+				width: 120,
+				now: NOW,
+			}),
+		).toBeNull();
+	});
 
-  it("names the reason, because it determines what the user should do", () => {
-    const rate = buildCatalogNoticeText({
-      failures: [failure("magus")],
-      unverifiedPlugins: 3,
-      width: 120,
-      now: NOW,
-    });
-    expect(rate).toContain("GitHub rate limit");
+	it("names the reason, because it determines what the user should do", () => {
+		const rate = buildCatalogNoticeText({
+			failures: [failure("magus")],
+			unverifiedPlugins: 3,
+			width: 120,
+			now: NOW,
+		});
+		expect(rate).toContain("GitHub rate limit");
 
-    const slow = buildCatalogNoticeText({
-      failures: [failure("magus", "timeout")],
-      unverifiedPlugins: 3,
-      width: 120,
-      now: NOW,
-    });
-    expect(slow).toContain("GitHub timed out");
-  });
+		const slow = buildCatalogNoticeText({
+			failures: [failure("magus", "timeout")],
+			unverifiedPlugins: 3,
+			width: 120,
+			now: NOW,
+		});
+		expect(slow).toContain("GitHub timed out");
+	});
 
-  it("names one or two failing marketplaces but only counts many", () => {
-    const few = buildCatalogNoticeText({
-      failures: [failure("magus"), failure("magus-alpha")],
-      unverifiedPlugins: 0,
-      width: 160,
-      now: NOW,
-    });
-    expect(few).toContain("magus-alpha");
+	it("names one or two failing marketplaces but only counts many", () => {
+		const few = buildCatalogNoticeText({
+			failures: [failure("magus"), failure("magus-alpha")],
+			unverifiedPlugins: 0,
+			width: 160,
+			now: NOW,
+		});
+		expect(few).toContain("magus-alpha");
 
-    const many = buildCatalogNoticeText({
-      failures: ["a", "b", "c", "d", "e", "f"].map((n) => failure(n)),
-      unverifiedPlugins: 0,
-      width: 160,
-      now: NOW,
-    });
-    expect(many).toContain("6 catalogs unchecked");
-  });
+		const many = buildCatalogNoticeText({
+			failures: ["a", "b", "c", "d", "e", "f"].map((n) => failure(n)),
+			unverifiedPlugins: 0,
+			width: 160,
+			now: NOW,
+		});
+		expect(many).toContain("6 catalogs unchecked");
+	});
 
-  it("counts down to the retry instead of saying 'later'", () => {
-    // Answering "when can I try again" is the point. Guessing costs another
-    // request against the very limit the user is waiting out.
-    const line = buildCatalogNoticeText({
-      failures: [failure("magus", "rate-limited", NOW + 240_000)],
-      unverifiedPlugins: 17,
-      width: 160,
-      now: NOW,
-    }) as string;
-    expect(line).toContain("retrying in 4m");
-  });
+	it("counts down to the retry instead of saying 'later'", () => {
+		// Answering "when can I try again" is the point. Guessing costs another
+		// request against the very limit the user is waiting out.
+		const line = buildCatalogNoticeText({
+			failures: [failure("magus", "rate-limited", NOW + 240_000)],
+			unverifiedPlugins: 17,
+			width: 160,
+			now: NOW,
+		}) as string;
+		expect(line).toContain("retrying in 4m");
+	});
 
-  it("uses the soonest retry when several catalogs are waiting", () => {
-    const line = buildCatalogNoticeText({
-      failures: [
-        failure("magus", "rate-limited", NOW + 600_000),
-        failure("magus-alpha", "rate-limited", NOW + 45_000),
-      ],
-      unverifiedPlugins: 2,
-      width: 160,
-      now: NOW,
-    }) as string;
-    expect(line).toContain("retrying in 45s");
-  });
+	it("uses the soonest retry when several catalogs are waiting", () => {
+		const line = buildCatalogNoticeText({
+			failures: [
+				failure("magus", "rate-limited", NOW + 600_000),
+				failure("magus-alpha", "rate-limited", NOW + 45_000),
+			],
+			unverifiedPlugins: 2,
+			width: 160,
+			now: NOW,
+		}) as string;
+		expect(line).toContain("retrying in 45s");
+	});
 
-  it("falls back to the manual hint when no retry time is known", () => {
-    // raw.githubusercontent.com sends no retry-after, so for some failures there
-    // is genuinely no time to show. Inventing one would be worse than omitting it.
-    const line = buildCatalogNoticeText({
-      failures: [failure("magus", "network")],
-      unverifiedPlugins: 1,
-      width: 160,
-      now: NOW,
-    }) as string;
-    expect(line).toContain("r to retry");
-    expect(line).not.toContain("retrying in");
-  });
+	it("falls back to the manual hint when no retry time is known", () => {
+		// raw.githubusercontent.com sends no retry-after, so for some failures there
+		// is genuinely no time to show. Inventing one would be worse than omitting it.
+		const line = buildCatalogNoticeText({
+			failures: [failure("magus", "network")],
+			unverifiedPlugins: 1,
+			width: 160,
+			now: NOW,
+		}) as string;
+		expect(line).toContain("r to retry");
+		expect(line).not.toContain("retrying in");
+	});
 
-  it("ignores a retry time that has already passed", () => {
-    const line = buildCatalogNoticeText({
-      failures: [failure("magus", "rate-limited", NOW - 5_000)],
-      unverifiedPlugins: 1,
-      width: 160,
-      now: NOW,
-    }) as string;
-    expect(line).toContain("r to retry");
-  });
+	it("ignores a retry time that has already passed", () => {
+		const line = buildCatalogNoticeText({
+			failures: [failure("magus", "rate-limited", NOW - 5_000)],
+			unverifiedPlugins: 1,
+			width: 160,
+			now: NOW,
+		}) as string;
+		expect(line).toContain("r to retry");
+	});
 
-  it("keeps a retry affordance at every width, however narrow", () => {
-    const failures = ["a", "b", "c", "d", "e", "f"].map((n) =>
-      failure(n, "rate-limited", NOW + 90_000),
-    );
-    for (const width of [40, 60, 80, 100, 120, 200]) {
-      const line = buildCatalogNoticeText({
-        failures,
-        unverifiedPlugins: 331,
-        width,
-        now: NOW,
-      }) as string;
-      expect(line).not.toBeNull();
-      expect(line).toContain("retrying in");
-    }
-  });
+	it("keeps a retry affordance at every width, however narrow", () => {
+		const failures = ["a", "b", "c", "d", "e", "f"].map((n) =>
+			failure(n, "rate-limited", NOW + 90_000),
+		);
+		for (const width of [40, 60, 80, 100, 120, 200]) {
+			const line = buildCatalogNoticeText({
+				failures,
+				unverifiedPlugins: 331,
+				width,
+				now: NOW,
+			}) as string;
+			expect(line).not.toBeNull();
+			expect(line).toContain("retrying in");
+		}
+	});
 
-  it("never renders wider than the pane", () => {
-    const failures = ["a", "b", "c", "d", "e", "f"].map((n) =>
-      failure(n, "rate-limited", NOW + 90_000),
-    );
-    for (const width of [40, 60, 80, 100, 120, 200]) {
-      const line = buildCatalogNoticeText({
-        failures,
-        unverifiedPlugins: 331,
-        width,
-        now: NOW,
-      }) as string;
-      // +1 for `⚠` rendering double-width while String.length counts it once.
-      expect(line.length + 1).toBeLessThanOrEqual(width);
-    }
-  });
+	it("never renders wider than the pane", () => {
+		const failures = ["a", "b", "c", "d", "e", "f"].map((n) =>
+			failure(n, "rate-limited", NOW + 90_000),
+		);
+		for (const width of [40, 60, 80, 100, 120, 200]) {
+			const line = buildCatalogNoticeText({
+				failures,
+				unverifiedPlugins: 331,
+				width,
+				now: NOW,
+			}) as string;
+			// +1 for `⚠` rendering double-width while String.length counts it once.
+			expect(line.length + 1).toBeLessThanOrEqual(width);
+		}
+	});
 });

package/src/__tests__/cli-apply-seams.test.ts

@@ -11,16 +11,16 @@
  */
 
 import { describe, expect, mock, test } from "bun:test";
+import { parseArgs } from "../cli/update.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import { checkBinaries } from "../services/doctor-bins.js";
 import {
 	type ApplyReporter,
 	type PluginApplyDeps,
 	applyPlugins,
-	pluginNeedsWork,
 	installPluginInScope,
+	pluginNeedsWork,
 } from "../services/update-engine.js";
-import { parseArgs } from "../cli/update.js";
-import { checkBinaries } from "../services/doctor-bins.js";
-import type { PluginScope } from "../services/claude-cli.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
 import type { ResolvedBin } from "../types/index.js";
 
@@ -259,8 +259,10 @@ describe("checkBinaries onProbe", () => {
 		// A meter fed the raw index reads 0/3 while the first probe runs, which
 		// is correct — it has finished none of them.
 		const first: number[] = [];
-		await checkBinaries(bins, async () => true, (_n, index) =>
-			first.push(index),
+		await checkBinaries(
+			bins,
+			async () => true,
+			(_n, index) => first.push(index),
 		);
 		expect(first[0]).toBe(0);
 		expect(first.at(-1)).toBe(bins.length - 1);
@@ -273,8 +275,10 @@ describe("checkBinaries onProbe", () => {
 
 	test("an empty bin list announces nothing", async () => {
 		const seen: string[] = [];
-		const results = await checkBinaries([], async () => true, (n) =>
-			seen.push(n),
+		const results = await checkBinaries(
+			[],
+			async () => true,
+			(n) => seen.push(n),
 		);
 		expect(results).toEqual([]);
 		expect(seen).toEqual([]);

package/src/__tests__/cli-router.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { route } from "../cli/router.js";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { parseThemeFlag, route } from "../cli/router.js";
 
 // Silence the help banner and capture what the router prints, without
 // touching the network (--version) or spawning processes (claude/update).
@@ -17,9 +19,7 @@ beforeEach(() => {
 	errSpy = mock((...a: unknown[]) => {
 		errs.push(a.join(" "));
 	});
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.log = logSpy as any;
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.error = errSpy as any;
 });
 
@@ -109,3 +109,132 @@ describe("update / upgrade split", () => {
 		expect(help).not.toContain("update             Update claudeup itself");
 	});
 });
+
+describe("--theme", () => {
+	test("T-flag-ok: --theme light launches the TUI carrying the theme", async () => {
+		const r = await route(["--theme", "light"], "1.0.0");
+		expect(r).toEqual({ handled: false, launchTui: true, theme: "light" });
+	});
+
+	test("T-flag-ok: --theme=dark is the same flag", async () => {
+		const r = await route(["--theme=dark"], "1.0.0");
+		expect(r).toEqual({ handled: false, launchTui: true, theme: "dark" });
+	});
+
+	test("no --theme leaves the outcome without a theme key", async () => {
+		const r = await route([], "1.0.0");
+		expect("theme" in r).toBe(false);
+	});
+
+	test.each([
+		[["--theme", "solarized"]],
+		[["--theme", "purple"]],
+		[["--theme", "Dark"]],
+		[["--theme", "auto"]],
+		[["--theme"]],
+		[["--theme", "--no-refresh"]],
+		[["--theme="]],
+	])(
+		"T-flag-bad: %j is handled with exit 1 and names both words",
+		async (argv) => {
+			const r = await route(argv, "1.0.0");
+
+			expect(r).toEqual({ handled: true, exitCode: 1, launchTui: false });
+			const err = errs.join("\n");
+			expect(err).toContain("light");
+			expect(err).toContain("dark");
+			expect(err).toContain("--theme");
+		},
+	);
+
+	test("T-flag-cmd: --theme dark update strips the flag and dispatches update", () => {
+		// The seam: parseThemeFlag is what route() dispatches on. Asserting on
+		// `rest` proves `update` is the command token that reaches the switch,
+		// without running the real update handler against this machine.
+		const parsed = parseThemeFlag(["--theme", "dark", "update", "--dry-run"]);
+
+		expect(parsed).toEqual({
+			ok: true,
+			theme: "dark",
+			rest: ["update", "--dry-run"],
+		});
+	});
+
+	test("T-flag-cmd-route: route() hands update the stripped argv, not the original", async () => {
+		// The parse test above cannot catch a route() that re-reads the original
+		// argv inside the switch. Mock the command seam and assert what reached it.
+		// mock.module is process-global and survives mock.restore(), so the real
+		// module is put back at the end — a later file in the same `bun test`
+		// process must not inherit the fake.
+		const actual = { ...(await import("../cli/update.js")) };
+		const calls: string[][] = [];
+		mock.module("../cli/update.js", () => ({
+			...actual,
+			runUpdateCommand: async (args: string[]) => {
+				calls.push(args);
+				return 0;
+			},
+		}));
+		try {
+			const { route: routeWithMock } = await import("../cli/router.js");
+			const r = await routeWithMock(
+				["--theme", "dark", "update", "--dry-run"],
+				"1.0.0",
+			);
+
+			expect(r).toEqual({ handled: true, exitCode: 0, launchTui: false });
+			expect(calls).toEqual([["--dry-run"]]);
+		} finally {
+			mock.module("../cli/update.js", () => actual);
+		}
+	});
+
+	test("T-flag-bad: an invalid --theme does not launch the TUI even when a command follows", async () => {
+		const r = await route(["--theme", "purple", "update"], "1.0.0");
+
+		expect(r).toEqual({ handled: true, exitCode: 1, launchTui: false });
+		expect(errs.join("\n")).toContain("purple");
+	});
+
+	test("T-flag-cmd: the flag may follow the command too", () => {
+		expect(parseThemeFlag(["update", "--theme=light"])).toEqual({
+			ok: true,
+			theme: "light",
+			rest: ["update"],
+		});
+	});
+
+	test("T-flag-help: --help wins over a bad --theme, and documents the flag", async () => {
+		const r = await route(["--theme", "bogus", "--help"], "1.0.0");
+
+		expect(r).toEqual({ handled: true, exitCode: 0, launchTui: false });
+		const help = logs.join("\n");
+		expect(help).toContain("--theme light|dark");
+		expect(help).toContain("CLAUDEUP_THEME");
+		expect(help).toContain("TERM_THEME");
+		expect(errs).toEqual([]);
+	});
+
+	test("T-flag-live: `bun src/main.tsx --theme bogus` exits 1 before the renderer", () => {
+		// Exits in the router, so no tty is needed. stdin is a pipe on purpose:
+		// were the renderer reached, createCliRenderer would fail differently.
+		// --no-env-file: Bun autoloads the cwd's .env before user code, and the
+		// theme snapshot must precede any .env merge — same flag as the launchers.
+		const result = spawnSync(
+			"bun",
+			[
+				"--no-env-file",
+				path.join(import.meta.dir, "..", "main.tsx"),
+				"--theme",
+				"bogus",
+			],
+			{ encoding: "utf-8", input: "" },
+		);
+
+		expect(result.status).toBe(1);
+		expect(result.stderr).toContain("--theme");
+		expect(result.stderr).toContain("light");
+		expect(result.stderr).toContain("dark");
+		expect(result.stderr).toContain("bogus");
+	});
+});

package/src/__tests__/cli-update-view.test.ts

@@ -13,7 +13,6 @@
 
 import { afterEach, describe, expect, test } from "bun:test";
 import { setColorEnabled, stripAnsi, width } from "../cli/ansi.js";
-import type { UpdatePlan } from "../services/update-plan.js";
 import {
 	type ApplyState,
 	type Step,
@@ -25,6 +24,7 @@ import {
 	stepRecord,
 	summaryLine,
 } from "../cli/update-view.js";
+import type { UpdatePlan } from "../services/update-plan.js";
 
 afterEach(() => setColorEnabled(null));
 
@@ -159,7 +159,11 @@ describe("NO_COLOR", () => {
 			...stepFrame(steps(), 3, 500),
 			...stepRecord(steps(), 500),
 			...planReport(plan()),
-			...applyFrame({ done: 1, total: 4, current: "dev@magus", startedAt: 0 }, 2, 900),
+			...applyFrame(
+				{ done: 1, total: 4, current: "dev@magus", startedAt: 0 },
+				2,
+				900,
+			),
 			applyRow(true, "dev@magus", 20, "project", 400),
 			...summaryLine(2, 5, 1, 0, 9000),
 		].join("\n");
@@ -218,8 +222,20 @@ describe("bars", () => {
 		setColorEnabled(false);
 		const record = stepRecord(
 			[
-				{ label: "fast", state: "done", detail: "", startedAt: 0, endedAt: 100 },
-				{ label: "slow", state: "done", detail: "", startedAt: 0, endedAt: 1000 },
+				{
+					label: "fast",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 100,
+				},
+				{
+					label: "slow",
+					state: "done",
+					detail: "",
+					startedAt: 0,
+					endedAt: 1000,
+				},
 			],
 			1000,
 		);
@@ -230,7 +246,10 @@ describe("bars", () => {
 
 	test("a step that never ran does not divide by zero", () => {
 		setColorEnabled(false);
-		const record = stepRecord([{ label: "x", state: "pending", detail: "" }], 0);
+		const record = stepRecord(
+			[{ label: "x", state: "pending", detail: "" }],
+			0,
+		);
 		expect(record[0]).toContain("░");
 	});
 
@@ -259,9 +278,9 @@ describe("bars", () => {
 describe("sections", () => {
 	test("an empty section is omitted entirely, not printed as a heading", () => {
 		setColorEnabled(false);
-		const out = planReport(
-			plan({ bins: [], skills: [] }) as UpdatePlan,
-		).join("\n");
+		const out = planReport(plan({ bins: [], skills: [] }) as UpdatePlan).join(
+			"\n",
+		);
 		expect(out).toContain("Plugins");
 		expect(out).not.toContain("CLI");
 		expect(out).not.toContain("Skills");

package/src/__tests__/community-staleness.test.ts

@@ -73,7 +73,6 @@ afterEach(async () => {
 
 const source: CommunityStyleSource = COMMUNITY_SOURCES[0];
 const STYLE_ID = "attention-span--spartan";
-// biome-ignore lint/style/noNonNullAssertion: a registry entry the tests pin
 const style = resolveCommunityStyle(STYLE_ID)!.style;
 
 function upstreamText(body: string): string {
@@ -596,7 +595,6 @@ describe("the budget, which is the binding constraint", () => {
 			"nattergabriel--socratic",
 		];
 		for (const id of oneEach) {
-			// biome-ignore lint/style/noNonNullAssertion: ids pinned from the registry
 			const sourceId = resolveCommunityStyle(id)!.source.id;
 			await writeCommunityCheck(sourceId, {
 				checkedAt: NOW - 2 * COMMUNITY_CHECK_TTL_MS,

package/src/__tests__/component-badge.test.ts

@@ -33,11 +33,11 @@ function contrast(a: string, b: string): number {
 const KINDS = ["skill", "command", "agent", "mcp"] as const;
 
 describe("componentBadge", () => {
-	it("returns no chip when the terminal never answered the theme query", () => {
-		// Unknown means no tint, the same rule the scope bar's fill follows: a
-		// light wash guessed onto a dark page is a bright band on every row.
+	it("serves the dark pair before any resolution", () => {
+		// There is no unknown: dark is the stated default, so a chip is always a
+		// pair, never null, and the caller has no bare-glyph branch to keep.
 		for (const kind of KINDS) {
-			expect(componentBadge(kind)).toBeNull();
+			expect(componentBadge(kind)).toEqual(COMPONENT_BADGE[kind].dark);
 		}
 	});
 

package/src/__tests__/content-drift.test.ts

@@ -53,7 +53,10 @@ beforeEach(async () => {
 		recursive: true,
 	});
 	await fs.mkdir(path.join(repo, "plugins", "beta"), { recursive: true });
-	await fs.writeFile(path.join(repo, "plugins", "alpha", "skills", "s.md"), "v1");
+	await fs.writeFile(
+		path.join(repo, "plugins", "alpha", "skills", "s.md"),
+		"v1",
+	);
 	await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v1");
 	await setVersion("alpha", "1.0.0");
 	await setVersion("beta", "1.0.0");
@@ -66,6 +69,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
+	// 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;
 	await fs.rm(configDir, { recursive: true, force: true });