magus-cli 7.14.0 → 7.14.2

package/README.md

@@ -46,9 +46,10 @@ install [profile]           Install a profile's plugins, binaries, skills and
 update [profile]            Bring the ACTIVE profile up to date: install what it
                             declares but this machine lacks, and advance every
                             "latest" pin to the newest published version.
+                            Applies without asking; it only moves forward.
+  --dry-run                 Show the plan and stop; writes nothing, exits 0
   --check                   Report only, write nothing (exits 1 if anything is
                             missing or known to be behind)
-  --yes, -y                 Skip the confirmation prompt
 profile list                Show every profile; ● marks the active one
 profile show <name>         Print a profile's fully resolved closure
 profile switch <name>       Make <name> active: render its settings.json,
@@ -56,8 +57,6 @@ profile switch <name>       Make <name> active: render its settings.json,
 profile init                Write .claude/profiles.json from this project's setup
 doctor [--fix]              Check binary deps, the active profile, conventions
 
-claude [args...]            Check for plugin updates (1h cache), then run claude
-  --force, -f               Force the update check
 upgrade                     Update magus itself
 --version, -v               Version + update check
 --help, -h                  This list
@@ -171,15 +170,16 @@ walks through it end to end, including conflicts and protected branches.
 
 | Screen | What it manages |
 |---|---|
-| Plugins | Install, enable, disable; shows version changes and newly installed plugins |
+| Plugins | Install, uninstall and update at USER, PROJECT or LOCAL scope; shows version changes and newly installed plugins |
 | Skills | Browse and install skills from configured skill repos |
 | MCP | Add MCP servers from a curated catalog |
 | Settings | Claude Code settings, from a catalog of known keys |
-| Profiles | Saved plugin sets (the TUI's own, older profile concept) |
+| Profiles | Switch between this project's profiles, apply a built-in one, rename, delete, copy or import |
 | CLI Tools | Install and update CLI tools via the right package manager; a tool a plugin installs from a release shows as managed by that plugin |
 | Git State | Gitignore conventions and repo hygiene |
 | Alias | Shell alias + flag management for launching `claude` |
 | Styles | Communication style presets, composed into one native output style |
+| Models | Per-subagent model routing presets (`magus models`) |
 
 Navigate with `↑/↓` or `j/k`, `Enter` to select, `r` to refresh, `?` for help,
 `q`/`Escape` to go back. Number keys `1`–`9` jump straight to a screen.

package/package.json

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

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/cli/router.ts

@@ -305,7 +305,8 @@ Usage: magus                    Open the interactive TUI
 Options:
   -v, --version  Show version and check for updates
   -h, --help     Show this help message
-  --no-refresh   Skip auto-refresh of marketplaces on startup
+  --no-refresh   Skip adding, at startup, marketplaces this project uses
+                 but this machine lacks
   --theme light|dark   Force the palette. Otherwise: MAGUS_THEME, then
                        TERM_THEME, then a 250 ms terminal query, then COLORFGBG,
                        then dark. Only the exact words "light"/"dark" count.
@@ -373,9 +374,9 @@ Other commands:
   upgrade            Update magus ITSELF to the latest version
 
 Navigation (TUI):
-  [1] Plugins    [4] Settings   [7] Git State
+  [1] Plugins    [4] Settings   [7] Git State   [0] Models
   [2] Skills     [5] Profiles   [8] Alias
-  [3] MCP        [6] CLI Tools
+  [3] MCP        [6] CLI Tools  [9] Styles
 
 Keys:
   ↑/↓ or j/k     Navigate

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 ----------------------------------------------------------------
 
 /**

package/src/ui/screens/PluginsScreen.tsx

@@ -789,28 +789,15 @@ export function PluginsScreen() {
 
 	const handleShowTeamConfigHelp = async () => {
 		const helpText =
-			"TEAM CONFIGURATION FOR MARKETPLACES\n\n" +
-			"To configure marketplaces for your entire team:\n\n" +
-			"1. Add to .claude/settings.json (committed to git):\n\n" +
-			"   {\n" +
-			'     "extraKnownMarketplaces": {\n' +
-			'       "company-tools": {\n' +
-			'         "source": {\n' +
-			'           "source": "github",\n' +
-			'           "repo": "your-org/claude-plugins"\n' +
-			"         }\n" +
-			"       }\n" +
-			"     },\n" +
-			'     "enabledPlugins": {\n' +
-			'       "code-formatter@company-tools": true\n' +
-			"     }\n" +
-			"   }\n\n" +
-			"2. Team members get prompted to install when they trust the folder\n\n" +
-			"3. Marketplaces are GLOBAL ONLY (managed by Claude Code)\n" +
-			"   - Not project-specific\n" +
-			"   - All team members share the same marketplace cache\n\n" +
-			"NOTE: Individual plugin enablement is still project-specific.\n" +
-			'Use "Project" scope in magus to enable for the team.';
+			"TEAM CONFIGURATION\n\n" +
+			"To give your whole team the same plugins:\n\n" +
+			"1. Install each plugin at PROJECT scope (p).\n" +
+			"   magus records it in this project's profile, together with\n" +
+			"   where its marketplace lives.\n\n" +
+			"2. Commit .claude/profiles.json.\n\n" +
+			"3. Teammates run magus install (a fresh clone) or magus update.\n" +
+			"   magus adds the marketplaces and installs the plugins.\n\n" +
+			"Your company's own marketplace: magus edit.";
 
 		await modal.message("Team Configuration", helpText);
 	};