magus-cli 7.12.1 → 7.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.12.1",
+  "version": "7.12.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.12.1",
-    "magus-cli-darwin-x64": "7.12.1",
-    "magus-cli-linux-x64": "7.12.1"
+    "magus-cli-darwin-arm64": "7.12.2",
+    "magus-cli-darwin-x64": "7.12.2",
+    "magus-cli-linux-x64": "7.12.2"
   }
 }

package/src/__tests__/tui-scope-action-profile.test.ts

@@ -0,0 +1,241 @@
+/**
+ * The Plugins screen installs and uninstalls through `installPluginInScope`
+ * and `uninstallPluginInScope`. In a profiled project a PROJECT-scope install
+ * turns the plugin on in `.claude/settings.json`; the active profile must list
+ * it as soon as the action returns, and the profile's record of the live files
+ * must move with it, so the next magus command finds nothing left to absorb.
+ *
+ * Real files, real reconcile: a temp project with `.claude/profiles.json` and
+ * an activated profile, HOME pointed at a temp dir. Only the `claude` CLI is
+ * doubled — install sets `enabledPlugins[id] = true` in the scope's
+ * settings.json, uninstall deletes it — plus the version read-back.
+ */
+
+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 { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import {
+	readActiveMarker,
+	writeActiveMarker,
+} from "../services/profile-live.js";
+import {
+	type PluginApplyDeps,
+	REAL_PLUGIN_DEPS,
+	REAL_REMOVE_DEPS,
+	installPluginInScope,
+	uninstallPluginInScope,
+	updatePluginInScope,
+} 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", "terminal@magus": "latest" },
+			},
+		},
+	};
+}
+
+/** The settings.json `claude plugin … --scope <scope>` 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,
+	on: boolean,
+): Promise<void> {
+	const file = settingsFor(scope);
+	const json = (await fs.pathExists(file))
+		? ((await fs.readJson(file)) as Record<string, unknown>)
+		: {};
+	const enabled = {
+		...((json.enabledPlugins as Record<string, boolean>) ?? {}),
+	};
+	if (on) enabled[pluginId] = true;
+	else delete enabled[pluginId];
+	json.enabledPlugins = enabled;
+	await fs.outputFile(file, JSON.stringify(json));
+}
+
+/**
+ * The real engine deps with only the `claude` CLI and the version read-back
+ * doubled. The loader and registry probes are dropped so `bringLoadForward`
+ * skips; every other member stays real.
+ */
+function deps(): PluginApplyDeps {
+	const {
+		loadedVersion: _loaded,
+		registryRows: _rows,
+		...real
+	} = REAL_PLUGIN_DEPS;
+	return {
+		...real,
+		install: async (pluginId, scope) => setEnabled(scope, pluginId, true),
+		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: async (pluginId, scope) => setEnabled(scope, pluginId, false),
+		},
+	};
+}
+
+async function enabledIn(scope: Scope): Promise<Record<string, boolean>> {
+	const json = (await fs.readJson(settingsFor(scope))) as {
+		enabledPlugins?: Record<string, boolean>;
+	};
+	return json.enabledPlugins ?? {};
+}
+
+function profilesJson(): Promise<string> {
+	return fs.readFile(join(project, ".claude", "profiles.json"), "utf8");
+}
+
+async function profilePlugins(): Promise<Record<string, unknown>> {
+	const { profiles } = await readManifest(project);
+	return (profiles.team?.plugins ?? {}) as Record<string, unknown>;
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "tui-scope-profile-"));
+	home = await mkdtemp(join(tmpdir(), "tui-scope-profile-home-"));
+	process.env.HOME = home;
+	process.env.CLAUDE_CONFIG_DIR = join(home, ".claude");
+	log = spyOn(console, "log").mockImplementation(() => {});
+	await writeManifest(manifest(), project);
+	await activateProfile(manifest(), "team", project, { onDisplace: () => {} });
+});
+
+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("Plugins screen scope actions record the change in the active profile", () => {
+	test("PROJECT install: the profile lists the plugin, and nothing is left to absorb", async () => {
+		await installPluginInScope("aside@magus", "project", project, deps());
+		expect(await enabledIn("project")).toHaveProperty("aside@magus", true);
+
+		expect(await profilePlugins()).toHaveProperty("aside@magus");
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("PROJECT uninstall: the profile drops the plugin, and nothing is left to absorb", async () => {
+		await uninstallPluginInScope(
+			"terminal@magus",
+			"project",
+			project,
+			deps(),
+			"team",
+		);
+
+		expect(await profilePlugins()).not.toHaveProperty("terminal@magus");
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("USER install: the profile is left as it was", async () => {
+		const before = await fs.readFile(
+			join(project, ".claude", "profiles.json"),
+			"utf8",
+		);
+
+		await installPluginInScope("aside@magus", "user", project, deps());
+		expect(await enabledIn("user")).toHaveProperty("aside@magus", true);
+
+		expect(
+			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
+		).toBe(before);
+		expect(await profilePlugins()).not.toHaveProperty("aside@magus");
+	});
+
+	test("LOCAL install: the private install never reaches the shared profile", async () => {
+		const before = await profilesJson();
+
+		await installPluginInScope("aside@magus", "local", project, deps());
+		expect(await enabledIn("local")).toHaveProperty("aside@magus", true);
+
+		expect(await profilesJson()).toBe(before);
+		expect(await profilePlugins()).not.toHaveProperty("aside@magus");
+	});
+
+	test("PROJECT install under CLI bookkeeping: the profile is left to the wrapper", async () => {
+		const marker = await readActiveMarker(project);
+		if (!marker) throw new Error("activation wrote no marker");
+		await writeActiveMarker({ ...marker, cliBookkeeping: true }, project);
+		const before = await profilesJson();
+
+		await installPluginInScope("aside@magus", "project", project, deps());
+		expect(await enabledIn("project")).toHaveProperty("aside@magus", true);
+
+		expect(await profilesJson()).toBe(before);
+		expect((await readActiveMarker(project))?.cliBookkeeping).toBe(true);
+	});
+
+	test("PROJECT update of a declared plugin: nothing new is recorded", async () => {
+		const before = await profilesJson();
+		const updating: PluginApplyDeps = {
+			...deps(),
+			// `claude plugin update` rewrites the scope's settings.json; the
+			// plugin stays enabled.
+			update: async (pluginId, scope) => setEnabled(scope, pluginId, true),
+		};
+
+		await updatePluginInScope("dev@magus", "project", project, updating);
+
+		expect(await profilesJson()).toBe(before);
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines).toEqual([]);
+	});
+
+	test("an unreadable live file: the install is reported done, the profile record refused", async () => {
+		const broken: PluginApplyDeps = {
+			...deps(),
+			install: async (pluginId, scope) => {
+				await setEnabled(scope, pluginId, true);
+				await fs.appendFile(settingsFor(scope), "{ not json");
+			},
+		};
+
+		await expect(
+			installPluginInScope("aside@magus", "project", project, broken),
+		).rejects.toThrow(
+			"installed at PROJECT scope, but the profile does not record it",
+		);
+	});
+});

package/src/services/update-engine.ts

@@ -267,6 +267,15 @@ export interface PluginApplyDeps {
 	 * that did not happen.
 	 */
 	remove?: PluginRemoveDeps;
+	/**
+	 * Absorb the live settings into the active profile and bring its record of
+	 * them forward (`recordScopeActionInProfile`). A Plugins-screen scope action
+	 * writes the live settings itself, through the `claude` CLI, so the profile
+	 * must record it at once — otherwise the next magus command absorbs it as an
+	 * edit the user made by hand. Optional so a double that does not model
+	 * profiles skips it.
+	 */
+	recordInProfile?: (projectPath: string) => Promise<void>;
 }
 
 /** The three calls a `remove` makes — see {@link applyRemove}. */
@@ -395,6 +404,7 @@ export const REAL_PLUGIN_DEPS: PluginApplyDeps = {
 		return Array.isArray(rows) ? rows : [];
 	},
 	remove: REAL_REMOVE_DEPS,
+	recordInProfile: recordScopeActionInProfile,
 };
 
 /**
@@ -1084,6 +1094,53 @@ export async function removeDeprecatedPlugin(
 	return { problems, unlistedFrom: unlisted.unlistedFrom };
 }
 
+/**
+ * Is a `withCliBookkeeping` run (`magus update`) in progress here? Its wrapper
+ * reconciles before it renders, so a reconcile inside the run would write a
+ * fresh marker, clear the bookkeeping flag, and turn the CLI's own install
+ * records into edits the user made.
+ */
+async function underCliBookkeeping(projectPath: string): Promise<boolean> {
+	const marker = (await hasCurrentMarker(projectPath))
+		? await readActiveMarker(projectPath)
+		: null;
+	return marker?.cliBookkeeping === true;
+}
+
+/**
+ * Absorb the live settings into the active profile after a Plugins-screen
+ * scope action, so the profile lists what the `claude` CLI just turned on or
+ * off and its record of the live files matches them. A no-op when the live
+ * files did not change or no profile is active, and left to the wrapper under
+ * {@link underCliBookkeeping}. Refuses, writing nothing, on an unreadable live
+ * file.
+ *
+ * The reconcile absorbs every pending edit to the live config, not only this
+ * action's own change, exactly as the next magus command would. The TUI shows
+ * no status for what it recorded.
+ */
+async function recordScopeActionInProfile(projectPath: string): Promise<void> {
+	if (await underCliBookkeeping(projectPath)) return;
+	refuseOnProblems(await reconcileActiveProfile(projectPath));
+}
+
+/**
+ * Run `deps.recordInProfile`, rethrowing a failure as one that says the action
+ * itself happened: the plugin is installed or removed, only the profile lags.
+ */
+async function recordInProfileOrExplain(
+	deps: PluginApplyDeps,
+	projectPath: string,
+	done: string,
+): Promise<void> {
+	try {
+		await deps.recordInProfile?.(projectPath);
+	} catch (error) {
+		const why = error instanceof Error ? error.message : String(error);
+		throw new Error(`${done}, but the profile does not record it: ${why}`);
+	}
+}
+
 /**
  * Stop EVERY profile in the project listing a deprecated plugin, keeping the
  * user's live edits — the profile half of both removals, {@link applyRemove}
@@ -1114,10 +1171,7 @@ async function unlistFromEveryProfile(
 	const problems: unknown[] = [];
 	const unlistedFrom: string[] = [];
 	try {
-		const marker = (await hasCurrentMarker(projectPath))
-			? await readActiveMarker(projectPath)
-			: null;
-		const wrapperReconciles = marker?.cliBookkeeping === true;
+		const wrapperReconciles = await underCliBookkeeping(projectPath);
 		// Refuses, writing nothing, on an unreadable live file.
 		if (!wrapperReconciles) {
 			refuseOnProblems(await reconcileActiveProfile(projectPath));
@@ -1321,6 +1375,7 @@ export async function applyPlugins(
  */
 async function applyOneInScope(
 	run: (pluginId: string, scope: PluginScope) => Promise<void>,
+	verb: "installed" | "updated",
 	pluginId: string,
 	scope: PluginScope,
 	projectPath: string,
@@ -1338,6 +1393,11 @@ async function applyOneInScope(
 			throw new Error(describeLoadNotForward(forward));
 		}
 	}
+	await recordInProfileOrExplain(
+		deps,
+		projectPath,
+		`${verb} at ${scope.toUpperCase()} scope`,
+	);
 	return actual;
 }
 
@@ -1359,7 +1419,14 @@ export async function installPluginInScope(
 	projectPath: string,
 	deps: PluginApplyDeps = REAL_PLUGIN_DEPS,
 ): Promise<string | null> {
-	return applyOneInScope(deps.install, pluginId, scope, projectPath, deps);
+	return applyOneInScope(
+		deps.install,
+		"installed",
+		pluginId,
+		scope,
+		projectPath,
+		deps,
+	);
 }
 
 /**
@@ -1381,6 +1448,7 @@ export async function updatePluginInScope(
 		async (id, sc) => {
 			await advanceInScope(deps, id, sc, projectPath);
 		},
+		"updated",
 		pluginId,
 		scope,
 		projectPath,
@@ -1454,12 +1522,13 @@ export async function uninstallPluginInScope(
 			break;
 		}
 	}
-	if (scope !== "project" && !installedNowhere) return;
-	if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
-		throw new Error(
-			`uninstalled at ${scope.toUpperCase()} scope, but the profile still lists it`,
-		);
+	const done = `uninstalled at ${scope.toUpperCase()} scope`;
+	if (scope === "project" || installedNowhere) {
+		if (!(await remove.dropFromProfile(pluginId, projectPath, profile))) {
+			throw new Error(`${done}, but the profile still lists it`);
+		}
 	}
+	await recordInProfileOrExplain(deps, projectPath, done);
 }
 
 // -- binaries ----------------------------------------------------------------