magus-cli 7.1.0 → 7.3.0

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

@@ -8,6 +8,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { PluginScope } from "../services/claude-cli.js";
+import type { StaleLoadRepairResult } from "../services/claude-settings.js";
 import type { ToolFacts } from "../services/tool-probe.js";
 import {
 	type ApplyReporter,
@@ -16,6 +17,7 @@ import {
 	applyPlan,
 	applyPlugins,
 	installPluginInScope,
+	pluginNeedsWork,
 	updatePluginInScope,
 } from "../services/update-engine.js";
 import type {
@@ -31,13 +33,39 @@ 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),
+	/**
+	 * What the registry repair answers. Defaults to success at the target, which
+	 * is what every case that is not ABOUT the repair wants.
+	 */
+	staleLoadOutcome: (
+		pluginId: string,
+		target: string,
+	) => StaleLoadRepairResult = (pluginId, target) => ({
+		pluginId,
+		target,
+		rewritten: 1,
+		backup: "/tmp/installed_plugins.json.backup.1",
+		loaded: target,
+		ok: true,
+	}),
 ) {
 	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 rowsRepaired: Array<{
+		id: string;
+		target: string;
+		projectPath: string;
+	}> = [];
 
 	const deps: PluginApplyDeps = {
+		repairStaleLoad: mock(
+			async (pluginId: string, target: string, projectPath: string) => {
+				rowsRepaired.push({ id: pluginId, target, projectPath });
+				return staleLoadOutcome(pluginId, target);
+			},
+		),
 		install: mock(async (id: string, scope: PluginScope) => {
 			installed.push({ id, scope });
 		}),
@@ -58,7 +86,7 @@ function stubDeps(
 			},
 		),
 	};
-	return { deps, saved, installed, updated, repaired };
+	return { deps, saved, installed, updated, repaired, rowsRepaired };
 }
 
 function item(over: Partial<PluginUpdateItem>): PluginUpdateItem {
@@ -274,6 +302,123 @@ describe("what is skipped", () => {
 	});
 });
 
