claudeup 6.2.1 → 6.3.2

package/src/__tests__/profile-command.test.ts

@@ -3,11 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
-import {
-	listProfiles,
-	showProfile,
-	switchProfile,
-} from "../cli/profile.js";
+import { listProfiles, showProfile, switchProfile } from "../cli/profile.js";
 import { activeProfile } from "../services/symlink-manager.js";
 import type { ProfileManifest } from "../types/index.js";
 
@@ -17,9 +13,7 @@ let errs: string[];
 beforeEach(() => {
 	logs = [];
 	errs = [];
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.log = mock((...a: unknown[]) => logs.push(a.join(" "))) as any;
-	// biome-ignore lint/suspicious/noExplicitAny: test double
 	console.error = mock((...a: unknown[]) => errs.push(a.join(" "))) as any;
 });
 afterEach(() => mock.restore());

package/src/__tests__/profile-materializer.test.ts

@@ -65,7 +65,9 @@ describe("buildProfileSettings", () => {
 	});
 
 	test("no union given -> no false entries (unchanged legacy shape)", () => {
-		const s = buildProfileSettings(closure({ plugins: { "dev@magus": "latest" } }));
+		const s = buildProfileSettings(
+			closure({ plugins: { "dev@magus": "latest" } }),
+		);
 		expect(s.enabledPlugins).toEqual({ "dev@magus": true });
 	});
 });
@@ -98,14 +100,28 @@ describe("materializeProfile", () => {
 			project,
 		);
 		expect(dir).toBe(profileDir("frontend", project));
-		expect((await fs.readJson(join(dir, "settings.json"))).enabledPlugins["dev@magus"]).toBe(true);
-		expect((await fs.readJson(join(dir, "mcp.json"))).mcpServers.x.command).toBe("y");
+		expect(
+			(await fs.readJson(join(dir, "settings.json"))).enabledPlugins[
+				"dev@magus"
+			],
+		).toBe(true);
+		expect(
+			(await fs.readJson(join(dir, "mcp.json"))).mcpServers.x.command,
+		).toBe("y");
 		expect(await fs.pathExists(join(dir, "skills"))).toBe(true);
 	});
 
 	test("is idempotent (re-materialize overwrites cleanly)", async () => {
-		await materializeProfile("p", closure({ plugins: { "a@m": "latest" } }), project);
-		const dir = await materializeProfile("p", closure({ plugins: { "b@m": "latest" } }), project);
+		await materializeProfile(
+			"p",
+			closure({ plugins: { "a@m": "latest" } }),
+			project,
+		);
+		const dir = await materializeProfile(
+			"p",
+			closure({ plugins: { "b@m": "latest" } }),
+			project,
+		);
 		const settings = await fs.readJson(join(dir, "settings.json"));
 		expect(settings.enabledPlugins).toEqual({ "b@m": true });
 	});
@@ -120,7 +136,10 @@ describe("materializeProfile", () => {
 		const dir = await materializeProfile("p", closure(), project);
 
 		expect(
-			await fs.readFile(join(dir, "skills", "systematic-debugging", "SKILL.md"), "utf8"),
+			await fs.readFile(
+				join(dir, "skills", "systematic-debugging", "SKILL.md"),
+				"utf8",
+			),
 		).toContain("committed project skill");
 	});
 
