magus-cli 7.5.3 → 7.6.0

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

@@ -304,7 +304,6 @@ describe("contentDriftCandidate — which plugins are even asked", () => {
 		description: "",
 		marketplace: "magus",
 		marketplaceDisplay: "magus",
-		enabled: true,
 		installedVersion: "3.0.0",
 		...over,
 	});

package/src/__tests__/files-missing-scope.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Files missing at a scope is repaired AT THAT SCOPE.
+ *
+ * The plan gave reason `files-missing` no scopes, and the engine read every
+ * `install` as "project scope". So a plugin installed at user scope with its
+ * files missing ran `claude plugin install <id> --scope project`, which turns it
+ * on in the project's settings.json — and for a plugin the active profile does
+ * not declare, the reconcile after the run took that record for the user's own
+ * edit and wrote it into the team's committed profiles.json. The TUI's `a`
+ * reached the same path.
+ *
+ * Every plan here comes from the real classifier (`planPluginUpdates`) and every
+ * apply from the real engine (`applyPlugins`); only the Claude CLI is faked.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import type { PluginScope } from "../services/claude-cli.js";
+import { writeManifest } from "../services/manifest.js";
+import type { PluginInfo, ScopeStatus } from "../services/plugin-manager.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { readActiveMarker } from "../services/profile-live.js";
+import { withCliBookkeeping } from "../services/profile-state.js";
+import {
+	type PluginApplyDeps,
+	applyPlugins,
+	pluginNeedsWork,
+} from "../services/update-engine.js";
+import {
+	type PluginUpdateItem,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { ProfileManifest } from "../types/index.js";
+
+const STRAY = "stray@magus";
+const DEV = "dev@magus";
+
+function info(
+	id: string,
+	scopes: {
+		user?: ScopeStatus;
+		project?: ScopeStatus;
+		local?: ScopeStatus;
+	},
+): PluginInfo {
+	const [name, marketplace] = id.split("@") as [string, string];
+	return {
+		id,
+		name,
+		version: "1.0.0",
+		description: "",
+		marketplace,
+		marketplaceDisplay: "Magus",
+		userScope: scopes.user,
+		projectScope: scopes.project,
+		localScope: scopes.local,
+	};
+}
+
+/** The plan item for `id`, from the real classifier. */
+function planFor(
+	id: string,
+	plugins: PluginInfo[],
+	pins: Record<string, string> = {},
+): PluginUpdateItem {
+	const item = planPluginUpdates(pins, plugins).find((i) => i.pluginId === id);
+	if (!item) throw new Error(`no plan item for ${id}`);
+	return item;
+}
+
+/**
+ * A fake Claude CLI that records each command's scope. `onInstall` is what the
+ * real one writes as a side effect — see the reconcile case.
+ */
+function fakeCli(
+	onInstall: (id: string, scope: PluginScope) => Promise<void> = async () => {},
+) {
+	const installs: Array<{ id: string; scope: PluginScope }> = [];
+	const updates: Array<{ id: string; scope: PluginScope }> = [];
+	const deps: PluginApplyDeps = {
+		install: async (id, scope) => {
+			installs.push({ id, scope });
+			await onInstall(id, scope);
+		},
+		update: async (id, scope) => {
+			updates.push({ id, scope });
+		},
+		repair: async () => {},
+		readInstalled: async () => "1.0.0",
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => {
+			throw new Error("no stale-load repair expected");
+		},
+	};
+	return { deps, installs, updates };
+}
+
+describe("the plan names the scopes whose files are missing", () => {
+	test("files missing at user scope plans user scope", () => {
+		const item = planFor(STRAY, [info(STRAY, { user: { installed: true } })]);
+		expect(item.action).toBe("install");
+		expect(item.reason).toBe("files-missing");
+		expect(item.scopes).toEqual(["user"]);
+	});
+
+	test("files missing at local scope plans local scope", () => {
+		const item = planFor(STRAY, [info(STRAY, { local: { installed: true } })]);
+		expect(item.reason).toBe("files-missing");
+		expect(item.scopes).toEqual(["local"]);
+	});
+
+	test("only the installed scopes with no version, user → project → local", () => {
+		// The project row is inherited from another checkout and not turned on
+		// here: it is neither installed nor missing, so it is not repaired.
+		const item = planFor(STRAY, [
+			info(STRAY, {
+				local: { installed: true },
+				project: { installed: false, version: "0.8.1" },
+				user: { installed: true },
+			}),
+		]);
+		expect(item.scopes).toEqual(["user", "local"]);
+	});
+
+	test("control: a declared plugin installed nowhere is `absent`, with no scopes", () => {
+		const item = planFor(DEV, [info(DEV, {})], { [DEV]: "latest" });
+		expect(item.reason).toBe("absent");
+		expect(item.scopes).toEqual([]);
+	});
+});
+
+describe("the engine reinstalls where the files are missing, never elsewhere", () => {
+	test("files missing at USER scope installs with --scope user, never project", async () => {
+		const item = planFor(STRAY, [info(STRAY, { user: { installed: true } })]);
+		const cli = fakeCli();
+
+		await applyPlugins([item], "/tmp/project", cli.deps);
+
+		// `REAL_PLUGIN_DEPS.install` is `installPlugin`, which passes this scope
+		// to `claude plugin install` as `--scope`.
+		expect(cli.installs).toEqual([{ id: STRAY, scope: "user" }]);
+		expect(cli.installs.map((c) => c.scope)).not.toContain("project");
+		expect(cli.updates).toEqual([]);
+	});
+
+	test("files missing at local scope installs with --scope local", async () => {
+		const item = planFor(STRAY, [info(STRAY, { local: { installed: true } })]);
+		const cli = fakeCli();
+
+		await applyPlugins([item], "/tmp/project", cli.deps);
+
+		expect(cli.installs).toEqual([{ id: STRAY, scope: "local" }]);
+	});
+
+	test("a progress meter counts it as work, so the bar reaches full", () => {
+		const item = planFor(STRAY, [info(STRAY, { user: { installed: true } })]);
+		expect(pluginNeedsWork(item)).toBe(true);
+	});
+
+	test("control: an `absent` profile plugin still goes in at project scope", async () => {
+		const item = planFor(DEV, [info(DEV, {})], { [DEV]: "latest" });
+		const cli = fakeCli();
+
+		await applyPlugins([item], "/tmp/project", cli.deps);
+
+		expect(cli.installs).toEqual([{ id: DEV, scope: "project" }]);
+	});
+});
+
+describe("repairing an undeclared user-scope plugin leaves profiles.json alone", () => {
+	let project: string;
+	let log: ReturnType<typeof spyOn>;
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "files-missing-scope-"));
+		log = spyOn(console, "log").mockImplementation(() => {});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("the full run — plan, apply under withCliBookkeeping, reconcile — writes nothing into profiles.json", async () => {
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: { team: { name: "Team", plugins: { [DEV]: "latest" } } },
+		};
+		await writeManifest(manifest, project);
+		await activateProfile(manifest, "team", project, { onDisplace: () => {} });
+		const profilesPath = join(project, ".claude", "profiles.json");
+		const settingsPath = join(project, ".claude", "settings.json");
+		const before = await readFile(profilesPath, "utf8");
+		// Without an active marker withCliBookkeeping skips the reconcile, and
+		// this case would pass without testing anything.
+		expect(await readActiveMarker(project)).not.toBeNull();
+
+		// What `magus update` plans: the profile's plugin, installed and current
+		// at project scope, and an undeclared plugin installed at user scope with
+		// its files missing.
+		const plan = planPluginUpdates({ [DEV]: "latest" }, [
+			info(DEV, { project: { installed: true, version: "1.0.0" } }),
+			info(STRAY, { user: { installed: true } }),
+		]);
+		// `claude plugin install --scope project` turns the plugin on in the
+		// project's settings.json. The user-scope write lands in
+		// ~/.claude/settings.json, which a reconcile never reads.
+		const cli = fakeCli(async (id, scope) => {
+			if (scope !== "project") return;
+			const settings = await fs.readJson(settingsPath);
+			settings.enabledPlugins = { ...settings.enabledPlugins, [id]: true };
+			await fs.writeFile(settingsPath, JSON.stringify(settings));
+		});
+		const reported: string[] = [];
+
+		await withCliBookkeeping(
+			project,
+			() => applyPlugins(plan, project, cli.deps),
+			{
+				// Exactly what `magus update` passes: the active profile's plugins.
+				installable: [DEV],
+				report: (line) => reported.push(line),
+			},
+		);
+
+		// The outcome first — nothing absorbed — then the cause.
+		expect(reported).toEqual([]);
+		expect(await readFile(profilesPath, "utf8")).toBe(before);
+		const live = await fs.readJson(settingsPath);
+		expect(live.enabledPlugins?.[STRAY]).toBeUndefined();
+		expect(cli.installs).toEqual([{ id: STRAY, scope: "user" }]);
+	});
+});

