claudeup 6.5.1 → 6.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "6.5.1",
+  "version": "6.7.1",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "6.5.1",
-    "claudeup-darwin-x64": "6.5.1",
-    "claudeup-linux-x64": "6.5.1"
+    "claudeup-darwin-arm64": "6.7.1",
+    "claudeup-darwin-x64": "6.7.1",
+    "claudeup-linux-x64": "6.7.1"
   }
 }

package/src/__tests__/active-closure.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from "bun:test";
+import {
+	type ActiveClosureDeps,
+	loadActiveClosure,
+	selectProfileId,
+} from "../services/active-closure.js";
+import { resolveProfile } from "../services/resolver.js";
+import type {
+	BinRequirement,
+	ProfileManifest,
+	ResolvedClosure,
+} from "../types/index.js";
+
+/**
+ * The CLI and the TUI choose a profile through ONE function. They used to
+ * differ — the CLI inline, the TUI not at all — so an exact pin could never
+ * produce the same state in both.
+ *
+ * Every IO edge is injected; nothing here reads the real manifest, the real
+ * active-profile symlink, or any plugin.json.
+ */
+
+const PROJECT = "/tmp/no-such-project";
+
+function manifest(
+	profiles: ProfileManifest["profiles"],
+	over: Partial<ProfileManifest> = {},
+): ProfileManifest {
+	return { version: 2, profiles, ...over };
+}
+
+const ONE = manifest({
+	default: {
+		name: "default",
+		plugins: { "dev@magus": "latest", "terminal@magus": "5.0.1" },
+		cliTools: { claudish: "latest" },
+	},
+} as ProfileManifest["profiles"]);
+
+const TWO = manifest({
+	frontend: { name: "frontend", plugins: { "dev@magus": "latest" } },
+	backend: { name: "backend", plugins: { "terminal@magus": "latest" } },
+} as ProfileManifest["profiles"]);
+
+/** A plugin.json resolver that fails the test if the screen reads one. */
+const MUST_NOT_READ = async (pluginId: string): Promise<BinRequirement[]> => {
+	throw new Error(`read plugin.json for ${pluginId}`);
+};
+
+describe("selectProfileId", () => {
+	const ids = ["frontend", "backend"];
+
+	test.each([
+		// [explicit, active, expected]
+		["frontend", "backend", "frontend"], // explicit wins
+		[undefined, "backend", "backend"], // then the active one
+		[undefined, null, null], // two profiles, no choice: ambiguous
+		["missing", "backend", "backend"], // unknown explicit is ignored
+		[undefined, "stale", null], // stale active, two profiles: ambiguous
+	] as const)("explicit=%p active=%p → %p", (explicit, active, expected) => {
+		expect(selectProfileId(ids, explicit, active)).toBe(expected);
+	});
+
+	test("a single profile needs no activation", () => {
+		expect(selectProfileId(["default"], undefined, null)).toBe("default");
+	});
+
+	test("a stale active symlink with a single profile picks the single one", () => {
+		// The profile the symlink names was removed from the manifest. The CLI
+		// used to pick the stale name and then fail to resolve it.
+		expect(selectProfileId(["default"], undefined, "removed")).toBe("default");
+	});
+
+	test("no profiles at all selects nothing", () => {
+		expect(selectProfileId([], undefined, null)).toBeNull();
+		expect(selectProfileId([], "x", "y")).toBeNull();
+	});
+});
+
+/** Deps over a fixed manifest and active name, recording every resolve call. */
+function fakeDeps(m: ProfileManifest, active: string | null) {
+	const calls: Array<{
+		id: string;
+		binResolver?: (id: string) => Promise<BinRequirement[]>;
+	}> = [];
+	const deps: Partial<ActiveClosureDeps> = {
+		readManifest: async () => m,
+		activeProfile: async () => active,
+		resolveProfile: async (manifest, id, opts) => {
+			calls.push({ id, binResolver: opts?.binResolver });
+			// The real resolver, but never the real plugin.json reader: when the
+			// caller passed none, a reader that throws stands in for the default.
+			return resolveProfile(manifest, id, {
+				binResolver: opts?.binResolver ?? MUST_NOT_READ,
+			});
+		},
+	};
+	return { deps, calls };
+}
+
+describe("loadActiveClosure", () => {
+	test("resolves the active profile's closure", async () => {
+		const { deps } = fakeDeps(TWO, "backend");
+		const got = await loadActiveClosure(PROJECT, { resolveBins: false, deps });
+		expect(got?.profileId).toBe("backend");
+		expect(got?.closure.plugins).toEqual({ "terminal@magus": "latest" });
+	});
+
+	test("passes the manifest's pins through exactly", async () => {
+		const { deps } = fakeDeps(ONE, null);
+		const got = await loadActiveClosure(PROJECT, { resolveBins: false, deps });
+		expect(got?.closure.plugins).toEqual({
+			"dev@magus": "latest",
+			"terminal@magus": "5.0.1",
+		});
+	});
+
+	test("an invalid manifest is null, not a throw", async () => {
+		const { deps, calls } = fakeDeps(
+			{ version: 1, profiles: {} } as unknown as ProfileManifest,
+			null,
+		);
+		expect(await loadActiveClosure(PROJECT, { deps })).toBeNull();
+		expect(calls).toEqual([]);
+	});
+
+	test("no manifest (readManifest's empty v2) is null", async () => {
+		const { deps } = fakeDeps(manifest({}), null);
+		expect(await loadActiveClosure(PROJECT, { deps })).toBeNull();
+	});
+
+	test("two profiles and none active is null — there is no choice to make", async () => {
+		const { deps, calls } = fakeDeps(TWO, null);
+		expect(await loadActiveClosure(PROJECT, { deps })).toBeNull();
+		expect(calls).toEqual([]);
+	});
+
+	test("a stale active symlink with a single profile resolves the single one", async () => {
+		const { deps } = fakeDeps(ONE, "removed-profile");
+		const got = await loadActiveClosure(PROJECT, { resolveBins: false, deps });
+		expect(got?.profileId).toBe("default");
+	});
+
+	test("resolveBins:false hands resolveProfile a resolver that returns []", async () => {
+		// The Plugins screen needs only pins. The default resolver reads every
+		// declared plugin's plugin.json on each fetch.
+		const { deps, calls } = fakeDeps(ONE, null);
+		const got = await loadActiveClosure(PROJECT, { resolveBins: false, deps });
+		expect(calls).toHaveLength(1);
+		const resolver = calls[0]?.binResolver;
+		expect(resolver).toBeDefined();
+		expect(await resolver?.("dev@magus")).toEqual([]);
+		// No plugin-declared bins; the profile's own cliTools still resolve.
+		expect(got?.closure.bins.map((b) => b.name)).toEqual(["claudish"]);
+	});
+
+	test("resolveBins defaults to true: the real plugin.json resolver is used", async () => {
+		const { deps, calls } = fakeDeps(ONE, null);
+		// MUST_NOT_READ stands in for the default reader, so the default path
+		// shows up as a rejected resolve — which loadActiveClosure reports as null.
+		expect(await loadActiveClosure(PROJECT, { deps })).toBeNull();
+		expect(calls).toHaveLength(1);
+		expect(calls[0]?.binResolver).toBeUndefined();
+	});
+
+	test("any failing edge is null, never a throw", async () => {
+		const boom = async (): Promise<never> => {
+			throw new Error("boom");
+		};
+		for (const deps of [
+			{ readManifest: boom },
+			{ readManifest: async () => ONE, activeProfile: boom },
+			{
+				readManifest: async () => ONE,
+				activeProfile: async () => null,
+				resolveProfile: boom as unknown as (
+					...args: unknown[]
+				) => Promise<ResolvedClosure>,
+			},
+		]) {
+			expect(await loadActiveClosure(PROJECT, { deps })).toBeNull();
+		}
+	});
+});

