magus-cli 7.0.0 → 7.1.0

package/src/services/marketplace-refresh.ts

@@ -36,17 +36,6 @@ export interface RefreshResult {
 	failed: string[];
 	/** Nothing to do: no clone on disk, not a git repo, or dirty tree. */
 	skipped: string[];
-	/**
-	 * Skipped specifically because `autoUpdate: false` in known_marketplaces.json.
-	 *
-	 * Called out separately from `skipped` because the consequence is invisible
-	 * and open-ended: the clone is the catalog, so a marketplace opted out here
-	 * never learns about new plugin versions, and every plugin from it reads as
-	 * up to date forever. The reporter's `magus` clone sat 11 days behind this
-	 * way — Claude Code would not refresh it, and this function skipped it too,
-	 * with nothing printed either time.
-	 */
-	autoUpdateDisabled: string[];
 }
 
 function cloneDir(name: string): string {
@@ -198,7 +187,6 @@ export async function refreshRegisteredMarketplaces(
 	const refreshed: string[] = [];
 	const failed: string[] = [];
 	const skipped: string[] = [];
-	const autoUpdateDisabled: string[] = [];
 
 	const configured = await getConfiguredMarketplaces();
 	const skipSet = new Set(skip);
@@ -211,8 +199,13 @@ export async function refreshRegisteredMarketplaces(
 			skipped.push(name);
 			continue;
 		}
+		// Claude Code's own refresh policy. Honour it by not pulling, and say
+		// nothing: the version answer does not come from this clone.
+		// `readCatalogFromRemote` reads `origin/<branch>` with fetch + show, never
+		// the working tree — measured, a clone holding dev 7.4.0 with autoUpdate
+		// off still reported 7.4.1 available.
 		if ((await getMarketplaceAutoUpdate(name)) === false) {
-			autoUpdateDisabled.push(name);
+			skipped.push(name);
 			continue;
 		}
 		eligible.push(name);
@@ -226,7 +219,6 @@ export async function refreshRegisteredMarketplaces(
 			refreshed: [],
 			failed: [],
 			skipped: [...skipped, ...eligible],
-			autoUpdateDisabled,
 		};
 	}
 
@@ -249,5 +241,5 @@ export async function refreshRegisteredMarketplaces(
 		else skipped.push(name); // absent | skipped
 	});
 
-	return { refreshed, failed, skipped, autoUpdateDisabled };
+	return { refreshed, failed, skipped };
 }

package/src/services/plugin-manager.ts

