magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/update-apply.test.ts

@@ -0,0 +1,637 @@
+/**
+ * Regression tests for the `magus update` APPLY path.
+ *
+ * Every defect a multi-model review found in this feature lived here, in the
+ * half that had no coverage, while the pure planner beside it had forty tests.
+ * These lock the apply path's contract so that gap cannot silently reopen.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { PluginScope } from "../services/claude-cli.js";
+import type { ToolFacts } from "../services/tool-probe.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyBins,
+	applyPlan,
+	applyPlugins,
+	installPluginInScope,
+	updatePluginInScope,
+} from "../services/update-engine.js";
+import type {
+	BinUpdateItem,
+	PluginUpdateItem,
+	UpdatePlan,
+} from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+import { noMoveReasons } from "../ui/adapters/pluginsAdapter.js";
+
+const PROJECT = "/tmp/project";
+
+/** Records every call, and lets a test dictate what the registry reads back. */
+function stubDeps(
+	installedAfter: string | null | ((scope: PluginScope) => string | null),
+) {
+	const saved: Array<{ id: string; version: string; scope: PluginScope }> = [];
+	const installed: Array<{ id: string; scope: PluginScope }> = [];
+	const updated: Array<{ id: string; scope: PluginScope }> = [];
+	const repaired: Array<{ id: string; scope: PluginScope }> = [];
+
+	const deps: PluginApplyDeps = {
+		install: mock(async (id: string, scope: PluginScope) => {
+			installed.push({ id, scope });
+		}),
+		update: mock(async (id: string, scope: PluginScope) => {
+			updated.push({ id, scope });
+		}),
+		repair: mock(async (id: string, scope: PluginScope) => {
+			repaired.push({ id, scope });
+		}),
+		readInstalled: mock(async (_id: string, scope: PluginScope) =>
+			typeof installedAfter === "function"
+				? installedAfter(scope)
+				: installedAfter,
+		),
+		saveInstalled: mock(
+			async (id: string, version: string, scope: PluginScope) => {
+				saved.push({ id, version, scope });
+			},
+		),
+	};
+	return { deps, saved, installed, updated, repaired };
+}
+
+function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
+	return {
+		pluginId: "dev@magus",
+		pinned: "latest",
+		installed: "1.0.0",
+		available: "2.0.0",
+		target: "2.0.0",
+		action: "update",
+		reason: "behind",
+		scopes: ["project"],
+		beforeVersions: { project: "1.0.0" },
+		...over,
+	};
+}
+
+let logs: string[];
+beforeEach(() => {
+	logs = [];
+	console.log = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
+	console.warn = ((...a: unknown[]) => logs.push(a.join(" "))) as any;
+});
+
+describe("what gets RECORDED is what got installed", () => {
+	test("records the version read back, not the version we asked for", async () => {
+		// `claude plugin install` accepts no version — it installs the newest.
+		// Recording `target` instead of the read-back made the registry claim a
+		// version that was never on disk.
+		const { deps, saved } = stubDeps("9.9.9");
+		await applyPlugins([item({ target: "2.0.0" })], PROJECT, deps);
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "project" },
+		]);
+	});
+
+	test("an exact pin the installer could not honour is reported, not hidden", async () => {
+		const { deps, saved } = stubDeps("9.9.9");
+		const result = await applyPlugins(
+			[item({ pinned: "4.6.1", target: "4.6.1" })],
+			PROJECT,
+			deps,
+		);
+		// The pin is NOT written as if satisfied...
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "project" },
+		]);
+		// ...and the shortfall is surfaced to the caller.
+		expect(result.mismatches).toEqual([
+			{
+				pluginId: "dev@magus",
+				pinned: "4.6.1",
+				actual: "9.9.9",
+				scope: "project",
+			},
+		]);
+	});
+
+	test("a satisfied exact pin produces no mismatch", async () => {
+		const { deps } = stubDeps("4.6.1");
+		const result = await applyPlugins(
+			[item({ pinned: "4.6.1", target: "4.6.1" })],
+			PROJECT,
+			deps,
+		);
+		expect(result.mismatches).toEqual([]);
+	});
+
+	test("a 'latest' pin never counts as a mismatch", async () => {
+		const { deps } = stubDeps("9.9.9");
+		const result = await applyPlugins(
+			[item({ pinned: "latest", target: "2.0.0" })],
+			PROJECT,
+			deps,
+		);
+		expect(result.mismatches).toEqual([]);
+	});
+
+	test("nothing is recorded when the registry has no version to read back", async () => {
+		// Writing a guess here would be the same fabrication in another costume.
+		const { deps, saved } = stubDeps(null);
+		await applyPlugins([item({})], PROJECT, deps);
+		expect(saved).toEqual([]);
+	});
+});
+
+describe("scope handling", () => {
+	test("a fresh install goes to project scope only", async () => {
+		const { deps, installed } = stubDeps("2.0.0");
+		await applyPlugins(
+			[item({ action: "install", installed: null, scopes: [] })],
+			PROJECT,
+			deps,
+		);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+	});
+
+	// Three actions, three Claude Code commands, each a silent no-op in the
+	// other two cases. Folding `install` and `update` together is what made
+	// every magus update path exit 0 having changed nothing: measured on
+	// Claude Code 2.1.252, `claude plugin install designer@magus --scope
+	// project` answers "already installed" and leaves 0.6.0 in place while
+	// 0.6.1 is published, and `claude plugin update` is the command that moves
+	// it. The reverse holds too — `update` on a plugin absent from the scope
+	// answers "already at the latest version" and installs nothing — so this
+	// asserts BOTH directions, not just the one that was broken.
+
+	test("an update runs `update`, never `install`", async () => {
+		const { deps, installed, updated } = stubDeps("2.0.0");
+		await applyPlugins([item({ action: "update" })], PROJECT, deps);
+		expect(updated).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(installed).toEqual([]);
+	});
+
+	test("an update with NO row for this project installs instead", async () => {
+		// `claude plugin update --scope project` resolves the project from the
+		// working directory, and with no row there it updates some OTHER
+		// project's row instead. Measured on 2.1.252 from a directory holding no
+		// madbench row, it moved /Users/jack/mag/tmux-mcp — a project nobody
+		// named. Live for git worktrees, which inherit the parent repo's version
+		// while owning no row of their own.
+		const { deps, installed, updated } = stubDeps(null);
+		await applyPlugins([item({ action: "update" })], PROJECT, deps);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+
+	test("the row check is per scope, not per plugin", async () => {
+		// user scope holds a row, project scope does not: one must update and
+		// the other install, in the same pass.
+		const { deps, installed, updated } = stubDeps((scope) =>
+			scope === "user" ? "1.5.0" : null,
+		);
+		await applyPlugins([item({ scopes: ["user", "project"] })], PROJECT, deps);
+		expect(updated).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+	});
+
+	test("a fresh install runs `install`, never `update`", async () => {
+		const { deps, installed, updated } = stubDeps("2.0.0");
+		await applyPlugins(
+			[item({ action: "install", installed: null, scopes: [] })],
+			PROJECT,
+			deps,
+		);
+		expect(installed).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+
+	test("a repair runs neither — content drift needs uninstall+install", async () => {
+		const { deps, installed, updated, repaired } = stubDeps("1.0.0");
+		await applyPlugins(
+			[item({ action: "repair", target: "1.0.0", scopes: ["project"] })],
+			PROJECT,
+			deps,
+		);
+		expect(repaired).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(installed).toEqual([]);
+		expect(updated).toEqual([]);
+	});
+
+	test("every outdated scope is updated AND recorded separately", async () => {
+		const { deps, updated, saved } = stubDeps((scope) =>
+			scope === "user" ? "2.0.0" : "1.5.0",
+		);
+		await applyPlugins([item({ scopes: ["user", "project"] })], PROJECT, deps);
+		expect(updated).toEqual([
+			{ id: "dev@magus", scope: "user" },
+			{ id: "dev@magus", scope: "project" },
+		]);
+		// Each scope records ITS OWN read-back, never one shared value.
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "2.0.0", scope: "user" },
+			{ id: "dev@magus", version: "1.5.0", scope: "project" },
+		]);
+	});
+
+	test("a repair uses repairPlugin, not a plain install", async () => {
+		// A content-stale plugin has no version bump, so `install` is a no-op that
+		// reports success — only uninstall+install refreshes the files.
+		const { deps, repaired, updated } = stubDeps("1.0.0");
+		await applyPlugins([item({ action: "repair" })], PROJECT, deps);
+		expect(repaired).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(updated).toEqual([]);
+	});
+});
+
+describe("what is skipped", () => {
+	test("'current' and 'unknown' items are never touched", async () => {
+		const { deps, updated, saved } = stubDeps("1.0.0");
+		await applyPlugins(
+			[
+				item({ action: "current", scopes: [] }),
+				item({ pluginId: "b@magus", action: "unknown", scopes: [] }),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(updated).toEqual([]);
+		expect(saved).toEqual([]);
+	});
+
+	test("an 'unknown' plugin is not installed on a guess", async () => {
+		// It is unknown because the catalog could not be reached. Acting on that
+		// would be picking a version at random.
+		const { deps, updated } = stubDeps("1.0.0");
+		await applyPlugins(
+			[item({ action: "unknown", target: null, scopes: ["project"] })],
+			PROJECT,
+			deps,
+		);
+		expect(updated).toEqual([]);
+	});
+});
+
+describe("failure handling", () => {
+	test("a failing plugin is reported, and the rest still run", async () => {
+		const { deps, updated } = stubDeps("2.0.0");
+		deps.update = mock(async (id: string, scope: PluginScope) => {
+			if (id === "bad@magus") throw new Error("network down");
+			updated.push({ id, scope });
+		});
+
+		const result = await applyPlugins(
+			[item({ pluginId: "bad@magus" }), item({ pluginId: "good@magus" })],
+			PROJECT,
+			deps,
+		);
+
+		expect(result.failed).toEqual(["bad@magus"]);
+		expect(result.ok).toBe(1);
+		expect(updated).toEqual([{ id: "good@magus", scope: "project" }]);
+	});
+
+	test("a scope that threw records nothing for that plugin", async () => {
+		// Half-applied state must not be recorded as if it succeeded.
+		const { deps, saved } = stubDeps("2.0.0");
+		deps.update = mock(async () => {
+			throw new Error("boom");
+		});
+		const result = await applyPlugins([item({})], PROJECT, deps);
+		expect(saved).toEqual([]);
+		expect(result.ok).toBe(0);
+	});
+});
+
+describe("installPluginInScope — a fresh install records what landed", () => {
+	// The TUI's install branches called the CLI directly and then wrote the
+	// version they had ASKED for. A marketplace serves whatever it publishes at
+	// the moment of the call, so that number was a guess — and `install --check`
+	// reads back the same field, so it compared the guess against a copy of
+	// itself and reported clean forever. Routing installs through the read-back
+	// the update branches already used is what closes it.
+	//
+	// The read-back semantics are pinned in cli-apply-seams.test.ts
+	// ("installPluginInScope — the scope-targeted path"). What these add is the
+	// property that makes the whole class of bug unrepresentable rather than
+	// merely absent right now.
+
+	test("takes no version parameter, so a caller cannot supply a wrong one", () => {
+		// Arity, not behaviour — and that is the point. Re-adding a `version`
+		// argument would reopen the defect without failing any behavioural test,
+		// because the new parameter would simply be believed.
+		// (pluginId, scope, projectPath, deps = REAL_PLUGIN_DEPS) — the defaulted
+		// parameter is not counted by Function.length.
+		expect(installPluginInScope.length).toBe(3);
+	});
+
+	test("saves the version read back, not one the caller chose", async () => {
+		const { deps, saved } = stubDeps("9.9.9");
+		await installPluginInScope("dev@magus", "user", PROJECT, deps);
+		expect(saved).toEqual([
+			{ id: "dev@magus", version: "9.9.9", scope: "user" },
+		]);
+	});
+
+	test("an unreadable version writes nothing at all", async () => {
+		// Never guess. A missing record is recoverable; a wrong one is not,
+		// because nothing downstream can tell it from a true one.
+		const { deps, saved } = stubDeps(null);
+		expect(
+			await installPluginInScope("dev@magus", "user", PROJECT, deps),
+		).toBeNull();
+		expect(saved).toEqual([]);
+	});
+
+	// The scope menu's update branch went through the install helper for as
+	// long as both issued `claude plugin install`. They no longer do, so the
+	// two helpers must reach different commands or the menu silently no-ops
+	// exactly the way "update all" did.
+	test("the install helper runs `install`, the update helper runs `update`", async () => {
+		const a = stubDeps("2.0.0");
+		await installPluginInScope("dev@magus", "user", PROJECT, a.deps);
+		expect(a.installed).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(a.updated).toEqual([]);
+
+		const b = stubDeps("2.0.0");
+		await updatePluginInScope("dev@magus", "user", PROJECT, b.deps);
+		expect(b.updated).toEqual([{ id: "dev@magus", scope: "user" }]);
+		expect(b.installed).toEqual([]);
+	});
+
+	test("the update helper takes no version parameter either", () => {
+		expect(updatePluginInScope.length).toBe(3);
+	});
+});
+
+// ── R6: an installer that exits 0 and changes nothing is never "changed" ────
+//
+// Planning (R4) refuses the upgrades it cannot justify, but it cannot see the
+// no-ops that only appear after an installer runs: a stale brew tap, a PATH
+// that still resolves an older copy, `~/.bun/bin` missing from PATH, a
+// marketplace clone lagging its catalog. Each exits 0 and is replanned
+// identically next run. Read-back — re-probing the one tool, or re-reading the
+// registry row — is what tells them apart. No installer output is parsed.
+
+const bin = (over: Partial<BinUpdateItem> = {}): BinUpdateItem => ({
+	name: "tmux",
+	action: "upgrade",
+	reason: "behind",
+	installed: "1.2.2",
+	latest: "1.2.3",
+	target: "1.2.3",
+	sources: [],
+	...over,
+});
+
+const readBack = (over: Partial<ToolFacts> = {}): ToolFacts => ({
+	name: "tmux",
+	present: true,
+	resolvedPath: "/opt/homebrew/Cellar/tmux/1.2.3/bin/tmux",
+	installed: "1.2.3",
+	latest: null,
+	behind: false,
+	managed: true,
+	sources: [],
+	...over,
+});
+
+function binPlan(item: BinUpdateItem): UpdatePlan {
+	const spec: ResolvedBin = { name: item.name, via: "brew", sources: [] };
+	return {
+		profileId: "test",
+		plugins: [],
+		bins: [item],
+		skills: [],
+		binSpecs: new Map([[item.name, spec]]),
+	};
+}
+
+function recordingReporter() {
+	const rows: Array<{ ok: boolean; name: string; detail: string }> = [];
+	const reporter: ApplyReporter = {
+		begin: () => {},
+		finish: (ok, name, detail) => rows.push({ ok, name, detail }),
+		detach: (work) => work(),
+	};
+	return { reporter, rows };
+}
+
+const RUN_OK = async () => true;
+
+describe("applyBins — read-back", () => {
+	test("an upgrade that reads back the same version is UNCHANGED (v-prefix tolerant)", async () => {
+		const { reporter, rows } = recordingReporter();
+		const result = await applyBins(
+			binPlan(bin({ installed: "v1.2.3", target: "1.2.4" })),
+			reporter,
+			RUN_OK,
+			async () => readBack({ installed: "1.2.3" }),
+		);
+		expect(result).toEqual({ ok: 0, failed: [], unchanged: ["tmux"] });
+		// A finished row, not a failure, carrying the reason.
+		expect(rows).toEqual([
+			{
+				ok: true,
+				name: "tmux",
+				detail: "no change — the installer exited 0 but tmux is still 1.2.3",
+			},
+		]);
+	});
+
+	test("a read-back where PATH still runs another copy is UNCHANGED", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () =>
+				readBack({
+					installed: "1.2.3",
+					managed: false,
+					resolvedPath: "/usr/local/bin/tmux",
+				}),
+		);
+		expect(result.unchanged).toEqual(["tmux"]);
+		expect(result.ok).toBe(0);
+	});
+
+	test("an install that is still not on PATH is UNCHANGED", async () => {
+		const { reporter, rows } = recordingReporter();
+		const result = await applyBins(
+			binPlan(bin({ action: "install", installed: null, reason: "absent" })),
+			reporter,
+			RUN_OK,
+			async () => readBack({ present: false, installed: null, managed: null }),
+		);
+		expect(result.unchanged).toEqual(["tmux"]);
+		expect(rows[0]!.detail).toContain("still not on PATH");
+	});
+
+	test("a read-back that cannot read a version counts as CHANGED", async () => {
+		// Failing to read is not evidence nothing moved — otherwise every
+		// go-less machine's upgrade would turn into a warning.
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => readBack({ installed: null }),
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("a read-back that throws counts as CHANGED, never as a failure", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => {
+				throw new Error("probe blew up");
+			},
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("a real move is CHANGED", async () => {
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			RUN_OK,
+			async () => readBack({ installed: "1.2.3" }),
+		);
+		expect(result).toEqual({ ok: 1, failed: [], unchanged: [] });
+	});
+
+	test("an installer that fails is FAILED and is not read back", async () => {
+		const probe = mock(async () => readBack());
+		const result = await applyBins(
+			binPlan(bin()),
+			undefined,
+			async () => false,
+			probe,
+		);
+		expect(result).toEqual({ ok: 0, failed: ["tmux"], unchanged: [] });
+		expect(probe).not.toHaveBeenCalled();
+	});
+
+	test("applyPlan: changed excludes the unchanged, which it lists", async () => {
+		const outcome = await applyPlan(
+			binPlan(bin({ installed: "1.2.2" })),
+			PROJECT,
+			{ run: RUN_OK, probe: async () => readBack({ installed: "1.2.2" }) },
+		);
+		expect(outcome.changed).toBe(0);
+		expect(outcome.unchanged).toEqual(["tmux"]);
+		expect(outcome.failed).toEqual([]);
+	});
+});
+
+describe("applyPlugins — read-back against beforeVersions", () => {
+	test("an update whose every scope reads back its before-version is UNCHANGED", async () => {
+		// `claude plugin update` answering "already at the latest version" while
+		// the marketplace clone lags the catalog: exit 0, nothing moved.
+		const { deps } = stubDeps("1.0.0");
+		const { reporter, rows } = recordingReporter();
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "1.0.0" } })],
+			PROJECT,
+			deps,
+			reporter,
+		);
+		expect(result.ok).toBe(0);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(result.failed).toEqual([]);
+		expect(rows[0]).toMatchObject({ ok: true });
+		expect(rows[0]!.detail).toContain("still 1.0.0");
+	});
+
+	test("an update where ONE scope moved is CHANGED", async () => {
+		const { deps } = stubDeps((scope) =>
+			scope === "user" ? "2.0.0" : "1.0.0",
+		);
+		const result = await applyPlugins(
+			[
+				item({
+					scopes: ["user", "project"],
+					beforeVersions: { user: "1.0.0", project: "1.0.0" },
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+	});
+
+	test("an install that reads back nothing in any scope is UNCHANGED", async () => {
+		const { deps } = stubDeps(null);
+		const result = await applyPlugins(
+			[
+				item({
+					action: "install",
+					installed: null,
+					scopes: [],
+					beforeVersions: {},
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(result.ok).toBe(0);
+	});
+
+	test("an install that lands a version is CHANGED", async () => {
+		const { deps } = stubDeps("2.0.0");
+		const result = await applyPlugins(
+			[
+				item({
+					action: "install",
+					installed: null,
+					scopes: [],
+					beforeVersions: {},
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+	});
+
+	test("a repair is always CHANGED — same version is its definition", async () => {
+		const { deps } = stubDeps("1.0.0");
+		const result = await applyPlugins(
+			[
+				item({
+					action: "repair",
+					target: "1.0.0",
+					beforeVersions: { project: "1.0.0" },
+				}),
+			],
+			PROJECT,
+			deps,
+		);
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+	});
+
+	test("the TUI's collector names the same cause the CLI prints", async () => {
+		// The screen used to branch on `failed.length` alone: a no-op update
+		// closed with a success and a row that had not moved.
+		const { deps } = stubDeps("1.0.0");
+		const reasons = noMoveReasons();
+		const result = await applyPlugins(
+			[item({ beforeVersions: { project: "1.0.0" } })],
+			PROJECT,
+			deps,
+			reasons.reporter,
+		);
+		expect(result.unchanged).toEqual(["dev@magus"]);
+		expect(reasons.lines(result.unchanged)).toBe(
+			"dev@magus: the installer exited 0 but dev@magus is still 1.0.0",
+		);
+		// An item with no recorded cause still gets a line.
+		expect(reasons.lines(["other@magus"])).toBe("other@magus");
+	});
+});