@@ -157,11 +176,15 @@ describe("materializeProfile", () => {
 			project,
 			union,
 		);
-		expect((await fs.readJson(join(fe, "settings.json"))).enabledPlugins).toEqual({
+		expect(
+			(await fs.readJson(join(fe, "settings.json"))).enabledPlugins,
+		).toEqual({
 			"designer@magus": true,
 			"terminal@magus": false,
 		});
-		expect((await fs.readJson(join(be, "settings.json"))).enabledPlugins).toEqual({
+		expect(
+			(await fs.readJson(join(be, "settings.json"))).enabledPlugins,
+		).toEqual({
 			"designer@magus": false,
 			"terminal@magus": true,
 		});

package/src/__tests__/profile-sync.test.ts

@@ -31,7 +31,10 @@ describe("computeSync (pure)", () => {
 		expect(next.plugins!["dev@magus"]).toBe("2.9.0");
 		// new plugin added as latest
 		expect(next.plugins!["designer@magus"]).toBe("latest");
-		expect(changes).toContainEqual({ kind: "plugin-added", detail: "designer@magus" });
+		expect(changes).toContainEqual({
+			kind: "plugin-added",
+			detail: "designer@magus",
+		});
 	});
 
 	test("removes a plugin that was disabled", () => {
@@ -41,7 +44,10 @@ describe("computeSync (pure)", () => {
 			{ mcpServers: {} },
 		);
 		expect(next.plugins!["terminal@magus"]).toBeUndefined();
-		expect(changes).toContainEqual({ kind: "plugin-removed", detail: "terminal@magus" });
+		expect(changes).toContainEqual({
+			kind: "plugin-removed",
+			detail: "terminal@magus",
+		});
 	});
 
 	test("captures a settings change and an mcp change", () => {
@@ -75,7 +81,14 @@ describe("computeSync (pure)", () => {
 		const withStamp: ProfileManifestEntry = { ...entry, updatedAt: "OLD" };
 		const { entry: changed } = computeSync(
 			withStamp,
-			{ enabledPlugins: { "dev@magus": true, "terminal@magus": true, "new@magus": true }, effortLevel: "high" },
+			{
+				enabledPlugins: {
+					"dev@magus": true,
+					"terminal@magus": true,
+					"new@magus": true,
+				},
+				effortLevel: "high",
+			},
 			{ mcpServers: {} },
 			"2026-07-27T00:00:00.000Z",
 		);
@@ -84,7 +97,10 @@ describe("computeSync (pure)", () => {
 		// Unchanged sync leaves updatedAt alone.
 		const { entry: same } = computeSync(
 			withStamp,
-			{ enabledPlugins: { "dev@magus": true, "terminal@magus": true }, effortLevel: "high" },
+			{
+				enabledPlugins: { "dev@magus": true, "terminal@magus": true },
+				effortLevel: "high",
+			},
 			{ mcpServers: {} },
 			"2026-07-27T00:00:00.000Z",
 		);
@@ -99,7 +115,9 @@ describe("syncProfile (io)", () => {
 		await fs.ensureDir(join(dir, ".claude"));
 		await fs.writeJson(join(dir, ".claude", "profiles.json"), {
 			version: 2,
-			profiles: { frontend: { name: "Frontend", plugins: { "dev@magus": "2.9.0" } } },
+			profiles: {
+				frontend: { name: "Frontend", plugins: { "dev@magus": "2.9.0" } },
+			},
 		});
 	});
 	afterEach(async () => {

package/src/__tests__/registry-version-resolution.test.ts

@@ -14,61 +14,75 @@ import type { InstalledPluginEntry } from "../types/index.js";
  */
 
 const entry = (
-  scope: InstalledPluginEntry["scope"],
-  version: string,
-  projectPath?: string,
+	scope: InstalledPluginEntry["scope"],
+	version: string,
+	projectPath?: string,
 ): InstalledPluginEntry => ({
-  scope,
-  version,
-  projectPath,
-  installPath: `/cache/${version}`,
-  installedAt: "2026-01-01T00:00:00.000Z",
-  lastUpdated: "2026-01-01T00:00:00.000Z",
+	scope,
+	version,
+	projectPath,
+	installPath: `/cache/${version}`,
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
 });
 
 describe("pickRegistryEntry — scope resolution", () => {
-  test("user scope takes the user entry, ignoring project installs", () => {
-    const entries = [
-      entry("project", "1.0.0", "/proj/a"),
-      entry("user", "2.0.0"),
-      entry("project", "3.0.0", "/proj/b"),
-    ];
-    expect(pickRegistryEntry(entries, "user")?.version).toBe("2.0.0");
-  });
+	test("user scope takes the user entry, ignoring project installs", () => {
+		const entries = [
+			entry("project", "1.0.0", "/proj/a"),
+			entry("user", "2.0.0"),
+			entry("project", "3.0.0", "/proj/b"),
+		];
+		expect(pickRegistryEntry(entries, "user")?.version).toBe("2.0.0");
+	});
 
-  test("project scope prefers the entry pinned to that exact project", () => {
-    const entries = [
-      entry("user", "2.0.0"),
-      entry("project", "1.0.0", "/proj/a"),
-      entry("project", "3.0.0", "/proj/b"),
-    ];
-    expect(pickRegistryEntry(entries, "project", "/proj/b")?.version).toBe("3.0.0");
-  });
+	test("project scope prefers the entry pinned to that exact project", () => {
+		const entries = [
+			entry("user", "2.0.0"),
+			entry("project", "1.0.0", "/proj/a"),
+			entry("project", "3.0.0", "/proj/b"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/b")?.version).toBe(
+			"3.0.0",
+		);
+	});
 
-  test("project scope falls back to the user entry when the project has no install", () => {
-    // This is the statusline case: installed at user scope, absent from project
-    // settings, previously surfaced as "no version" and skipped by update checks.
-    const entries = [entry("user", "2.1.2"), entry("project", "1.0.0", "/proj/other")];
-    expect(pickRegistryEntry(entries, "project", "/proj/mine")?.version).toBe("2.1.2");
-  });
+	test("project scope falls back to the user entry when the project has no install", () => {
+		// This is the statusline case: installed at user scope, absent from project
+		// settings, previously surfaced as "no version" and skipped by update checks.
+		const entries = [
+			entry("user", "2.1.2"),
+			entry("project", "1.0.0", "/proj/other"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/mine")?.version).toBe(
+			"2.1.2",
+		);
+	});
 
-  test("project paths are compared resolved, not as raw strings", () => {
-    const entries = [entry("project", "4.2.0", "/proj/a/../a")];
-    expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe("4.2.0");
-  });
+	test("project paths are compared resolved, not as raw strings", () => {
+		const entries = [entry("project", "4.2.0", "/proj/a/../a")];
+		expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe(
+			"4.2.0",
+		);
+	});
 
-  test("a local-scope entry satisfies a project lookup for the same path", () => {
-    const entries = [entry("local", "5.0.0", "/proj/a"), entry("user", "1.0.0")];
-    expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe("5.0.0");
-  });
+	test("a local-scope entry satisfies a project lookup for the same path", () => {
+		const entries = [
+			entry("local", "5.0.0", "/proj/a"),
+			entry("user", "1.0.0"),
+		];
+		expect(pickRegistryEntry(entries, "project", "/proj/a")?.version).toBe(
+			"5.0.0",
+		);
+	});
 
-  test("no project path and no user entry yields undefined, not a wrong project's version", () => {
-    const entries = [entry("project", "9.9.9", "/proj/somewhere-else")];
-    expect(pickRegistryEntry(entries, "project")).toBeUndefined();
-  });
+	test("no project path and no user entry yields undefined, not a wrong project's version", () => {
+		const entries = [entry("project", "9.9.9", "/proj/somewhere-else")];
+		expect(pickRegistryEntry(entries, "project")).toBeUndefined();
+	});
 
-  test("empty and missing entry lists are handled", () => {
-    expect(pickRegistryEntry([], "user")).toBeUndefined();
-    expect(pickRegistryEntry(undefined, "user")).toBeUndefined();
-  });
+	test("empty and missing entry lists are handled", () => {
+		expect(pickRegistryEntry([], "user")).toBeUndefined();
+		expect(pickRegistryEntry(undefined, "user")).toBeUndefined();
+	});
 });

package/src/__tests__/resolve-executable.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, symlink, writeFile, chmod } from "node:fs/promises";
+import { chmod, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { resolveExecutable } from "../utils/command-utils.js";

package/src/__tests__/resolver.test.ts

@@ -53,7 +53,11 @@ describe("dedupeBins — precedence by order", () => {
 
 	test("a later entry fills a version the winner left unset", () => {
 		const loose: BinRequirement = { name: "tmux", via: "brew" };
-		const pinned: BinRequirement = { name: "tmux", via: "brew", version: "3.4" };
+		const pinned: BinRequirement = {
+			name: "tmux",
+			via: "brew",
+			version: "3.4",
+		};
 		const result = dedupeBins([
 			{ bin: loose, source: "plugin:a" },
 			{ bin: pinned, source: "plugin:b" },
@@ -71,8 +75,8 @@ describe("resolveExtends", () => {
 			settings: { effortLevel: "max" },
 		};
 		const merged = resolveExtends(entry);
-		// must-have contributes statusline@magus + multimodel@magus at "latest".
-		expect(merged.plugins!["statusline@magus"]).toBe("latest");
+		// must-have contributes setup@magus + multimodel@magus at "latest".
+		expect(merged.plugins!["setup@magus"]).toBe("latest");
 		expect(merged.plugins!["multimodel@magus"]).toBe("latest");
 		// Entry's own plugin pin is preserved.
 		expect(merged.plugins!["dev@magus"]).toBe("2.9.0");
@@ -150,9 +154,9 @@ describe("resolveProfile", () => {
 	});
 
 	test("throws for an unknown profile id", async () => {
-		await expect(
-			resolveProfile(manifestOf({}), "ghost"),
-		).rejects.toThrow('Profile "ghost" not found');
+		await expect(resolveProfile(manifestOf({}), "ghost")).rejects.toThrow(
+			'Profile "ghost" not found',
+		);
 	});
 });
 
@@ -191,12 +195,22 @@ describe("resolveAllProfiles — union", () => {
 
 	test("conflicting explicit pins resolve to the higher semver, order-independent, and are reported", async () => {
 		const mk = (order: "ab" | "ba"): ProfileManifest => {
-			const a: ProfileManifestEntry = { name: "A", plugins: { "dev@magus": "2.9.0" } };
-			const b: ProfileManifestEntry = { name: "B", plugins: { "dev@magus": "2.11.0" } };
+			const a: ProfileManifestEntry = {
+				name: "A",
+				plugins: { "dev@magus": "2.9.0" },
+			};
+			const b: ProfileManifestEntry = {
+				name: "B",
+				plugins: { "dev@magus": "2.11.0" },
+			};
 			return manifestOf(order === "ab" ? { a, b } : { b, a });
 		};
-		const ab = await resolveAllProfiles(mk("ab"), { binResolver: fakeBinResolver({}) });
-		const ba = await resolveAllProfiles(mk("ba"), { binResolver: fakeBinResolver({}) });
+		const ab = await resolveAllProfiles(mk("ab"), {
+			binResolver: fakeBinResolver({}),
+		});
+		const ba = await resolveAllProfiles(mk("ba"), {
+			binResolver: fakeBinResolver({}),
+		});
 
 		// Deterministic: higher pin wins regardless of profile order.
 		expect(ab.plugins["dev@magus"]).toBe("2.11.0");
@@ -211,8 +225,12 @@ describe("resolveAllProfiles — union", () => {
 			a: { name: "A", cliTools: { claudish: "1.2.0" } },
 			b: { name: "B", cliTools: { claudish: "1.5.0" } },
 		});
-		const union = await resolveAllProfiles(manifest, { binResolver: fakeBinResolver({}) });
-		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe("1.5.0");
+		const union = await resolveAllProfiles(manifest, {
+			binResolver: fakeBinResolver({}),
+		});
+		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe(
+			"1.5.0",
+		);
 		expect(union.conflicts?.some((c) => c.includes("claudish"))).toBe(true);
 	});
 });
@@ -255,7 +273,9 @@ describe("marketplaces derived from plugin ids", () => {
 			},
 		});
 		const c = await resolveProfile(manifest, "mixed", noBins);
-		expect(c.marketplaces["magus-marketing"]?.repo).toBe("MadAppGang/magus-marketing");
+		expect(c.marketplaces["magus-marketing"]?.repo).toBe(
+			"MadAppGang/magus-marketing",
+		);
 		expect(c.marketplaces["magus-alpha"]?.repo).toBe("MadAppGang/magus-alpha");
 	});
 
@@ -263,7 +283,9 @@ describe("marketplaces derived from plugin ids", () => {
 		const manifest = manifestOf({
 			pinned: {
 				name: "Pinned",
-				marketplaces: { magus: { source: "github", repo: "MadAppGang/magus-fork" } },
+				marketplaces: {
+					magus: { source: "github", repo: "MadAppGang/magus-fork" },
+				},
 				plugins: { "dev@magus": "latest" },
 			},
 		});
@@ -273,7 +295,10 @@ describe("marketplaces derived from plugin ids", () => {
 
 	test("an unknown marketplace is left for the manifest to declare", async () => {
 		const manifest = manifestOf({
-			third: { name: "Third", plugins: { "thing@someones-marketplace": "latest" } },
+			third: {
+				name: "Third",
+				plugins: { "thing@someones-marketplace": "latest" },
+			},
 		});
 		const c = await resolveProfile(manifest, "third", noBins);
 		expect(c.marketplaces["someones-marketplace"]).toBeUndefined();

package/src/__tests__/scope-action.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import {
-  isInstalledInScope,
-  resolveScopeAction,
+	isInstalledInScope,
+	resolveScopeAction,
 } from "../services/plugin-manager.js";
 
 /**
@@ -19,64 +19,66 @@ import {
  */
 
 describe("isInstalledInScope", () => {
-  test("enabled with a registry version is installed", () => {
-    expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
-  });
+	test("enabled with a registry version is installed", () => {
+		expect(isInstalledInScope({ enabled: true, version: "3.0.2" })).toBe(true);
+	});
 
-  test("enabled with NO version is not installed — the broken state", () => {
-    // dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
-    // installed_plugins.json had no entry resolving for the project path.
-    expect(isInstalledInScope({ enabled: true })).toBe(false);
-  });
+	test("enabled with NO version is not installed — the broken state", () => {
+		// dev@magus, measured: `.claude/settings.json` had "dev@magus": true while
+		// installed_plugins.json had no entry resolving for the project path.
+		expect(isInstalledInScope({ enabled: true })).toBe(false);
+	});
 
-  test("a version with the flag off is not installed either", () => {
-    expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(false);
-  });
+	test("a version with the flag off is not installed either", () => {
+		expect(isInstalledInScope({ enabled: false, version: "3.0.2" })).toBe(
+			false,
+		);
+	});
 
-  test("an absent scope is not installed", () => {
-    expect(isInstalledInScope(undefined)).toBe(false);
-  });
+	test("an absent scope is not installed", () => {
+		expect(isInstalledInScope(undefined)).toBe(false);
+	});
 
-  test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
-    expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
-  });
+	test('"0.0.0" counts as installed — Anthropic official plugins record it', () => {
+		expect(isInstalledInScope({ enabled: true, version: "0.0.0" })).toBe(true);
+	});
 });
 
 describe("resolveScopeAction", () => {
-  test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
-    // This is the reported bug. Before the fix this returned "uninstall".
-    expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
-  });
+	test("REGRESSION: enabled but not installed resolves to install, never uninstall", () => {
+		// This is the reported bug. Before the fix this returned "uninstall".
+		expect(resolveScopeAction({ enabled: true }, "3.0.2")).toBe("install");
+	});
 
-  test("a scope that was never enabled resolves to install", () => {
-    expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
-    expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
-  });
+	test("a scope that was never enabled resolves to install", () => {
+		expect(resolveScopeAction(undefined, "3.0.2")).toBe("install");
+		expect(resolveScopeAction({ enabled: false }, "3.0.2")).toBe("install");
+	});
 
-  test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
-    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "3.0.2")).toBe(
-      "uninstall",
-    );
-  });
+	test("a healthy install at the latest version resolves to uninstall (toggle off)", () => {
+		expect(
+			resolveScopeAction({ enabled: true, version: "3.0.2" }, "3.0.2"),
+		).toBe("uninstall");
+	});
 
-  test("a healthy install behind the catalog resolves to update", () => {
-    expect(resolveScopeAction({ enabled: true, version: "2.9.0" }, "3.0.2")).toBe(
-      "update",
-    );
-  });
+	test("a healthy install behind the catalog resolves to update", () => {
+		expect(
+			resolveScopeAction({ enabled: true, version: "2.9.0" }, "3.0.2"),
+		).toBe("update");
+	});
 
-  test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
-    // There is nothing to update *to*, so toggling must still mean uninstall.
-    expect(resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0")).toBe(
-      "uninstall",
-    );
-  });
+	test('an unknown catalog version ("0.0.0") never fabricates an update', () => {
+		// There is nothing to update *to*, so toggling must still mean uninstall.
+		expect(
+			resolveScopeAction({ enabled: true, version: "3.0.2" }, "0.0.0"),
+		).toBe("uninstall");
+	});
 
-  test("installed with unknown version resolves to update when a real version is published", () => {
-    // "0.0.0" installed against a real catalog version is a genuine upgrade
-    // path, not the broken state — it must not be treated as uninstall.
-    expect(resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2")).toBe(
-      "update",
-    );
-  });
+	test("installed with unknown version resolves to update when a real version is published", () => {
+		// "0.0.0" installed against a real catalog version is a genuine upgrade
+		// path, not the broken state — it must not be treated as uninstall.
+		expect(
+			resolveScopeAction({ enabled: true, version: "0.0.0" }, "3.0.2"),
+		).toBe("update");
+	});
 });

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

@@ -2,7 +2,6 @@ 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,
@@ -19,8 +18,8 @@ import { CONTRAST_REFERENCE, theme } from "../ui/theme.js";
  *
  * 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.
+ * near-black. So the fill follows the resolved mode, and these tests pin both
+ * that behaviour and the dark default that applies before resolution.
  */
 
 interface SpanLike {
@@ -94,10 +93,10 @@ describe("fill distinguishes lit from unlit", () => {
 		]);
 	});
 
-	test("an undetected terminal still gets a visible fill, never nothing", () => {
+	test("before resolution the fill is the dark pair", () => {
 		resetThemeMode();
 		const el = ScopeSquares({ user: false, project: false, local: false });
-		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FALLBACK]));
+		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
 	});
 });