magus-cli 7.11.3 → 7.11.5

package/package.json

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

package/src/__tests__/cli-profile-prompts.test.ts

@@ -919,7 +919,7 @@ describe("REQ-3 ensureManifest", () => {
 	);
 
 	test(
-		"REQ-3d2 with no project plugins and a USER plugin, the plugins line says USER and the project has none of its own",
+		"REQ-3d2 with no project plugins and a USER plugin, nothing is adopted and no profile is written",
 		async () => {
 			const sb = await sandbox();
 			const project = await standaloneProject(sb, {
@@ -932,17 +932,17 @@ describe("REQ-3 ensureManifest", () => {
 			const run = await callBootstrap(sb, "ensureManifest", project, {});
 
 			expect(run.error).toBeNull();
-			const pluginLines = run.lines.filter((l) =>
-				l.trim().startsWith("plugins"),
+			expect(run.result).toBeNull();
+			expect(run.lines.filter((l) => l.trim().startsWith("plugins"))).toEqual(
+				[],
 			);
-			expect(pluginLines.length).toBeGreaterThan(0);
-			expect(pluginLines.some((l) => l.includes("USER"))).toBe(true);
-			expect(pluginLines.filter((l) => l.includes("PROJECT"))).toEqual([]);
 			expect(
-				run.lines.some((l) =>
-					l.includes("This project has no plugins of its own"),
-				),
+				run.lines.some((l) => l.includes("no plugins to save as one")),
 			).toBe(true);
+			expect(run.lines.filter((l) => l.includes("USER"))).toEqual([]);
+			expect(
+				await Bun.file(join(project, ".claude", "profiles.json")).exists(),
+			).toBe(false);
 		},
 		CHILD_TEST_TIMEOUT_MS,
 	);

package/src/__tests__/deprecated-remove-all-profiles.test.ts

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, 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 { readManifest, writeManifest } from "../services/manifest.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { removeDeprecatedPlugin } from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+/**
+ * `d` on a deprecated plugin that is installed at no scope in this folder, but
+ * shows as a row because the profile render writes `"<id>": false` for it.
+ *
+ * The render writes `false` for every id in `allPluginIds`, the union of every
+ * profile in `.claude/profiles.json` (`renderProfile`), so a plugin a profile
+ * that is NOT active still lists keeps its key in the live settings.json. The
+ * Plugins screen turns that key into a row. Uninstalling touches nothing:
+ * there is no install here, and the CLI answers every scope with "nothing at
+ * this scope here", in the wording measured on Claude Code 2.1.312.
+ *
+ * CONTRACT the fix must provide, in `services/update-engine.ts`, for the
+ * Plugins screen's `d` to call when the plan carries no `remove` item:
+ *
+ *   export async function removeDeprecatedPlugin(
+ *     pluginId: string,
+ *     projectPath: string,
+ *     deps?: {
+ *       // default `uninstallPluginViaCli`
+ *       uninstall?: (id: string, scope: PluginScope, cwd: string) => Promise<void>;
+ *       // default `readInheritedRegistryRows`
+ *       inheritedRows?: (id: string, projectPath: string) => Promise<InstalledPluginEntry[]>;
+ *     },
+ *   ): Promise<{ problems: unknown[]; unlistedFrom: string[] }>
+ *
+ *   1. Uninstalls at user, project and local in `projectPath`; an error
+ *      `isNotInstalledAnswer` accepts is not a problem.
+ *   2. Uninstalls each inherited row in its own folder; errors are problems.
+ *   3. Removes the id from EVERY profile in the project's profiles.json that
+ *      lists it (`removePluginFromProfile` per profile); `unlistedFrom` names
+ *      them. Profiles that do not list it are not written.
+ *   4. Re-applies the active profile, so the live settings.json no longer
+ *      carries a key for the id.
+ *
+ * Only for a deprecated (no longer published) plugin: the caller decides that.
+ */
+
+const ID = "code-analysis@magus";
+
+/** Measured, Claude Code 2.1.312, from a folder with no row while others hold PROJECT rows. */
+const wrongScope = (scope: PluginScope) =>
+	new Error(
+		`✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not ${scope}. Use --scope project to uninstall.`,
+	);
+
+/** The magus-src shape: the active profile does not list it, two others do. */
+const manifest = (): ProfileManifest => ({
+	version: 2,
+	profiles: {
+		default: { name: "Default", plugins: { "dev@magus": "latest" } },
+		maintainer: {
+			name: "Maintainer",
+			plugins: { "dev@magus": "latest", [ID]: "latest" },
+		},
+		lean: { name: "Lean", plugins: { [ID]: "latest" } },
+		minimal: { name: "Minimal", plugins: { "setup@magus": "latest" } },
+	},
+});
+
+describe("removeDeprecatedPlugin: a deprecated plugin only other profiles list", () => {
+	let project: string;
+	let log: ReturnType<typeof spyOn>;
+	const settingsPath = () => join(project, ".claude", "settings.json");
+	const profilesPath = () => join(project, ".claude", "profiles.json");
+	const mcpPath = () => join(project, ".mcp.json");
+
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "deprecated-all-profiles-"));
+		log = spyOn(console, "log").mockImplementation(() => {});
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "default", project, {
+			onDisplace: () => {},
+		});
+	});
+	afterEach(async () => {
+		log.mockRestore();
+		await rm(project, { recursive: true, force: true });
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should report no failure, unlist it from every profile, and leave no settings key for it", async () => {
+		// Seeded red: the render wrote the key that makes the row.
+		expect((await fs.readJson(settingsPath())).enabledPlugins[ID]).toBe(false);
+		const before = (await fs.readJson(profilesPath())).profiles;
+
+		const calls: Array<{ scope: PluginScope; cwd: string }> = [];
+		const result = await removeDeprecatedPlugin(ID, project, {
+			uninstall: async (_id, scope, cwd) => {
+				calls.push({ scope, cwd });
+				if (scope === "project") {
+					throw new Error(`Plugin "${ID}" is not installed in project scope.`);
+				}
+				throw wrongScope(scope);
+			},
+			inheritedRows: async () => [],
+		});
+
+		expect(result.problems).toEqual([]);
+		expect([...result.unlistedFrom].sort()).toEqual(["lean", "maintainer"]);
+		expect(calls.map((c) => c.scope).sort()).toEqual([
+			"local",
+			"project",
+			"user",
+		]);
+		expect(calls.every((c) => c.cwd === project)).toBe(true);
+
+		const after = (await readManifest(project)).profiles;
+		for (const id of Object.keys(after)) {
+			expect(after[id]?.plugins?.[ID]).toBeUndefined();
+		}
+		expect(after.maintainer?.plugins).toEqual({ "dev@magus": "latest" });
+		// Profiles that never listed it are not written at all.
+		const raw = (await fs.readJson(profilesPath())).profiles;
+		expect(raw.default).toEqual(before.default);
+		expect(raw.minimal).toEqual(before.minimal);
+
+		const live = (await fs.readJson(settingsPath())).enabledPlugins;
+		expect(Object.hasOwn(live, ID)).toBe(false);
+		expect(live["dev@magus"]).toBe(true);
+
+		// The row does not come back: the next entry point's reconcile and a
+		// fresh activation leave the key out.
+		await reconcileActiveProfile(project);
+		await activateProfile(await readManifest(project), "default", project, {
+			onDisplace: () => {},
+		});
+		expect(
+			Object.hasOwn((await fs.readJson(settingsPath())).enabledPlugins, ID),
+		).toBe(false);
+	});
+
+	// REGRESSION: deprecated plugin `d` re-rendered the live files without absorbing them, losing edits Claude Code made after the TUI started — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should keep edits made to the live files after the profile was activated", async () => {
+		// Written straight into the live files, as Claude Code does mid-session.
+		const settings = await fs.readJson(settingsPath());
+		settings.permissions = { allow: ["Bash(ls:*)"] };
+		settings.enabledPlugins["other@magus"] = true;
+		await fs.writeJson(settingsPath(), settings, { spaces: 2 });
+		const mcp = await fs.readJson(mcpPath());
+		mcp.mcpServers = { ...mcp.mcpServers, local: { command: "local-mcp" } };
+		await fs.writeJson(mcpPath(), mcp, { spaces: 2 });
+
+		const result = await removeDeprecatedPlugin(ID, project, {
+			uninstall: async (_id, scope) => {
+				throw wrongScope(scope);
+			},
+			inheritedRows: async () => [],
+		});
+
+		expect(result.problems).toEqual([]);
+		const live = await fs.readJson(settingsPath());
+		expect(live.permissions?.allow).toEqual(["Bash(ls:*)"]);
+		expect(live.enabledPlugins["other@magus"]).toBe(true);
+		expect(Object.hasOwn(live.enabledPlugins, ID)).toBe(false);
+		expect((await fs.readJson(mcpPath())).mcpServers?.local).toEqual({
+			command: "local-mcp",
+		});
+	});
+});

