magus-cli 7.11.3 → 7.11.5

package/src/services/resolver.ts

@@ -285,6 +285,37 @@ export function resolveExtends(
 	};
 }
 
+/** Whether a profile entry, `extends` included, turns the plugin on. */
+export function profileLists(
+	entry: ProfileManifestEntry | undefined,
+	pluginId: string,
+): boolean {
+	if (!entry) return false;
+	const value = resolveExtends(entry).plugins?.[pluginId];
+	return value !== undefined && value !== false;
+}
+
+/**
+ * Every plugin id some profile in the manifest turns on, `extends` included —
+ * by {@link profileLists}, the test a removal uses to find the profiles it
+ * must edit.
+ *
+ * The planner's view of the profiles that are NOT active. The render writes
+ * `false` for each of these into the live settings.json, so a deprecated one
+ * shows as a row on the Plugins screen even though the active profile never
+ * names it; `magus update` and the screen both pass this set to the planner,
+ * which is how such a plugin gets planned for removal at all.
+ */
+export function pluginsAnyProfileLists(manifest: ProfileManifest): string[] {
+	const out = new Set<string>();
+	for (const entry of Object.values(manifest.profiles)) {
+		for (const pluginId of Object.keys(resolveExtends(entry).plugins ?? {})) {
+			if (profileLists(entry, pluginId)) out.add(pluginId);
+		}
+	}
+	return [...out];
+}
+
 /** The pin a selected requirement installs at, if its chosen option carries one. */
 export function pinOfBin(bin: SelectedBin): string | undefined {
 	const option = bin.chosen;

package/src/services/update-engine.ts

@@ -57,6 +57,7 @@ import {
 	inheritedRowsOf,
 	loadedVersionHere,
 	notDownloadedReason,
+	readInheritedRegistryRows,
 	readInstalledPluginsRegistry,
 	repairStaleLoad,
 	rowBelongsToRepository,
@@ -69,9 +70,15 @@ import {
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
 } from "./plugin-manager.js";
-import { activeProfile } from "./profile-live.js";
+import { reconcileActiveProfile, refuseOnProblems } from "./profile-absorb.js";
+import { regenerateLiveFiles } from "./profile-activate.js";
+import {
+	activeProfile,
+	hasCurrentMarker,
+	readActiveMarker,
+} from "./profile-live.js";
 import { removePluginFromProfile } from "./profile-state.js";
-import { profileDependentsOf } from "./resolver.js";
+import { profileDependentsOf, profileLists } from "./resolver.js";
 import { installSkill } from "./skills-manager.js";
 import {
 	type ToolFacts,
@@ -296,6 +303,17 @@ export interface PluginRemoveDeps {
 		projectPath: string,
 		profile: string | null | undefined,
 	) => Promise<boolean>;
+	/**
+	 * Stop EVERY profile listing a deprecated plugin, the live files absorbed
+	 * first (`unlistFromEveryProfile`); answers whether none lists it, read
+	 * back, and throws the first failure. What {@link applyRemove} runs in
+	 * place of `dropFromProfile` when present. Optional so a double that models
+	 * one profile keeps doing it through `dropFromProfile`.
+	 */
+	unlistEverywhere?: (
+		pluginId: string,
+		projectPath: string,
+	) => Promise<boolean>;
 	/**
 	 * Clear magus's OWN `installedPluginVersions` claim for the plugin at a
 	 * scope it was removed from (`forgetInstalledPluginVersion`). Claude Code
@@ -338,6 +356,12 @@ export const REAL_REMOVE_DEPS: PluginRemoveDeps = {
 		(await enabledAt(scope, projectPath))[pluginId] === true,
 	dropFromProfile: (pluginId, projectPath, profile) =>
 		removePluginFromProfile(projectPath, pluginId, profile),
+	unlistEverywhere: async (pluginId, projectPath) => {
+		const { problems } = await unlistFromEveryProfile(pluginId, projectPath);
+		if (problems.length > 0) throw problems[0];
+		const { profiles } = await readManifest(projectPath);
+		return !Object.values(profiles).some((e) => profileLists(e, pluginId));
+	},
 	forgetVersion: forgetInstalledPluginVersion,
 	// The profile picked as `removePluginFromProfile` picks it, so the check and
 	// the drop judge the same profile. A parse error throws, as it does there.
@@ -856,13 +880,14 @@ async function applyStaleLoad(
  * Remove ONE deprecated plugin — the `remove` half of {@link applyPlugins}.
  *
  * Uninstalls it at every scope the plan found it installed at, through the
- * Claude Code CLI wrapper, then stops the profile listing it. Both halves run
- * even when the first fails part-way: a profile that keeps a plugin no
- * marketplace publishes only ever asks for an install that cannot happen.
+ * Claude Code CLI wrapper, then stops every profile listing it
+ * (`unlistEverywhere`). Both halves run even when the first fails part-way: a
+ * profile that keeps a plugin no marketplace publishes only ever asks for an
+ * install that cannot happen.
  *
  * Success is READ BACK, never "the calls returned": installed at no scope here
- * afterwards — all three are checked, not just the planned ones — and the
- * profile no longer lists it.
+ * afterwards — all three are checked, not just the planned ones — and no
+ * profile lists it.
  */
 async function applyRemove(
 	item: PluginUpdateItem,
@@ -914,11 +939,11 @@ async function applyRemove(
 				inheritedError ??= error;
 			}
 		}
-		const unlisted = await remove.dropFromProfile(
-			item.pluginId,
-			projectPath,
-			profile,
-		);
+		// Every profile that lists it, or one left listing it brings the row back
+		// on the next render.
+		const unlisted = remove.unlistEverywhere
+			? await remove.unlistEverywhere(item.pluginId, projectPath)
+			: await remove.dropFromProfile(item.pluginId, projectPath, profile);
 
 		const still: PluginScope[] = [];
 		for (const scope of REMOVE_SCOPES) {
@@ -1007,6 +1032,115 @@ async function applyRemove(
 /** Every scope a removal must leave the plugin uninstalled at. */
 const REMOVE_SCOPES: readonly PluginScope[] = ["user", "project", "local"];
 
+/**
+ * Remove an orphan the plan holds no `remove` item for — the Plugins screen's
+ * `d` on a row the planner keeps rather than removes: it moved to another
+ * marketplace, another plugin still requires it, or its marketplace was not
+ * read. The user asked for it gone, so it goes.
+ *
+ * Uninstalls at every scope here, then each inherited row from its own folder,
+ * then {@link unlistFromEveryProfile}: a key the render writes `false` for is
+ * cleared only once no profile lists the id.
+ *
+ * `problems` holds every real failure; the CLI's "nothing at this scope here"
+ * answer is not one. `unlistedFrom` names the profiles that listed it.
+ */
+export async function removeDeprecatedPlugin(
+	pluginId: string,
+	projectPath: string,
+	deps: {
+		uninstall?: (id: string, scope: PluginScope, cwd: string) => Promise<void>;
+		inheritedRows?: (
+			id: string,
+			projectPath: string,
+		) => Promise<InstalledPluginEntry[]>;
+	} = {},
+): Promise<{ problems: unknown[]; unlistedFrom: string[] }> {
+	const uninstall = deps.uninstall ?? uninstallPluginViaCli;
+	const inheritedRows = deps.inheritedRows ?? readInheritedRegistryRows;
+	const problems: unknown[] = [];
+	const unlistedFrom: string[] = [];
+
+	for (const scope of REMOVE_SCOPES) {
+		try {
+			await uninstall(pluginId, scope, projectPath);
+		} catch (error) {
+			if (!isNotInstalledAnswer(error)) problems.push(error);
+		}
+	}
+	// A folder of the same repository may hold the install this one only
+	// shows: the CLI removes it only when run from that folder.
+	for (const row of await inheritedRows(pluginId, projectPath)) {
+		if (!row.projectPath) continue;
+		try {
+			await uninstall(pluginId, row.scope, row.projectPath);
+		} catch (error) {
+			problems.push(error);
+		}
+	}
+
+	const unlisted = await unlistFromEveryProfile(pluginId, projectPath);
+	problems.push(...unlisted.problems);
+	return { problems, unlistedFrom: unlisted.unlistedFrom };
+}
+
+/**
+ * Stop EVERY profile in the project listing a deprecated plugin, keeping the
+ * user's live edits — the profile half of both removals, {@link applyRemove}
+ * (`magus update`, the Plugins screen's `a` and `d`) and
+ * {@link removeDeprecatedPlugin}.
+ *
+ * Every profile, not only the active one: the render writes `false` for each
+ * id ANY profile lists, so one profile left listing it brings the row back on
+ * the next render. A deprecated plugin can never be installed, so no profile
+ * loses anything it could use.
+ *
+ * The live files are absorbed into the active profile BEFORE any profile is
+ * written, and rendered again after, so what Claude Code or the user wrote
+ * since the last render survives and the id's key is gone. Under
+ * `withCliBookkeeping` (`magus update`) both are left to the wrapper, whose
+ * reconcile absorbs before it renders: reconciling here would write a fresh
+ * marker mid-run, clearing the bookkeeping flag, so the installs that follow
+ * would read as the user's own edits.
+ *
+ * `unlistedFrom` names the profiles that listed it, each READ BACK as no longer
+ * listing it; `problems` holds every failure, a refused reconcile included,
+ * in which case nothing was written.
+ */
+async function unlistFromEveryProfile(
+	pluginId: string,
+	projectPath: string,
+): Promise<{ problems: unknown[]; unlistedFrom: string[] }> {
+	const problems: unknown[] = [];
+	const unlistedFrom: string[] = [];
+	try {
+		const marker = (await hasCurrentMarker(projectPath))
+			? await readActiveMarker(projectPath)
+			: null;
+		const wrapperReconciles = marker?.cliBookkeeping === true;
+		// Refuses, writing nothing, on an unreadable live file.
+		if (!wrapperReconciles) {
+			refuseOnProblems(await reconcileActiveProfile(projectPath));
+		}
+		const manifest = await readManifest(projectPath);
+		for (const [id, entry] of Object.entries(manifest.profiles)) {
+			if (!profileLists(entry, pluginId)) continue;
+			if (await removePluginFromProfile(projectPath, pluginId, id)) {
+				unlistedFrom.push(id);
+			} else {
+				problems.push(
+					new Error(`the ${entry.name ?? id} profile still lists it`),
+				);
+			}
+		}
+		// Renders nothing, and answers false, when no profile is active.
+		if (!wrapperReconciles) await regenerateLiveFiles(projectPath);
+	} catch (error) {
+		problems.push(error);
+	}
+	return { problems, unlistedFrom };
+}
+
 /** Options for {@link applyPlugins}. */
 export interface ApplyPluginsOptions {
 	/**

package/src/services/update-plan.ts

@@ -879,6 +879,8 @@ export function classifyPlugin(
  * Every plugin the active profile declares, under its pin, and every plugin
  * installed in any scope (user, project, local), under "latest" — the rule
  * {@link pinForRow} states — each classified by {@link classifyPlugin}, sorted.
+ * A plugin only other profiles list joins the plan only to be removed, when it
+ * is deprecated ({@link onlyOtherProfilesList}).
  *
  * ONE list, read by both surfaces: the screen's rows, header counts and
  * "update all", and the CLI's report and apply. It used to be two — the CLI
@@ -891,11 +893,16 @@ export function classifyPlugin(
  * @param catalog    getAvailablePlugins() output — keyed by id, or as a list
  * @param requiredBy closure.dependencies?.requiredBy — which plugin needs each
  *                   dependency the profile does not name itself
+ * @param listedByProfiles every plugin id ANY profile in the manifest lists
+ *                   (`pluginsAnyProfileLists`). One neither pinned nor
+ *                   installed is planned only as a deprecated `remove`; see
+ *                   {@link onlyOtherProfilesList}.
  */
 export function planPluginUpdates(
 	pinned: Readonly<Record<string, string>>,
 	catalog: ReadonlyMap<string, PluginInfo> | readonly PluginInfo[],
 	requiredBy: RequiredBy = {},
+	listedByProfiles: readonly string[] = [],
 ): PluginUpdateItem[] {
 	const index = indexCatalog(catalog);
 	const plugins =
@@ -908,13 +915,42 @@ export function planPluginUpdates(
 		const pin = pinForRow(info, pinned);
 		if (pin !== null) pins.set(info.id, pin);
 	}
+	const othersOnly = new Set<string>();
+	for (const pluginId of listedByProfiles) {
+		if (pins.has(pluginId)) continue;
+		othersOnly.add(pluginId);
+		pins.set(pluginId, "latest");
+	}
 	return settleDeprecated(
 		[...pins].map(([pluginId, pin]) =>
 			classifyPlugin(pluginId, pin, index, requiredBy),
 		),
 		index,
 		requiredBy,
-	).sort((a, b) => a.pluginId.localeCompare(b.pluginId));
+	)
+		.filter(
+			(item) => !othersOnly.has(item.pluginId) || onlyOtherProfilesList(item),
+		)
+		.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
+}
+
+/**
+ * The one item a plugin gets when only profiles that are NOT active list it,
+ * and nothing here installs it: a deprecated `remove`.
+ *
+ * The render writes `false` for it into the live settings.json, so the Plugins
+ * screen shows it as a row, and a profile that keeps a plugin no marketplace
+ * publishes only ever asks for an install that cannot happen. Removing it here
+ * drops it from every profile that lists it, which is what clears the row.
+ *
+ * Anything else — published, moved, still required, a marketplace we did not
+ * read — is no work of this profile's: it is not active, so nothing is
+ * installed, updated or kept for it, and it gets no item at all. Judged after
+ * {@link settleDeprecated}, so retired plugins that only require each other are
+ * still removed together.
+ */
+function onlyOtherProfilesList(item: PluginUpdateItem): boolean {
+	return item.action === "remove" && item.reason === "deprecated";
 }
 
 /**
@@ -951,9 +987,13 @@ export function classifyPluginRows(
 	plugins: readonly PluginInfo[],
 	pins: Readonly<Record<string, string>>,
 	requiredBy: RequiredBy = {},
+	listedByProfiles: readonly string[] = [],
 ): Map<string, PluginUpdateItem> {
 	return new Map(
-		planPluginUpdates(pins, plugins, requiredBy).map((i) => [i.pluginId, i]),
+		planPluginUpdates(pins, plugins, requiredBy, listedByProfiles).map((i) => [
+			i.pluginId,
+			i,
+		]),
 	);
 }
 

package/src/ui/screens/PluginsScreen.tsx

@@ -9,14 +9,8 @@ import {
 	type PluginScope,
 	addMarketplace as cliAddMarketplace,
 	repairPlugin as cliRepairPlugin,
-	isNotInstalledAnswer,
-	uninstallPluginViaCli,
 } from "../../services/claude-cli.js";
-import {
-	readInheritedRegistryRows,
-	readSettings,
-	setMcpEnvVar,
-} from "../../services/claude-settings.js";
+import { readSettings, setMcpEnvVar } from "../../services/claude-settings.js";
 import { clearContentDriftCache } from "../../services/content-drift.js";
 import { missingPluginEnvVars } from "../../services/plugin-env-needs.js";
 import {
@@ -49,6 +43,7 @@ import {
 	applyPlugins,
 	installPluginInScope,
 	pluginNeedsWork,
+	removeDeprecatedPlugin,
 	uninstallPluginInScope,
 	updatePluginInScope,
 } from "../../services/update-engine.js";
@@ -176,6 +171,14 @@ export function PluginsScreen() {
 	const [requiredBy, setRequiredBy] = useState<
 		Readonly<Record<string, readonly string[]>>
 	>({});
+	/**
+	 * Every plugin any profile lists — the same set `magus update` plans with,
+	 * so a deprecated plugin only another profile keeps is a `remove` row here
+	 * and a removal there.
+	 */
+	const [listedByProfiles, setListedByProfiles] = useState<readonly string[]>(
+		[],
+	);
 
 	// Fetch data (always fetches all scopes). Only the most recently started
 	// load may touch the screen.
@@ -209,6 +212,7 @@ export function PluginsScreen() {
 			setPins(active?.closure.plugins ?? null);
 			setActiveProfileId(active?.profileId ?? null);
 			setRequiredBy(required);
+			setListedByProfiles(active?.listedByProfiles ?? []);
 
 			// Which catalogs answered, and which only appeared to. Read straight
 			// after the fetch, while the record still describes this attempt.
@@ -300,9 +304,14 @@ export function PluginsScreen() {
 	const statuses = useMemo(
 		(): Map<string, PluginUpdateItem> =>
 			shownPlugins
-				? classifyPluginRows(shownPlugins, pins ?? {}, requiredBy)
+				? classifyPluginRows(
+						shownPlugins,
+						pins ?? {},
+						requiredBy,
+						listedByProfiles,
+					)
 				: new Map(),
-		[shownPlugins, pins, requiredBy],
+		[shownPlugins, pins, requiredBy, listedByProfiles],
 	);
 
 	/**
@@ -1265,39 +1274,16 @@ export function PluginsScreen() {
 			return;
 		}
 
-		// Errors are collected, not dropped: only the CLI's "is not installed in
-		// <scope> scope" answer is expected, and only for a scope with no row.
-		const problems: unknown[] = [];
+		// An orphan the plan keeps rather than removes — it moved, another plugin
+		// still requires it, or its marketplace was not read — and the user asked
+		// for it gone. The engine uninstalls everywhere, drops it from every
+		// profile and renders the active one again, so the row does not come back.
 		try {
-			// Remove from all scopes — try all to clean up stale references
-			const scopes: PluginScope[] = ["user", "project", "local"];
-			for (const scope of scopes) {
-				try {
-					modal.loading(
-						`Removing ${plugin.name} from ${scope}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
-					);
-					await uninstallPluginViaCli(plugin.id, scope, state.projectPath);
-				} catch (error) {
-					if (!isNotInstalledAnswer(error)) problems.push(error);
-				}
-			}
-			// A folder of the same repository may hold the install this one only
-			// shows: the CLI removes it only when run from that folder.
-			const inherited = await readInheritedRegistryRows(
+			modal.loading(`Removing ${plugin.name}…`);
+			const { problems } = await removeDeprecatedPlugin(
 				plugin.id,
 				state.projectPath || process.cwd(),
 			);
-			for (const row of inherited) {
-				if (!row.projectPath) continue;
-				try {
-					modal.loading(
-						`Removing ${plugin.name} from the repository's main folder, which this folder shares…\nclaude plugin uninstall ${plugin.id} --scope ${row.scope}`,
-					);
-					await uninstallPluginViaCli(plugin.id, row.scope, row.projectPath);
-				} catch (error) {
-					problems.push(error);
-				}
-			}
 
 			modal.hideModal();
 			fetchData();