+/**
+ * A broken plugin — the loader resolves an older version than the one installed.
+ *
+ * It used to be SKIPPED here, on the argument that no installer could clear it.
+ * That is still true of every installer; what clears it is rewriting the registry
+ * rows, which `repairStaleLoad` does. These cases lock in that the engine reaches
+ * that repair and nothing else — a reinstall is measured not to fix this, so an
+ * `install`/`update`/`repair` call for one of these rows is a regression.
+ */
+describe("a stale load is APPLIED, by repairing the registry", () => {
+	const broken = (over: Partial<PluginUpdateItem> = {}) =>
+		item({
+			pluginId: "madbench@magus",
+			action: "stale-load",
+			reason: "older-version-loads",
+			installed: "0.5.0",
+			available: "0.5.0",
+			loaded: "0.3.0",
+			target: "0.5.0",
+			scopes: [],
+			beforeVersions: { project: "0.5.0" },
+			note: "loads v0.3.0, installed v0.5.0",
+			...over,
+		});
+
+	test("it is work, so a progress meter counts it", () => {
+		// `pluginNeedsWork` is the apply loop's own predicate and the meter's
+		// denominator. It cannot answer false here while the loop acts, or the bar
+		// finishes short of full and reads as a hang.
+		expect(pluginNeedsWork(broken())).toBe(true);
+	});
+
+	test("the repair runs, targeting the INSTALLED version", async () => {
+		const { deps, rowsRepaired } = stubDeps("0.5.0");
+		const result = await applyPlugins([broken()], PROJECT, deps);
+
+		expect(rowsRepaired).toEqual([
+			{ id: "madbench@magus", target: "0.5.0", projectPath: PROJECT },
+		]);
+		expect(result.ok).toBe(1);
+		expect(result.failed).toEqual([]);
+	});
+
+	test("no installer is invoked for it", async () => {
+		const { deps, installed, updated, repaired, saved } = stubDeps("0.5.0");
+		await applyPlugins([broken()], PROJECT, deps);
+
+		expect({ installed, updated, repaired, saved }).toEqual({
+			installed: [],
+			updated: [],
+			repaired: [],
+			saved: [],
+		});
+	});
+
+	test("a repair that did not change the resolution is a FAILURE", async () => {
+		// The repair's own post-write assertion says the loader still resolves the
+		// old version. Counting that as `ok` would report a fix for a plugin that is
+		// still broken — the precise deception this state exists to end.
+		const { deps } = stubDeps("0.5.0", (pluginId, target) => ({
+			pluginId,
+			target,
+			rewritten: 1,
+			backup: "/tmp/installed_plugins.json.backup.1",
+			loaded: "0.3.0",
+			ok: false,
+			error: "the loader still resolves v0.3.0 here, not v0.5.0",
+		}));
+
+		const result = await applyPlugins([broken()], PROJECT, deps);
+
+		expect(result.ok).toBe(0);
+		expect(result.failed).toEqual(["madbench@magus"]);
+		// And the reason reaches the reporter verbatim, not a generic message.
+		const seen: string[] = [];
+		const reporter: ApplyReporter = {
+			begin: () => {},
+			finish: (_ok, _name, detail) => seen.push(detail),
+			detach: (work) => work(),
+		};
+		await applyPlugins([broken()], PROJECT, deps, reporter);
+		expect(seen).toEqual(["the loader still resolves v0.3.0 here, not v0.5.0"]);
+	});
+
+	test("a throwing repair fails that plugin without stopping the run", async () => {
+		const { deps, updated } = stubDeps("2.0.0");
+		deps.repairStaleLoad = async () => {
+			throw new Error("registry is read-only");
+		};
+
+		const result = await applyPlugins(
+			[broken(), item({ pluginId: "dev@magus" })],
+			PROJECT,
+			deps,
+		);
+
+		expect(result.failed).toEqual(["madbench@magus"]);
+		// The ordinary update after it still ran.
+		expect(updated).toEqual([{ id: "dev@magus", scope: "project" }]);
+		expect(result.ok).toBe(1);
+	});
+
+	test("no target means no repair to run, and it is not silently skipped", async () => {
+		// `target` is the installed version; null means nothing is on disk to point
+		// the rows at. Reporting that is different from doing nothing quietly.
+		const { deps, rowsRepaired } = stubDeps("0.5.0");
+		const result = await applyPlugins(
+			[broken({ target: null, installed: null })],
+			PROJECT,
+			deps,
+		);
+
+		expect(rowsRepaired).toEqual([]);
+		expect(result.failed).toEqual(["madbench@magus"]);
+	});
+});
+
 describe("failure handling", () => {
 	test("a failing plugin is reported, and the rest still run", async () => {
 		const { deps, updated } = stubDeps("2.0.0");

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

@@ -1359,6 +1359,7 @@ describe("countPluginStates", () => {
 			update: 2,
 			repair: 1,
 			current: 0,
+			"stale-load": 0,
 			unknown: 1,
 		});
 	});
@@ -1394,3 +1395,340 @@ describe("scopeIsBehind — the scope picker's one question", () => {
 		expect(scopeIsBehind(undefined, "project")).toBe(false);
 	});
 });
