magus-cli 7.14.0 → 7.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.14.0",
+  "version": "7.14.1",
   "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.14.0",
-    "magus-cli-darwin-x64": "7.14.0",
-    "magus-cli-linux-x64": "7.14.0"
+    "magus-cli-darwin-arm64": "7.14.1",
+    "magus-cli-darwin-x64": "7.14.1",
+    "magus-cli-linux-x64": "7.14.1"
   }
 }

package/src/__tests__/scope-uninstall-wrong-scope.test.ts

@@ -0,0 +1,341 @@
+/**
+ * A scope key on the Plugins screen uninstalls through `uninstallPluginInScope`.
+ * When the scope's settings.json turns the plugin on but Claude Code's registry
+ * holds its row at ANOTHER scope, `claude plugin uninstall --scope <scope>`
+ * refuses with "is installed in <other> scope, not <scope>" and changes
+ * nothing. In a profiled project that is the normal state of a PROJECT enable:
+ * the profile render wrote it, so the profile is what must drop it. Where no
+ * profile owns the enable, the refusal must reach the user in magus's terms,
+ * never as Claude Code's raw text.
+ *
+ * Real files, real reconcile: a temp project, HOME pointed at a temp dir. Only
+ * the `claude` CLI is doubled, and its uninstall refuses the way Claude Code
+ * does, touching no file.
+ */
+
+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 { readManifest, writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	type PluginApplyDeps,
+	REAL_PLUGIN_DEPS,
+	REAL_REMOVE_DEPS,
+	uninstallPluginInScope,
+} from "../services/update-engine.js";
+import type { ProfileManifest } from "../types/index.js";
+
+type Scope = "user" | "project" | "local";
+
+let project: string;
+let home: string;
+let log: ReturnType<typeof spyOn>;
+const saved = {
+	HOME: process.env.HOME,
+	CLAUDE_CONFIG_DIR: process.env.CLAUDE_CONFIG_DIR,
+};
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			team: {
+				name: "Team",
+				plugins: { "dev@magus": "latest", "multimodel@magus": "latest" },
+			},
+		},
+	};
+}
+
+/** The settings.json `claude plugin … --scope <scope>` reads and writes. */
+function settingsFor(scope: Scope): string {
+	if (scope === "user") return join(home, ".claude", "settings.json");
+	if (scope === "local") return join(project, ".claude", "settings.local.json");
+	return join(project, ".claude", "settings.json");
+}
+
+async function setEnabled(scope: Scope, pluginId: string): Promise<void> {
+	const file = settingsFor(scope);
+	const json = (await fs.pathExists(file))
+		? ((await fs.readJson(file)) as Record<string, unknown>)
+		: {};
+	json.enabledPlugins = {
+		...((json.enabledPlugins as Record<string, boolean>) ?? {}),
+		[pluginId]: true,
+	};
+	await fs.outputFile(file, JSON.stringify(json));
+}
+
+async function enabledIn(scope: Scope): Promise<Record<string, boolean>> {
+	const file = settingsFor(scope);
+	if (!(await fs.pathExists(file))) return {};
+	const json = (await fs.readJson(file)) as {
+		enabledPlugins?: Record<string, boolean>;
+	};
+	return json.enabledPlugins ?? {};
+}
+
+async function profilePlugins(): Promise<Record<string, unknown>> {
+	const { profiles } = await readManifest(project);
+	return (profiles.team?.plugins ?? {}) as Record<string, unknown>;
+}
+
+/** Claude Code's refusal when the registry row is at `rowAt`, not `asked`. */
+function wrongScopeRefusal(pluginId: string, rowAt: Scope, asked: Scope) {
+	return new Error(
+		`✘ Failed to uninstall plugin "${pluginId}": Plugin "${pluginId}" is installed in ${rowAt} scope, not ${asked}. Use --scope ${rowAt} to uninstall.`,
+	);
+}
+
+/**
+ * The real engine deps with only the `claude` CLI and the version read-back
+ * doubled. `uninstall` is the given behaviour; it never touches a file.
+ */
+function deps(
+	uninstall: (pluginId: string, scope: Scope) => Promise<void>,
+): PluginApplyDeps {
+	const {
+		loadedVersion: _loaded,
+		registryRows: _rows,
+		...real
+	} = REAL_PLUGIN_DEPS;
+	return {
+		...real,
+		install: async () => {
+			throw new Error("install must not run here");
+		},
+		update: async () => {},
+		repair: async () => {},
+		readInstalled: async () => "1.0.0",
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => {
+			throw new Error("repairStaleLoad must not run here");
+		},
+		remove: { ...REAL_REMOVE_DEPS, uninstall },
+	};
+}
+
+/** Claude Code holding the plugin's only registry row at `rowAt`. */
+function rowOnlyAt(rowAt: Scope): PluginApplyDeps {
+	return deps(async (pluginId, scope) => {
+		if (scope !== rowAt) throw wrongScopeRefusal(pluginId, rowAt, scope);
+	});
+}
+
+/** Claude Code's older refusal, which names no scope the plugin is at. */
+function notInstalledRefusal(pluginId: string, asked: Scope) {
+	return new Error(
+		`✘ Failed to uninstall plugin "${pluginId}": Plugin "${pluginId}" is not installed in ${asked} scope.`,
+	);
+}
+
+async function rejection(promise: Promise<unknown>): Promise<string> {
+	try {
+		await promise;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	throw new Error("expected the uninstall to reject, but it resolved");
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "scope-wrong-scope-"));
+	home = await mkdtemp(join(tmpdir(), "scope-wrong-scope-home-"));
+	process.env.HOME = home;
+	process.env.CLAUDE_CONFIG_DIR = join(home, ".claude");
+	log = spyOn(console, "log").mockImplementation(() => {});
+});
+
+afterEach(async () => {
+	log.mockRestore();
+	process.env.HOME = saved.HOME;
+	if (saved.CLAUDE_CONFIG_DIR === undefined) {
+		// biome-ignore lint/performance/noDelete: an unset env var must be absent, not "undefined"
+		delete process.env.CLAUDE_CONFIG_DIR;
+	} else process.env.CLAUDE_CONFIG_DIR = saved.CLAUDE_CONFIG_DIR;
+	await rm(project, { recursive: true, force: true });
+	await rm(home, { recursive: true, force: true });
+});
+
+describe("a scope uninstall Claude Code refuses as the wrong scope", () => {
+	test("PROJECT, enabled by the active profile: the profile drops it and the project no longer enables it", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+
+		await uninstallPluginInScope(
+			"multimodel@magus",
+			"project",
+			project,
+			rowOnlyAt("user"),
+			"team",
+		);
+
+		expect((await enabledIn("project"))["multimodel@magus"]).not.toBe(true);
+		expect(await profilePlugins()).not.toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, enabled with no profile to own it: refused in magus's terms, naming USER", async () => {
+		await setEnabled("project", "multimodel@magus");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				rowOnlyAt("user"),
+			),
+		);
+
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+
+	test("USER, enabled while the only row is PROJECT: refused in magus's terms, naming PROJECT", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		await setEnabled("user", "multimodel@magus");
+		const userBefore = await fs.readFile(settingsFor("user"), "utf8");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"user",
+				project,
+				rowOnlyAt("project"),
+				"team",
+			),
+		);
+
+		expect(message).toMatch(/PROJECT/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+		expect(await fs.readFile(settingsFor("user"), "utf8")).toBe(userBefore);
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, any other CLI failure: rejected with its own text, the profile untouched", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		const failing = deps(async () => {
+			throw new Error("claude timed out");
+		});
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				failing,
+				"team",
+			),
+		);
+
+		expect(message).toBe("claude timed out");
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+	});
+
+	test("PROJECT, the older not-installed wording, no profile to own it: refused in magus's terms, naming PROJECT", async () => {
+		await setEnabled("project", "multimodel@magus");
+		const olderWording = deps(async (pluginId, scope) => {
+			throw notInstalledRefusal(pluginId, scope);
+		});
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				olderWording,
+			),
+		);
+
+		expect(message).toMatch(/PROJECT/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+
+	test("LOCAL, enabled while the only row is USER: refused naming USER, the local settings untouched", async () => {
+		await setEnabled("local", "multimodel@magus");
+		const localBefore = await fs.readFile(settingsFor("local"), "utf8");
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"local",
+				project,
+				rowOnlyAt("user"),
+			),
+		);
+
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+		expect(await fs.readFile(settingsFor("local"), "utf8")).toBe(localBefore);
+	});
+
+	test("USER, not enabled there while PROJECT installs it: resolves, the profile still lists it and the project still enables it", async () => {
+		await writeManifest(manifest(), project);
+		await activateProfile(manifest(), "team", project, {
+			onDisplace: () => {},
+		});
+		expect(await enabledIn("user")).not.toHaveProperty("multimodel@magus");
+
+		await uninstallPluginInScope(
+			"multimodel@magus",
+			"user",
+			project,
+			rowOnlyAt("project"),
+			"team",
+		);
+
+		expect(await profilePlugins()).toHaveProperty("multimodel@magus");
+		expect(await enabledIn("project")).toHaveProperty("multimodel@magus", true);
+		expect(await enabledIn("user")).not.toHaveProperty("multimodel@magus");
+	});
+
+	test("PROJECT, the profile lists it but the enable survives the drop: refused saying the profile no longer lists it, naming USER", async () => {
+		// The profile file lists the plugin; the remove double models a drop
+		// that succeeds while the PROJECT enable stays on.
+		await writeManifest(manifest(), project);
+		const base = rowOnlyAt("user");
+		const remove = base.remove;
+		if (!remove) throw new Error("the harness deps carry remove");
+		const surviving: PluginApplyDeps = {
+			...base,
+			recordInProfile: async () => {},
+			remove: {
+				...remove,
+				dependents: undefined,
+				dropFromProfile: async () => true,
+				isInstalled: async (_id, scope) => scope === "project",
+			},
+		};
+
+		const message = await rejection(
+			uninstallPluginInScope(
+				"multimodel@magus",
+				"project",
+				project,
+				surviving,
+				"team",
+			),
+		);
+
+		expect(message).toContain("no longer in the profile");
+		expect(message).toMatch(/USER/);
+		expect(message).not.toContain("Failed to uninstall plugin");
+		expect(message).not.toContain("--scope");
+	});
+});