package/src/__tests__/not-installed-answer-wrong-scope.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { isNotInstalledAnswer } from "../services/claude-cli.js";
+
+/**
+ * `isNotInstalledAnswer` classifies the CLI's answer to an uninstall at a
+ * scope that holds nothing for this folder. Claude Code has two wordings for
+ * it, and both mean "nothing to do here", never a failure.
+ *
+ * MEASURED on Claude Code 2.1.312, from a folder with no registry row while
+ * other folders hold PROJECT rows for the plugin: `--scope user` and
+ * `--scope local` exit 1 with the strings below. The older wording is what the
+ * CLI says when no folder holds a row at all.
+ */
+
+const ID = "code-analysis@magus";
+
+/** The exact text `claude plugin uninstall … --scope user` printed. */
+const MEASURED_USER = `✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not user. Use --scope project to uninstall.`;
+/** The exact text `claude plugin uninstall … --scope local` printed. */
+const MEASURED_LOCAL = `✘ Failed to uninstall plugin "${ID}": Plugin "${ID}" is installed in project scope, not local. Use --scope project to uninstall.`;
+
+describe("isNotInstalledAnswer", () => {
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should treat the measured 'installed in project scope, not user' answer as nothing to remove", () => {
+		expect(isNotInstalledAnswer(new Error(MEASURED_USER))).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should treat the measured 'installed in project scope, not local' answer as nothing to remove", () => {
+		expect(isNotInstalledAnswer(new Error(MEASURED_LOCAL))).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should still treat the older 'not installed in user scope' answer as nothing to remove", () => {
+		expect(
+			isNotInstalledAnswer(
+				new Error(`Plugin "${ID}" is not installed in user scope.`),
+			),
+		).toBe(true);
+	});
+
+	// REGRESSION: deprecated plugin `d` failed with "installed in project scope, not user" and the row came back — Fixed in /dev:fix session dev-fix-20261029-2140-uninstall
+	test("should still count an unrelated error as a failure", () => {
+		expect(isNotInstalledAnswer(new Error("claude timed out"))).toBe(false);
+	});
+});

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