+
+describe("classifyPlugin — an older version LOADS than the one installed", () => {
+	/**
+	 * The measured madbench case. 0.5.0 is installed in this project and is what
+	 * the marketplace offers, so every comparison the classifier used to make
+	 * said `current`. Claude Code loaded 0.3.0 out of a registry row belonging to
+	 * a worktree that no longer exists — see services/plugin-resolution.ts.
+	 *
+	 * What makes it worth its own state: the installed version is RIGHT. Nothing
+	 * in the version columns is wrong, so every report was green about a session
+	 * running two-versions-old code.
+	 */
+	const madbench = (over: Partial<PluginInfo> = {}) =>
+		info({
+			id: "madbench@magus",
+			version: "0.5.0",
+			installedVersion: "0.5.0",
+			loadedVersion: "0.3.0",
+			projectScope: { enabled: true, version: "0.5.0" },
+			...over,
+		});
+
+	test("beats `current`, and names both versions", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench()),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			reason: "older-version-loads",
+			installed: "0.5.0",
+			loaded: "0.3.0",
+			note: "loads v0.3.0, installed v0.5.0",
+		});
+	});
+
+	test("targets the INSTALLED version, with no scope, and IS planned as work", () => {
+		// It is applied by rewriting registry rows (`repairStaleLoad`), not by any
+		// installer — a reinstall is measured not to clear it. So there is no scope
+		// to enumerate, and `planWorkItems` has to name it anyway or the apply loop
+		// would skip the one action the row tells the user to press a key for.
+		//
+		// The target is what is INSTALLED here, never the catalog version: the
+		// repair points rows at a cache directory, and only the installed version's
+		// cache is on disk.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench()),
+		);
+
+		expect(item?.target).toBe("0.5.0");
+		expect(item?.scopes).toEqual([]);
+		expect(
+			planWorkItems(plan({ plugins: [item as PluginUpdateItem] })),
+		).toEqual(["madbench@magus"]);
+	});
+
+	test("the target is the installed version even when the catalog is ahead", () => {
+		// 0.4.0 installed, 0.5.0 published, 0.3.0 loading. Aiming at 0.5.0 would
+		// name a cache directory that does not exist; `repairStaleLoad` refuses
+		// those outright. The ordinary `update` to 0.5.0 is planned on the next run,
+		// once the load is no longer stale, so the two steps converge.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(
+				madbench({
+					installedVersion: "0.4.0",
+					projectScope: { enabled: true, version: "0.4.0" },
+				}),
+			),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			installed: "0.4.0",
+			available: "0.5.0",
+			target: "0.4.0",
+		});
+	});
+
+	test("it fails the --check gate now that applying it clears it", () => {
+		// It was excluded from `planIsBehind` while it was report-only, on the
+		// un-greenable-gate rule. `magus update` repairs it, so a gate that stays
+		// silent here would print "nothing behind" over a session running a version
+		// nobody installed.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench()),
+		);
+
+		expect(planIsBehind(plan({ plugins: [item as PluginUpdateItem] }))).toBe(
+			true,
+		);
+	});
+
+	test("beats `update` too — and says the update is still waiting", () => {
+		// Behind the catalog AND loading something older still. The update is the
+		// smaller problem and the loaded version is the fact that decides what
+		// this session actually runs — but the pending release is NOT swallowed:
+		// the note names it, because a user told only "loads v0.3.0, installed
+		// v0.4.0" has no way to know 0.5.0 is waiting behind the repair.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(
+				madbench({
+					installedVersion: "0.4.0",
+					projectScope: { enabled: true, version: "0.4.0" },
+				}),
+			),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			installed: "0.4.0",
+			available: "0.5.0",
+			target: "0.4.0",
+			note: "loads v0.3.0, installed v0.4.0; v0.5.0 is available once the load is repaired",
+		});
+	});
+
+	test("an ordinary PENDING RELEASE is an update, not a broken load", () => {
+		// THE defect this branch shipped with: it compared the CATALOG version
+		// against the loaded one, so installed 0.5.0 / loaded 0.5.0 / catalog 0.6.0
+		// — nothing stale whatsoever, just a release waiting to be installed —
+		// classified `stale-load` with an empty `scopes`. No installer ran,
+		// `repairStaleLoad` had no row behind 0.5.0 to move and reported ok, the
+		// engine counted a success, and 0.6.0 was never installed on any machine
+		// with a pending release.
+		//
+		// The note it emitted contradicted itself in the same breath: "loads
+		// v0.5.0, installed v0.5.0".
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ version: "0.6.0", loadedVersion: "0.5.0" })),
+		);
+
+		expect(item).toMatchObject({
+			action: "update",
+			reason: "behind",
+			installed: "0.5.0",
+			loaded: "0.5.0",
+			available: "0.6.0",
+			target: "0.6.0",
+			scopes: ["project"],
+		});
+	});
+
+	test("the same pending release is planned as work, and clears the gate once applied", () => {
+		// The consequence of the misclassification, pinned separately from the
+		// label: `stale-load` carries no scopes, so the apply loop had nothing to
+		// install, while `planIsBehind` kept the `--check` gate red forever.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ version: "0.6.0", loadedVersion: "0.5.0" })),
+		);
+		const single = plan({ plugins: [item as PluginUpdateItem] });
+
+		expect(planWorkItems(single)).toEqual(["madbench@magus"]);
+		expect(item?.scopes).toEqual(["project"]);
+		expect(planIsBehind(single)).toBe(true);
+	});
+
+	test("an UNVERSIONED catalog cannot hide a real stale load", () => {
+		// The mirror failure of the same wrong operand: 278 of the 292 plugins in
+		// `claude-plugins-official` publish no version, so `available` is null,
+		// `isRepairablyBehind(null, loaded)` is false, and a genuine stale load
+		// classified `current` with reason `no-published-version` — green about a
+		// session running old code.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ version: null })),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			reason: "older-version-loads",
+			installed: "0.5.0",
+			loaded: "0.3.0",
+			available: null,
+			target: "0.5.0",
+			note: "loads v0.3.0, installed v0.5.0",
+		});
+	});
+
+	test("an exact pin does not hide it either", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "0.5.0" },
+			catalog(madbench()),
+		);
+		expect(item?.action).toBe("stale-load");
+	});
+
+	test("loading the installed version is plain `current`", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ loadedVersion: "0.5.0" })),
+		);
+		expect(item).toMatchObject({ action: "current", loaded: "0.5.0" });
+	});
+
+	test("a loaded version AHEAD of the catalog is not a stale load", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ loadedVersion: "0.6.0" })),
+		);
+		expect(item?.action).toBe("current");
+	});
+
+	test("an unknown loaded version changes nothing — cannot tell is not a finding", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(madbench({ loadedVersion: null })),
+		);
+		expect(item).toMatchObject({ action: "current", loaded: null });
+	});
+
+	/**
+	 * THE PIN IS A CEILING on this branch.
+	 *
+	 * `installed` is the highest version in ANY scope and `scopesNeeding` never
+	 * downgrades, so a scope legitimately sits above an exact pin — permanently.
+	 * Comparing the loaded version against the uncapped `installed` therefore
+	 * called a plugin loading exactly its pinned version a broken load, and the
+	 * repair then moved the pinned rows off the pin and reported success.
+	 *
+	 * One registry shape, two pins, opposite answers — which is the whole point:
+	 * only the pin can say whether moving this repo up to the user-scope version is
+	 * wanted.
+	 */
+	const pinned = (over: Partial<PluginInfo> = {}) =>
+		info({
+			id: "madbench@magus",
+			version: "0.3.0",
+			installedVersion: "0.3.0",
+			loadedVersion: "0.3.0",
+			projectScope: { enabled: true, version: "0.3.0" },
+			// Higher, in a scope this project did not ask for and cannot downgrade.
+			userScope: { enabled: true, version: "0.5.0" },
+			...over,
+		});
+
+	test("a plugin loading exactly its exact pin is NOT a broken load", () => {
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "0.3.0" },
+			catalog(pinned()),
+		);
+
+		expect(item).toMatchObject({
+			action: "current",
+			reason: "up-to-date",
+			pinned: "0.3.0",
+			// Still reported honestly: 0.5.0 IS installed, in user scope.
+			installed: "0.5.0",
+			loaded: "0.3.0",
+			target: "0.3.0",
+		});
+		expect(item?.note).toBeUndefined();
+	});
+
+	test("under the same rows pinned to `latest`, the promotion IS a broken load", () => {
+		// The negative control for the cap: it must not silently disable the state.
+		// Nothing pins this plugin down, so 0.5.0 on the machine is the version to
+		// converge on and loading 0.3.0 here is the defect.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "latest" },
+			catalog(pinned({ version: "0.5.0" })),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			reason: "older-version-loads",
+			installed: "0.5.0",
+			loaded: "0.3.0",
+			target: "0.5.0",
+			note: "loads v0.3.0, installed v0.5.0",
+		});
+	});
+
+	test("an exact pin still reports a load BELOW it, and targets the pin", () => {
+		// The cap is a ceiling, not an off switch: 0.2.0 loads, the pin asked for
+		// 0.3.0, and 0.3.0 is installed here — so there is a repair to make, and its
+		// target is the pinned version rather than user scope's 0.5.0.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "0.3.0" },
+			catalog(pinned({ loadedVersion: "0.2.0" })),
+		);
+
+		expect(item).toMatchObject({
+			action: "stale-load",
+			loaded: "0.2.0",
+			target: "0.3.0",
+			note: "loads v0.2.0, installed v0.3.0",
+		});
+	});
+
+	test("a pin naming a version installed nowhere at or below it stays silent", () => {
+		// Only 0.5.0 is on disk and the pin asked for 0.3.0. There is no repair this
+		// branch may perform — moving to 0.5.0 exceeds the pin, and 0.3.0 has no
+		// cache directory — so the pin branch below reports the pin state instead of
+		// this one quietly promoting the plugin.
+		const [item] = planPluginUpdates(
+			{ "madbench@magus": "0.3.0" },
+			catalog(
+				pinned({
+					projectScope: undefined,
+					loadedVersion: "0.2.0",
+				}),
+			),
+		);
+
+		expect(item?.action).not.toBe("stale-load");
+		expect(item?.installed).toBe("0.5.0");
+	});
+
+	test("it is counted on its own, never as current", () => {
+		const counts = countPluginStates(
+			planPluginUpdates(
+				{ "madbench@magus": "latest", "dev@magus": "latest" },
+				catalog(
+					madbench(),
+					info({
+						id: "dev@magus",
+						version: "7.4.0",
+						installedVersion: "7.4.0",
+						loadedVersion: "7.4.0",
+						projectScope: { enabled: true, version: "7.4.0" },
+					}),
+				),
+			),
+		);
+
+		expect(counts["stale-load"]).toBe(1);
+		expect(counts.current).toBe(1);
+		expect(counts.update).toBe(0);
+	});
+});