package/src/__tests__/blackbox-active-closure.test.ts

@@ -0,0 +1,119 @@
+/**
+ * BLACK-BOX: the one profile choice both front ends resolve through (R2
+ * precondition: "for the same project and profile"). §8.4 contracts only;
+ * IO injected through `loadActiveClosure`'s deps.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type ActiveClosureDeps,
+	loadActiveClosure,
+	selectProfileId,
+} from "../services/active-closure.js";
+import type {
+	BinRequirement,
+	ProfileManifest,
+	ResolvedClosure,
+} from "../types/index.js";
+
+describe("selectProfileId: explicit ?? active ?? the only id ?? null", () => {
+	test.each([
+		{ ids: ["a", "b"], explicit: "b", active: "a", want: "b" },
+		{ ids: ["a", "b"], explicit: "zz", active: "a", want: "a" },
+		{ ids: ["a", "b"], explicit: undefined, active: "b", want: "b" },
+		{ ids: ["a", "b"], explicit: undefined, active: "zz", want: null },
+		{ ids: ["only"], explicit: undefined, active: null, want: "only" },
+		{ ids: ["only"], explicit: "zz", active: "yy", want: "only" },
+		{ ids: ["a", "b"], explicit: undefined, active: null, want: null },
+		{ ids: [], explicit: "a", active: "a", want: null },
+	])(
+		"ids=$ids explicit=$explicit active=$active → $want",
+		({ ids, explicit, active, want }) => {
+			expect(selectProfileId(ids, explicit, active)).toBe(want);
+		},
+	);
+});
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			default: { name: "Default", plugins: { "dev@magus": "latest" } },
+			other: { name: "Other", plugins: { "setup@magus": "latest" } },
+		},
+	};
+}
+
+function closureFor(id: string): ResolvedClosure {
+	return {
+		marketplaces: {},
+		plugins: { [`${id}-plugin@magus`]: "latest" },
+		mcpServers: {},
+		bins: [],
+		skills: [],
+		settings: {},
+		env: { required: [], optional: [] },
+	};
+}
+
+describe("loadActiveClosure", () => {
+	test("resolves the active profile through the injected deps", async () => {
+		const resolved: string[] = [];
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => "other",
+			resolveProfile: async (_m, id) => {
+				resolved.push(id);
+				return closureFor(id);
+			},
+		};
+
+		const got = await loadActiveClosure("/proj", { deps });
+
+		expect(got?.profileId).toBe("other");
+		// selectProfileId returns `string | null`; widen the matcher's type so the
+		// comparison type-checks. Runtime assertion unchanged.
+		expect<string | null | undefined>(got?.profileId).toBe(
+			selectProfileId(["default", "other"], undefined, "other"),
+		);
+		expect(got?.closure.plugins).toEqual({ "other-plugin@magus": "latest" });
+		expect(resolved).toEqual(["other"]);
+	});
+
+	test("resolveBins: false hands resolveProfile a bin resolver that yields nothing", async () => {
+		let resolver: ((pluginId: string) => Promise<BinRequirement[]>) | undefined;
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => "default",
+			resolveProfile: async (_m, id, opts) => {
+				resolver = opts?.binResolver;
+				return closureFor(id);
+			},
+		};
+
+		await loadActiveClosure("/proj", { resolveBins: false, deps });
+
+		expect(resolver).toBeDefined();
+		expect(await resolver?.("terminal@magus")).toEqual([]);
+	});
+
+	test("an unreadable manifest yields null and never throws", async () => {
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => {
+				throw new Error("ENOENT profiles.json");
+			},
+			activeProfile: async () => "default",
+		};
+
+		expect(await loadActiveClosure("/proj", { deps })).toBeNull();
+	});
+
+	test("no selectable profile (two profiles, none active) yields null", async () => {
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => null,
+			resolveProfile: async (_m, id) => closureFor(id),
+		};
+
+		expect(await loadActiveClosure("/proj", { deps })).toBeNull();
+	});
+});

package/src/__tests__/blackbox-convergence.test.ts

@@ -0,0 +1,334 @@
+/**
+ * BLACK-BOX: R6 — convergence. A no-op installer run (brew "already installed",
+ * uv reinstalling the same version) is never counted as changed, unknown tools
+ * are never applied, and a second plan after a successful apply has no work
+ * for what the first run changed. Written from requirements.md and §8.2/§8.5/§8.8.
+ *
+ * IO is injected through the contracts' seams: applyBins(run, probe),
+ * applyPlugins(deps), applyPlan({ run, probe, deps }). No mock.module.
+ */
+import { describe, expect, test } from "bun:test";
+import { summaryLine } from "../cli/update-view.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import type { ToolFacts } from "../services/tool-probe.js";
+import {
+	type PluginApplyDeps,
+	SILENT_REPORTER,
+	applyBins,
+	applyPlan,
+	applyPlugins,
+	planWorkItems,
+} from "../services/update-engine.js";
+import {
+	type UpdatePlan,
+	classifyPlugin,
+	indexCatalog,
+	planBinUpdates,
+	planHasWork,
+} from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+import type { Command } from "../utils/command-utils.js";
+
+function facts(name: string, over: Partial<ToolFacts> = {}): ToolFacts {
+	return {
+		name,
+		present: true,
+		resolvedPath: `/usr/local/bin/${name}`,
+		installed: "1.0.0",
+		latest: null,
+		behind: null,
+		managed: true,
+		sources: ["path"],
+		...over,
+	};
+}
+
+const SPECS: Record<string, ResolvedBin> = {
+	codex: {
+		name: "codex",
+		via: "npm",
+		package: "@openai/codex",
+		sources: ["profile"],
+	},
+	mnemex: {
+		name: "mnemex",
+		via: "bun",
+		version: "1.0.0",
+		sources: ["profile"],
+	},
+	tmux: {
+		name: "tmux",
+		via: "brew",
+		check: "tmux -V",
+		sources: ["terminal@magus"],
+	},
+	gemini: {
+		name: "gemini",
+		via: "npm",
+		package: "@google/gemini-cli",
+		sources: ["profile"],
+	},
+};
+
+function toolPlan(names: string[], before: ToolFacts[]): UpdatePlan {
+	const bins = names.map((n) => SPECS[n] as ResolvedBin);
+	return {
+		profileId: "default",
+		plugins: [],
+		bins: planBinUpdates(bins, before),
+		skills: [],
+		binSpecs: new Map(bins.map((b) => [b.name, b])),
+	};
+}
+
+function recorder(ok = true) {
+	const ran: Command[] = [];
+	return {
+		ran,
+		run: async (c: Command) => {
+			ran.push(c);
+			return ok;
+		},
+	};
+}
+
+function probeFrom(after: Record<string, ToolFacts>) {
+	return async (spec: ResolvedBin) =>
+		after[spec.name] ?? facts(spec.name, { installed: null });
+}
+
+const CODEX_BEHIND = facts("codex", { installed: "0.40.0", latest: "0.41.0" });
+
+describe("applyBins read-back (R6)", () => {
+	test("installer exits 0 but nothing moved (brew 'already installed'): unchanged, not changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder();
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: CODEX_BEHIND }),
+		);
+
+		expect(plan.bins[0]?.action).toBe("upgrade");
+		expect(r.ran.length).toBe(1);
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 0,
+			unchanged: ["codex"],
+			failed: [],
+		});
+	});
+
+	test("installer exits 0 and read-back shows the new version: changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder();
+		const after = facts("codex", { installed: "0.41.0", latest: "0.41.0" });
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: after }),
+		);
+
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 1,
+			unchanged: [],
+			failed: [],
+		});
+	});
+
+	test("current and unknown tools are never run and never counted", async () => {
+		const plan = toolPlan(
+			["tmux", "gemini"],
+			[
+				facts("tmux", { installed: "3.7c", behind: false }),
+				facts("gemini", { installed: "0.5.0", failure: "timed out after 8s" }),
+			],
+		);
+		const r = recorder();
+
+		const res = await applyBins(plan, SILENT_REPORTER, r.run, probeFrom({}));
+
+		expect(plan.bins.map((b) => b.action)).toEqual(["current", "unknown"]);
+		expect(planWorkItems(plan)).toEqual([]);
+		expect(r.ran).toEqual([]);
+		expect({
+			ok: res.ok,
+			unchanged: res.unchanged,
+			failed: res.failed,
+		}).toEqual({
+			ok: 0,
+			unchanged: [],
+			failed: [],
+		});
+	});
+
+	test("installer exits non-zero: failed, not changed", async () => {
+		const plan = toolPlan(["codex"], [CODEX_BEHIND]);
+		const r = recorder(false);
+
+		const res = await applyBins(
+			plan,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ codex: CODEX_BEHIND }),
+		);
+
+		expect(res.ok).toBe(0);
+		expect(res.failed).toContain("codex");
+	});
+
+	test("after an upgrade to the pin, the next plan has no tool work", async () => {
+		const before = facts("mnemex", { installed: "0.9.0", latest: "1.2.0" });
+		const after = facts("mnemex", { installed: "1.0.0", latest: "1.2.0" });
+		const plan1 = toolPlan(["mnemex"], [before]);
+		const r = recorder();
+
+		const res = await applyBins(
+			plan1,
+			SILENT_REPORTER,
+			r.run,
+			probeFrom({ mnemex: after }),
+		);
+		const plan2 = toolPlan(["mnemex"], [after]);
+
+		expect(plan1.bins[0]?.action).toBe("upgrade");
+		expect(res.ok).toBe(1);
+		expect(plan2.bins[0]?.action).toBe("current");
+		expect(planWorkItems(plan2)).toEqual([]);
+		expect(planHasWork(plan2)).toBe(false);
+	});
+});
+
+// ── plugins ────────────────────────────────────────────────────────────────
+
+function designer(installed: string): PluginInfo {
+	return {
+		id: "designer@magus",
+		name: "designer",
+		version: "2.0.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "magus",
+		enabled: true,
+		installedVersion: installed,
+		projectScope: { enabled: true, version: installed },
+	};
+}
+
+function pluginDeps(readBack: string | null) {
+	const calls: string[] = [];
+	const deps: PluginApplyDeps = {
+		install: async (id, scope) => {
+			calls.push(`install ${id} ${scope}`);
+		},
+		update: async (id, scope) => {
+			calls.push(`update ${id} ${scope}`);
+		},
+		repair: async (id, scope) => {
+			calls.push(`repair ${id} ${scope}`);
+		},
+		readInstalled: async () => readBack,
+		saveInstalled: async () => {},
+	};
+	return { calls, deps };
+}
+
+describe("applyPlugins read-back (R6)", () => {
+	test("update exits 0 but the registry still shows the before-version: unchanged, not changed", async () => {
+		const item = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("1.5.0")]),
+		);
+		const { calls, deps } = pluginDeps("1.5.0");
+
+		const res = await applyPlugins([item], "/proj", deps, SILENT_REPORTER);
+
+		expect(item.action).toBe("update");
+		expect(calls.length).toBeGreaterThan(0);
+		expect({ ok: res.ok, unchanged: res.unchanged }).toEqual({
+			ok: 0,
+			unchanged: ["designer@magus"],
+		});
+		expect(res.failed).toEqual([]);
+	});
+
+	test("update moves the registry to the target: changed, and the next classification is current", async () => {
+		const item = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("1.5.0")]),
+		);
+		const { deps } = pluginDeps("2.0.0");
+
+		const res = await applyPlugins([item], "/proj", deps, SILENT_REPORTER);
+		const next = classifyPlugin(
+			"designer@magus",
+			"latest",
+			indexCatalog([designer("2.0.0")]),
+		);
+
+		expect({ ok: res.ok, unchanged: res.unchanged }).toEqual({
+			ok: 1,
+			unchanged: [],
+		});
+		expect(next.action).toBe("current");
+	});
+});
+
+describe("applyPlan totals (R6)", () => {
+	test("changed counts only real movement; the no-op is listed as unchanged", async () => {
+		const plan = toolPlan(
+			["codex", "mnemex", "tmux"],
+			[
+				CODEX_BEHIND,
+				facts("mnemex", { installed: "0.9.0", latest: "1.2.0" }),
+				facts("tmux", { installed: "3.7c", behind: false }),
+			],
+		);
+		const r = recorder();
+		const { deps } = pluginDeps(null);
+
+		const out = await applyPlan(plan, "/proj", {
+			deps,
+			report: SILENT_REPORTER,
+			run: r.run,
+			probe: probeFrom({
+				codex: CODEX_BEHIND,
+				mnemex: facts("mnemex", { installed: "1.0.0", latest: "1.2.0" }),
+			}),
+		});
+
+		expect(r.ran.length).toBe(2); // tmux is current: never run
+		expect({
+			changed: out.changed,
+			unchanged: out.unchanged,
+			failed: out.failed,
+		}).toEqual({
+			changed: 1,
+			unchanged: ["codex"],
+			failed: [],
+		});
+	});
+});
+
+describe("summaryLine never reports a no-op as changed", () => {
+	test("three no-op runs do not read as '3 changed', and the unchanged count is visible", () => {
+		const withUnchanged = summaryLine(0, 5, 1, 0, 1200, 3).join("\n");
+		const without = summaryLine(0, 5, 1, 0, 1200, 0).join("\n");
+
+		expect(withUnchanged).not.toMatch(/\b3 changed\b/);
+		expect(withUnchanged).not.toBe(without);
+	});
+});