@@ -1,5 +1,9 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
+	adoptCurrentProject,
 	buildAdoptedProfile,
 	findMachineSpecificPaths,
 } from "../services/profile-adopt.js";
@@ -175,3 +179,61 @@ describe("findMachineSpecificPaths", () => {
 		expect(findMachineSpecificPaths({ a: `${HOME}/x` }, "")).toEqual([]);
 	});
 });
+
+describe("adoptCurrentProject — USER plugins never enter a PROJECT profile", () => {
+	// REGRESSION: first magus run in a fresh checkout adopted USER plugins into the PROJECT profile (MTL-323)
+	let root: string;
+	let project: string;
+	let savedHome: string | undefined;
+
+	function writeSettings(dir: string, settings: Record<string, unknown>) {
+		mkdirSync(join(dir, ".claude"), { recursive: true });
+		writeFileSync(
+			join(dir, ".claude", "settings.json"),
+			JSON.stringify(settings, null, 2),
+		);
+	}
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "magus-adopt-scope-"));
+		project = join(root, "project");
+		const home = join(root, "home");
+		mkdirSync(project, { recursive: true });
+		// The USER settings reader resolves process.env.HOME at call time.
+		savedHome = process.env.HOME;
+		process.env.HOME = home;
+		writeSettings(home, {
+			enabledPlugins: {
+				"setup@magus": true,
+				"agent-colours@magus-alpha": true,
+			},
+		});
+	});
+
+	afterEach(() => {
+		// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"
+		if (savedHome === undefined) delete process.env.HOME;
+		else process.env.HOME = savedHome;
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	test("a project that enables no plugins adopts none", async () => {
+		writeSettings(project, { enableAllProjectMcpServers: true });
+		const result = await adoptCurrentProject(project);
+		expect(result.entry.plugins).toEqual({});
+	});
+
+	test("a project whose every plugin entry is false adopts none", async () => {
+		writeSettings(project, {
+			enabledPlugins: { "dev@magus": false, "designer@magus": false },
+		});
+		const result = await adoptCurrentProject(project);
+		expect(result.entry.plugins).toEqual({});
+	});
+
+	test("a project that enables its own plugin adopts exactly that one", async () => {
+		writeSettings(project, { enabledPlugins: { "dev@magus": true } });
+		const result = await adoptCurrentProject(project);
+		expect(result.entry.plugins).toEqual({ "dev@magus": "latest" });
+	});
+});