package/src/__tests__/{enabled-not-installed.test.ts → files-missing.test.ts}

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { isEnabledButNotInstalled } from "../services/plugin-manager.js";
+import { hasMissingFiles } from "../services/plugin-manager.js";
 import type { PluginInfo } from "../services/plugin-manager.js";
 
 /**
- * "Enabled but not installed" is a broken state that previously rendered
- * identically to a healthy install: a green scope square and no version.
+ * "Files missing" — installed at a scope, with no version resolving — is a
+ * broken state that previously rendered identically to a healthy install: a
+ * green scope square and no version.
  *
  * It is also invisible to every update path, because the check is
  * `installedVersion && compare(latest, installedVersion) > 0` — with no
@@ -19,18 +20,17 @@ const plugin = (over: Partial<PluginInfo>): PluginInfo =>
 		description: "",
 		marketplace: "magus",
 		marketplaceDisplay: "Magus",
-		enabled: true,
 		...over,
 	}) as PluginInfo;
 
-describe("isEnabledButNotInstalled", () => {
-	test("enabled in project scope with no installed version is flagged", () => {
+describe("hasMissingFiles", () => {
+	test("installed in project scope with no installed version is flagged", () => {
 		// The real case: terminal/code-search are in this project's enabledPlugins
 		// but have no registry entry for it and none at user scope.
 		expect(
-			isEnabledButNotInstalled(
+			hasMissingFiles(
 				plugin({
-					projectScope: { enabled: true },
+					projectScope: { installed: true },
 					installedVersion: undefined,
 				}),
 			),
@@ -39,53 +39,59 @@ describe("isEnabledButNotInstalled", () => {
 
 	test("a healthy install is not flagged", () => {
 		expect(
-			isEnabledButNotInstalled(
-				plugin({ projectScope: { enabled: true }, installedVersion: "1.0.0" }),
+			hasMissingFiles(
+				plugin({
+					projectScope: { installed: true, version: "1.0.0" },
+					installedVersion: "1.0.0",
+				}),
 			),
 		).toBe(false);
 	});
 
-	test('installedVersion "0.0.0" means installed-with-unknown-version, not missing', () => {
+	test('a "0.0.0" version means installed-with-unknown-version, not missing', () => {
 		// Anthropic's official plugins record exactly this. Treating it as missing
 		// would mislabel every one of them as broken.
 		expect(
-			isEnabledButNotInstalled(
-				plugin({ userScope: { enabled: true }, installedVersion: "0.0.0" }),
+			hasMissingFiles(
+				plugin({
+					userScope: { installed: true, version: "0.0.0" },
+					installedVersion: "0.0.0",
+				}),
 			),
 		).toBe(false);
 	});
 
-	test("not enabled anywhere is not flagged — it is simply available", () => {
-		expect(
-			isEnabledButNotInstalled(plugin({ installedVersion: undefined })),
-		).toBe(false);
+	test("not installed anywhere is not flagged — it is simply available", () => {
+		expect(hasMissingFiles(plugin({ installedVersion: undefined }))).toBe(
+			false,
+		);
 	});
 
 	test("orphaned plugins are excluded — they have their own 'deprecated' state", () => {
 		expect(
-			isEnabledButNotInstalled(
+			hasMissingFiles(
 				plugin({
 					isOrphaned: true,
-					projectScope: { enabled: true },
+					projectScope: { installed: true },
 					installedVersion: undefined,
 				}),
 			),
 		).toBe(false);
 	});
 
-	test("any enabled scope counts, not just project", () => {
+	test("any installed scope counts, not just project", () => {
 		for (const scope of ["userScope", "projectScope", "localScope"] as const) {
-			expect(
-				isEnabledButNotInstalled(plugin({ [scope]: { enabled: true } })),
-			).toBe(true);
+			expect(hasMissingFiles(plugin({ [scope]: { installed: true } }))).toBe(
+				true,
+			);
 		}
 	});
 
-	test("a scope present but disabled does not count as enabled", () => {
+	test("a scope present but not installed does not count", () => {
 		expect(
-			isEnabledButNotInstalled(
+			hasMissingFiles(
 				plugin({
-					projectScope: { enabled: false },
+					projectScope: { installed: false },
 					installedVersion: undefined,
 				}),
 			),