@@ -122,15 +122,6 @@ export interface PluginInfo {
 	 * a reinstall delivers the current content. See content-drift.ts.
 	 */
 	contentStale?: boolean;
-	/**
-	 * For an orphaned plugin: another configured marketplace that publishes a
-	 * plugin of the same name — i.e. it did not disappear, it moved.
-	 *
-	 * Splitting `magus` into `magus` + `magus-marketing` left video-editing and
-	 * image-generate installed under a namespace that no longer lists them. Rendered as bare "deprecated", the only offered action
-	 * was deletion, which silently drops a plugin that is still published.
-	 */
-	movedTo?: string;
 	/**
 	 * Set when this plugin's installed version changed since magus last
 	 * rendered it — including updates made by Claude Code or a direct CLI call
@@ -467,9 +458,6 @@ export async function getAvailablePlugins(
 		// Try to get plugin info from local marketplace cache (fallback)
 		const localMp = localMarketplaces.get(mpName);
 		const localPlugin = localMp?.plugins.find((p) => p.name === pluginName);
-		const movedTo = localPlugin
-			? undefined
-			: findPluginInOtherMarketplace(pluginName, mpName, localMarketplaces);
 
 		const latestVersion = localPlugin?.version || installedVersion || "unknown";
 		const description = localPlugin?.description || "Installed plugin";
@@ -486,7 +474,6 @@ export async function getAvailablePlugins(
 			installedVersion: installedVersion,
 			hasUpdate,
 			isOrphaned: true,
-			movedTo,
 			...scopeStatus,
 		});
 	}
@@ -495,24 +482,6 @@ export async function getAvailablePlugins(
 	return plugins;
 }
 
-/**
- * Find another configured marketplace that still publishes this plugin name.
- *
- * Answers "did it disappear, or did it move?" for an orphaned plugin, so the
- * UI can offer migration rather than only deletion.
- */
-function findPluginInOtherMarketplace(
-	pluginName: string,
-	currentMarketplace: string,
-	localMarketplaces: Map<string, LocalMarketplace>,
-): string | undefined {
-	for (const [name, mp] of localMarketplaces) {
-		if (name === currentMarketplace) continue;
-		if (mp.plugins.some((p) => p.name === pluginName)) return name;
-	}
-	return undefined;
-}
-
 /**
  * Is this plugin one whose files could have moved while its version did not?
  *

package/src/services/resolver.ts

@@ -19,7 +19,9 @@ import type {
 	ResolvedBin,
 	ResolvedClosure,
 } from "../types/index.js";
+import { readManifest } from "./manifest.js";
 import { resolvePluginBinRequirements } from "./plugin-requires.js";
+import { activeProfile } from "./symlink-manager.js";
 
 export interface ResolveOptions {
 	/**
@@ -190,6 +192,37 @@ export function withDerivedMarketplaces(
 	return out;
 }
 
+/**
+ * The active profile's plugin pins, or null when there is nothing to read.
+ *
+ * A convenience for callers that want the manifest's opinion but must never be
+ * blocked by it — the TUI above all. Every failure path answers null: no
+ * manifest file, no profiles in it, no active profile and more than one to
+ * choose from, an unresolvable profile. A project without a manifest is the
+ * normal case, not an error, and a broken one must not stop the plugin list
+ * from rendering.
+ *
+ * `magus update` deliberately does NOT use this: it needs to fail loudly
+ * when the profile is ambiguous, and to name the profile it resolved.
+ */
+export async function activeProfilePins(
+	projectPath?: string,
+): Promise<Record<string, string> | null> {
+	try {
+		const manifest = await readManifest(projectPath);
+		const ids = Object.keys(manifest.profiles);
+		if (ids.length === 0) return null;
+		const id =
+			(await activeProfile(projectPath)) ??
+			(ids.length === 1 ? ids[0] : undefined);
+		if (!id) return null;
+		const closure = await resolveProfile(manifest, id);
+		return closure.plugins;
+	} catch {
+		return null;
+	}
+}
+
 export async function resolveProfile(
 	manifest: ProfileManifest,
 	profileId: string,

package/src/services/update-plan.ts

@@ -68,16 +68,12 @@ export type PluginReason =
 	| "enabled-not-installed"
 	/** unknown: a marketplace we READ does not list it. */
 	| "not-offered"
-	/** unknown: installed, unlisted, and another marketplace publishes the name. */
-	| "moved"
 	/** unknown: installed, unlisted, and its marketplace contributed no listed ids. */
 	| "marketplace-unread"
 	/** unknown: the catalog fetch failed ("latest" pins only). */
 	| "catalog-unverified"
-	/** unknown: listed, but its marketplace publishes no version for it. */
+	/** current: listed, but its marketplace publishes no version to compare. */
 	| "no-published-version"
-	/** unknown: an installed scope cannot be ordered against the target. */
-	| "unorderable"
 	/** repair: files changed without a version bump. */
 	| "content-stale"
 	/** update: a scope is provably behind. */
@@ -182,16 +178,6 @@ export function scopesNeeding(
 		.map(([scope]) => scope);
 }
 
-/** True when some installed scope cannot be ordered against `target` at all. */
-function hasUnorderableScope(
-	info: PluginInfo | undefined,
-	target: string,
-): boolean {
-	return scopeVersions(info).some(
-		([, version]) => isBehind(target, version) === null,
-	);
-}
-
 /** The "@marketplace" suffix of an id, or null when it has none to reason about. */
 function marketplaceSuffix(id: string): string | null {
 	const at = id.indexOf("@");
@@ -373,13 +359,6 @@ export function classifyPlugin(
 			action: "unknown" as const,
 			scopes: [],
 		};
-		if (info?.movedTo) {
-			return {
-				...orphan,
-				reason: "moved",
-				note: `moved to ${info.movedTo}`,
-			};
-		}
 		if (index.marketplaceIsKnown(pluginId)) {
 			return {
 				...orphan,
@@ -424,22 +403,10 @@ export function classifyPlugin(
 		const deliverable = available ?? pin;
 		const needing = scopesNeeding(info, deliverable);
 
-		// The same "cannot tell is not current" rule as the "latest" path below.
 		// A scope that cannot be ordered against the deliverable contributes
-		// nothing to `needing`, and used to fall through to `current` here.
-		if (needing.length === 0 && hasUnorderableScope(info, deliverable)) {
-			return {
-				...base,
-				target: null,
-				action: "unknown",
-				reason: "unorderable",
-				scopes: [],
-				note:
-					available !== null
-						? `installed version cannot be compared with the published ${available}`
-						: `installed version cannot be compared with the pin ${pin}`,
-			};
-		}
+		// nothing to `needing` and lands on `current`. That is the decision: if we
+		// cannot compare, assume what is installed is the latest. See the "latest"
+		// path below for the same rule and what it costs.
 
 		const undeliverable = available !== null && available !== pin;
 		return {
@@ -488,47 +455,37 @@ export function classifyPlugin(
 		};
 	}
 
-	// Installed and listed, with nothing to compare against. The answer is
-	// `unknown` — "current" is a claim we cannot support — and the note must not
-	// confuse this with the withdrawn case (handled above as an orphan): it is
-	// still published, still installable; we simply have no number to compare.
-	// 278 of the 292 plugins in `claude-plugins-official` are in this state, so
-	// reporting them as "not offered by any configured marketplace" told the
-	// user their installed, working, currently-published plugin had been
-	// withdrawn.
+	// Installed and listed, with nothing to compare against — still published,
+	// still installable, we simply have no number. 278 of the 292 plugins in
+	// `claude-plugins-official` are in this state.
+	//
+	// By decision this is CURRENT: if we cannot compare, assume what is installed
+	// is the latest. It was `unknown`, which put a red badge and a sentence on a
+	// quarter of the report for a fact nobody can act on. The `reason` is kept so
+	// a caller can still tell this apart from a verified match; the note is not,
+	// because there is nothing to say.
 	if (!available) {
 		return {
 			...base,
-			target: null,
-			action: "unknown",
+			target: installed,
+			action: "current",
 			reason: "no-published-version",
 			scopes: [],
-			note: "its marketplace publishes no version for this plugin, so there is nothing to compare",
 		};
 	}
 
 	// Again per-scope, and only ever forward.
 	const needing = scopesNeeding(info, available);
 
-	// No scope is provably behind — but that is not the same as being current.
-	// `scopesNeeding` filters on `isBehind(...) === true`, so a scope whose
-	// version cannot be ordered against the catalog contributes nothing and
-	// would fall through to `current`, which is precisely the "cannot tell
-	// rendered as nothing wrong" this whole change removes.
+	// A scope whose version cannot be ordered against the catalog contributes
+	// nothing to `needing`, so it lands on `current`. That is the decision, not
+	// an oversight: if we cannot compare, assume the installed one is the latest.
 	//
-	// Real and measured: 21 registry rows carry the literal string "unknown"
-	// as their version, across 8 `@claude-plugins-official` ids. Against a
-	// semver catalog they are unorderable, so they land here every run.
-	if (needing.length === 0 && hasUnorderableScope(info, available)) {
-		return {
-			...base,
-			target: null,
-			action: "unknown",
-			reason: "unorderable",
-			scopes: [],
-			note: `installed version cannot be compared with the published ${available}`,
-		};
-	}
+	// What it costs, stated plainly: such a plugin can never report an update,
+	// and reads exactly like a verified-current one. What it buys: `--check` can
+	// pass at all. It used to fail forever on the 21 registry rows carrying the
+	// literal string "unknown" as their version, across 8
+	// `@claude-plugins-official` ids — a gate nothing could make green.
 
 	return {
 		...base,

package/src/ui/App.tsx

@@ -454,9 +454,6 @@ function AppContent({ onExit }: AppContentProps) {
 						}
 					}
 				}
-				if (recovery.enabledAutoUpdate.length > 0) {
-					parts.push(`auto-update: ${recovery.enabledAutoUpdate.join(", ")}`);
-				}
 				if (recovery.removed.length > 0) {
 					parts.push(`removed: ${recovery.removed.join(", ")}`);
 				}

package/src/ui/screens/PluginsScreen.tsx

@@ -1193,71 +1193,30 @@ export function PluginsScreen() {
 
 		const plugin = item.plugin;
 
-		// A plugin that moved marketplace is not deprecated — it is still
-		// published under a new namespace. Offering only "remove" silently drops
-		// something the user still wants (the magus → magus-marketing split left
-		// video-editing and image-generate in this state).
-		let migrateTo: string | undefined;
-		if (plugin.movedTo) {
-			const choice = await modal.select(
-				"Plugin moved",
-				`${plugin.name} is no longer published by "${plugin.marketplace}", but "${plugin.movedTo}" still publishes it.`,
-				[
-					{
-						label: `Migrate to ${plugin.name}@${plugin.movedTo}`,
-						value: "migrate",
-					},
-					{ label: "Remove it entirely", value: "remove" },
-				],
-			);
-			if (choice === null) return;
-			if (choice === "migrate") migrateTo = plugin.movedTo;
-		}
+		// No "it moved, migrate there?" branch. It offered to uninstall this
+		// plugin and install the same NAME from another marketplace, on the
+		// strength of a name match with no history behind it — and for
+		// `claudish`, dual-published to two marketplaces on purpose, the target
+		// was already installed. An orphan is removed; where else a name happens
+		// to appear is not this screen's guess to make.
 
 		try {
 			// Remove from all scopes — try all to clean up stale references
 			const scopes: PluginScope[] = ["user", "project", "local"];
-			const removedFrom: PluginScope[] = [];
+			// Nothing tallies which scopes actually held it. The migrate dialog
+			// that consumed that tally is gone with the `moved` inference, and
+			// collecting it for no reader is how a value goes stale unnoticed.
 			for (const scope of scopes) {
 				try {
 					modal.loading(
 						`Removing ${plugin.name} from ${scope}…\nclaude plugin uninstall ${plugin.id} --scope ${scope}`,
 					);
-					const wasInstalled =
-						scope === "user"
-							? plugin.userScope?.enabled
-							: scope === "project"
-								? plugin.projectScope?.enabled
-								: plugin.localScope?.enabled;
 					await cliUninstallPlugin(plugin.id, scope, state.projectPath);
-					if (wasInstalled) removedFrom.push(scope);
 				} catch {
 					// Ignore errors for scopes where it doesn't exist
 				}
 			}
 
-			if (migrateTo) {
-				// Reinstall under the new namespace in every scope it occupied, so
-				// the migration does not quietly change where the plugin is enabled.
-				const newId = `${plugin.name}@${migrateTo}`;
-				for (const scope of removedFrom.length > 0
-					? removedFrom
-					: ["project" as PluginScope]) {
-					modal.loading(
-						`Installing ${newId} (${scope})…\nclaude plugin install ${newId} --scope ${scope}`,
-					);
-					// The migrated id is a plugin magus has never recorded a
-					// version for, so going through the read-back is what stops the
-					// rename leaving it permanently version-less — a plugin with no
-					// recorded version never reports an available update.
-					await installPluginInScope(
-						newId,
-						scope,
-						state.projectPath || process.cwd(),
-					);
-				}
-			}
-
 			modal.hideModal();
 			fetchData();
 		} catch (error) {

package/src/ui/theme-mode.ts

@@ -269,6 +269,94 @@ export const MODEL_BADGE = {
 
 export type ModelBadgeKind = keyof typeof MODEL_BADGE;
 
+/**
+ * Fill, ink and page-text for the report's state badges — one set per page.
+ *
+ * Every value here is LIFTED from `MODEL_BADGE` above rather than invented, so
+ * the contrast measurements recorded there carry over. Ink on fill, and the
+ * page text on its own ground, both measured here:
+ *
+ *   update      `sonnet`    green      ink/fill 5.82 light, 4.80 dark
+ *                                      text 6.68 on cream, 9.44 on #1C1C1E
+ *   deprecated  `kangaroo`  red earth  label 4.86 light on its own bar
+ *   fix         `fable`     purple     label 4.86 light on its own bar
+ *
+ * `text` is the tone for a heading or glyph drawn ON THE PAGE, which is not the
+ * same question as ink on a fill: on cream it is the deep member of the family,
+ * on near-black the pale one. Using the fill for both put a mid-amber heading on
+ * a dark page, where it reads as dirt.
+ *
+ * Green, not ochre, because green is what an update wears elsewhere in magus
+ * and the report was the odd one out. It is a like-for-like swap inside the same
+ * measured system: the green fill separates from the page by 1.15 on cream and
+ * 3.42 on near-black, against the ochre's 1.15 and 3.32.
+ *
+ * Amber is NOT freed up by this — `unknown` still wears it, and that is the
+ * distinction worth keeping: green says "there is a newer version", amber says
+ * "we could not tell".
+ *
+ * Purple carries "fix required" because the warm band is spoken for and the
+ * measured set has no blue. Hue, not meaning — the badge says the word.
+ */
+const REPORT_BADGE = {
+	update: {
+		light: { fill: "#D6EEDD", ink: "#166534", text: "#166534" },
+		dark: { fill: "#12804F", ink: "#EFFFF6", text: "#4FD98F" },
+	},
+	deprecated: {
+		light: { fill: "#F6D6D0", ink: "#8E2F26", text: "#8E2F26" },
+		dark: { fill: "#A83A2E", ink: "#FFEFEC", text: "#E07A6C" },
+	},
+	fix: {
+		light: { fill: "#E9DCF5", ink: "#6B21A8", text: "#6B21A8" },
+		dark: { fill: "#7B4CD6", ink: "#F6F0FF", text: "#A87BE8" },
+	},
+} as const;
+
+export type ReportBadgeKind = keyof typeof REPORT_BADGE;
+
+export interface ReportInk {
+	/** The badge's fill. */
+	fill: string;
+	/** Ink for the word written on `fill`. */
+	ink: string;
+	/** The tone for a heading or glyph on the page itself. */
+	text: string;
+}
+
+/** Badge colours for one report state, for the resolved page. */
+export function reportBadge(kind: ReportBadgeKind): ReportInk {
+	return REPORT_BADGE[kind][detected];
+}
+
+/**
+ * The unfilled part of a bar — `░` — for the page this run resolved.
+ *
+ * A track is CHROME. It exists so the eye can see how long the bar could have
+ * been, and it must never compete with the fill. "Quiet" is only definable
+ * against a page, which is why this lives here and not beside the ramps.
+ *
+ * It was a single dark grey, `darken(brand.muted, 0.68)` = #222429, chosen
+ * against a near-black terminal and applied on both. MEASURED against the two
+ * reference grounds:
+ *
+ *              #222429 (was)     this table
+ *   dark       1.10:1  quiet     1.10:1  quiet
+ *   cream     14.54:1  LOUDEST   1.24:1  quiet
+ *
+ * 14.54:1 is higher contrast than the body text. On a light terminal the empty
+ * half of every step bar was the most prominent thing in the report — a dense
+ * stipple that read as hatched texture and buried a 1 ms step's actual fill.
+ * The light value steps from the page TOWARD `brand.muted` rather than scaling
+ * a grey, so it stays in the page's own hue instead of laying cold grey on warm
+ * cream.
+ */
+const BAR_TRACK = { light: "#E0E2C3", dark: "#222429" } as const;
+
+export function barTrack(): string {
+	return BAR_TRACK[detected];
+}
+
 export interface ModelInk {
 	bg: string;
 	fg: string;

package/src/utils/command-utils.ts

@@ -1,10 +1,6 @@
-import { execFile } from "node:child_process";
 import { constants, accessSync, statSync } from "node:fs";
 import { access, realpath } from "node:fs/promises";
 import { join } from "node:path";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
 
 /**
  * A command as an executable plus its already-separated arguments.
@@ -70,19 +66,28 @@ function quoteToken(token: string): string {
 }
 
 /**
- * Check if a command exists in PATH
- * Uses execFile (not exec) to avoid shell injection vulnerabilities
- * @param command - Command name to check
+ * Check if a command exists in PATH.
+ *
+ * Async only for its callers' sake — it spawns nothing. This used to run
+ * `execFileAsync("which", [command])`, a real `which(1)` process with no
+ * timeout, on every one of its dozen call sites. Answering "is bun on PATH?"
+ * does not need a process, and under load that process is what stalls:
+ * `detectToolchains` calls this per toolchain, and in a 103-file parallel test
+ * run the spawn queue backed up until the test failed at **20,007 ms** — after
+ * the per-test timeout had already been raised from 5s to 20s to accommodate
+ * the earlier 5s failures. Raising the limit moved the goalposts; removing the
+ * spawn removes the stall.
+ *
+ * {@link whichSync} is also STRICTER than `which(1)`, which is a bonus rather
+ * than a risk: it stats the candidate and checks the execute bit, so a dangling
+ * symlink answers null here instead of reporting the link's own path. That is
+ * the exact failure {@link resolveExecutable} was written to catch afterwards.
+ *
+ * @param command - Command name to check, or an explicit path
  * @returns Path to command if found, null otherwise
  */
 export async function which(command: string): Promise<string | null> {
-	try {
-		// Use execFile with argument array to prevent command injection
-		const { stdout } = await execFileAsync("which", [command]);
-		return stdout.trim() || null;
-	} catch {
-		return null;
-	}
+	return whichSync(command);
 }
 
 /**

package/src/__tests__/moved-marketplace.test.ts

@@ -1,86 +0,0 @@
-/**
- * An orphaned plugin that merely changed marketplace is not deprecated.
- *
- * Splitting `magus` into `magus` + `magus-marketing` left `video-editing@magus`
- * and `nanobanana@magus` installed under a namespace that no longer lists them. They rendered as bare
- * "deprecated", whose only action is deletion — which drops a plugin that is
- * still published, just under a different id.
- */
-
-import { describe, expect, test } from "bun:test";
-import type { LocalMarketplace } from "../services/local-marketplace.js";
-
-/**
- * Mirrors `findPluginInOtherMarketplace` in plugin-manager.ts, which is module
- * -private. Kept in lockstep with it; the behaviour, not the binding, is what
- * these tests pin.
- */
-function findPluginInOtherMarketplace(
-	pluginName: string,
-	currentMarketplace: string,
-	localMarketplaces: Map<string, LocalMarketplace>,
-): string | undefined {
-	for (const [name, mp] of localMarketplaces) {
-		if (name === currentMarketplace) continue;
-		if (mp.plugins.some((p) => p.name === pluginName)) return name;
-	}
-	return undefined;
-}
-
-const mp = (name: string, plugins: string[]): [string, LocalMarketplace] => [
-	name,
-	{
-		name,
-		description: "",
-		plugins: plugins.map((p) => ({
-			name: p,
-			version: "1.0.0",
-			description: "",
-		})),
-	},
-];
-
-describe("moved-marketplace detection", () => {
-	test("finds a plugin that moved to a sibling marketplace", () => {
-		const marketplaces = new Map([
-			mp("magus", ["dev", "terminal"]),
-			mp("magus-marketing", ["image-generate", "video-editing"]),
-		]);
-
-		expect(
-			findPluginInOtherMarketplace("video-editing", "magus", marketplaces),
-		).toBe("magus-marketing");
-	});
-
-	test("a genuinely retired plugin reports no destination", () => {
-		// `conductor` was removed at magus v8.0.0 and republished nowhere.
-		const marketplaces = new Map([
-			mp("magus", ["dev"]),
-			mp("magus-marketing", ["video-editing"]),
-		]);
-
-		expect(
-			findPluginInOtherMarketplace("conductor", "magus", marketplaces),
-		).toBeUndefined();
-	});
-
-	test("does not propose the marketplace it is already installed from", () => {
-		const marketplaces = new Map([mp("magus", ["dev"])]);
-		expect(findPluginInOtherMarketplace("dev", "magus", marketplaces)).toBe(
-			undefined,
-		);
-	});
-
-	test("a renamed plugin is not matched — the name is the identity", () => {
-		// nanobanana became image-generate. Names differ, so this correctly
-		// reports no destination rather than guessing at a rename.
-		const marketplaces = new Map([
-			mp("magus", ["dev"]),
-			mp("magus-marketing", ["image-generate"]),
-		]);
-
-		expect(
-			findPluginInOtherMarketplace("nanobanana", "magus", marketplaces),
-		).toBeUndefined();
-	});
-});