package/src/services/claude-cli.ts

@@ -288,6 +288,19 @@ export function isNotInstalledAnswer(error: unknown): boolean {
 	);
 }
 
+/**
+ * The scope a wrong-scope answer says the plugin IS installed at — `user` from
+ * `is installed in user scope, not project` — or null when the answer names
+ * none, as the `not installed in <scope> scope` wording does.
+ */
+export function installedScopeFromAnswer(error: unknown): PluginScope | null {
+	const message = error instanceof Error ? error.message : String(error);
+	const match = /is installed in (user|project|local) scope, not /i.exec(
+		message,
+	);
+	return match ? (match[1].toLowerCase() as PluginScope) : null;
+}
+
 /**
  * Repair a plugin whose files drifted from the marketplace under an unchanged
  * version — uninstall, then install again at the same scope.

package/src/services/update-engine.ts

@@ -43,6 +43,7 @@ import { selectProfileId } from "./active-closure.js";
 import type { PluginScope } from "./claude-cli.js";
 import {
 	installPlugin,
+	installedScopeFromAnswer,
 	isNotInstalledAnswer,
 	repairPlugin,
 	uninstallPluginViaCli,
@@ -1508,7 +1509,25 @@ export async function uninstallPluginInScope(
 		}
 	}
 
-	await remove.uninstall(pluginId, scope, projectPath);
+	try {
+		await remove.uninstall(pluginId, scope, projectPath);
+	} catch (error) {
+		if (!isNotInstalledAnswer(error)) throw error;
+		await settleScopeWithNoInstall(
+			pluginId,
+			scope,
+			projectPath,
+			deps,
+			error,
+			profile,
+		);
+		if (scope === "project") {
+			await remove
+				.forgetVersion?.(pluginId, scope, projectPath)
+				.catch(() => {});
+			return;
+		}
+	}
 	if (await remove.isInstalled(pluginId, scope, projectPath)) {
 		throw new Error(`still installed at ${scope.toUpperCase()} scope`);
 	}
@@ -1531,6 +1550,83 @@ export async function uninstallPluginInScope(
 	await recordInProfileOrExplain(deps, projectPath, done);
 }
 
+/**
+ * The half of {@link uninstallPluginInScope} that runs when Claude Code answers
+ * that it holds no install of the plugin at `scope` here, so its uninstall had
+ * nothing to remove.
+ *
+ * At PROJECT the setting that turns the plugin on is the profile render's, so
+ * the profile drops it and the live files are brought back in line with the
+ * profile. USER and LOCAL settings belong to no profile, so nothing is changed
+ * there. Either way the scope is read back afterwards: still installed means
+ * nothing magus owns turns it on, and the refusal names the scope Claude Code
+ * reported, in magus's terms rather than the CLI's text.
+ */
+async function settleScopeWithNoInstall(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath: string,
+	deps: PluginApplyDeps,
+	answer: unknown,
+	profile: string | null | undefined,
+): Promise<void> {
+	const remove = deps.remove;
+	if (!remove) throw new Error("magus cannot remove plugins from here");
+	const name = pluginName(pluginId);
+	const here = scope.toUpperCase();
+
+	let wasListed = false;
+	if (scope === "project") {
+		wasListed = await profileListsPlugin(pluginId, projectPath, profile);
+		if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+			throw new Error(`${name} is still in the profile at ${here} scope`);
+		}
+		await recordInProfileOrExplain(
+			deps,
+			projectPath,
+			`${name} is no longer in the profile`,
+		);
+	}
+
+	if (!(await remove.isInstalled(pluginId, scope, projectPath))) return;
+	// The profile was changed above, so the refusal says so: the user must not
+	// find a plugin gone from the profile with nothing telling them why.
+	const lead = wasListed
+		? `${name} is no longer in the profile, but it is`
+		: `${name} is`;
+	const installedAt = installedScopeFromAnswer(answer);
+	if (installedAt && installedAt !== scope) {
+		const there = installedAt.toUpperCase();
+		throw new Error(
+			`${lead}${wasListed ? " still" : ""} installed at ${there} scope, not ${here} — remove it from ${there}`,
+		);
+	}
+	throw new Error(
+		`${lead} not installed at ${here} scope in this project — remove it from the scope that installed it`,
+	);
+}
+
+/**
+ * Whether `profile` lists the plugin, the profile picked as
+ * `removePluginFromProfile` picks it: undefined means the active one.
+ */
+async function profileListsPlugin(
+	pluginId: string,
+	projectPath: string,
+	profile: string | null | undefined,
+): Promise<boolean> {
+	const manifest = await readManifest(projectPath);
+	const id =
+		profile === undefined
+			? selectProfileId(
+					Object.keys(manifest.profiles),
+					undefined,
+					await activeProfile(projectPath),
+				)
+			: profile;
+	return id ? profileLists(manifest.profiles[id], pluginId) : false;
+}
+
 // -- binaries ----------------------------------------------------------------
 
 /**