magus-cli 7.0.0 → 7.2.0

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/screens/ProfilesScreen.tsx

@@ -190,7 +190,7 @@ export function ProfilesScreen() {
 				? "~/.claude/settings.json"
 				: ".claude/settings.json";
 
-		const pluginCount = Object.keys(selectedProfile.plugins).length;
+		const pluginCount = Object.keys(selectedProfile.plugins ?? {}).length;
 		const emptyWarning =
 			pluginCount === 0
 				? "\n\nWARNING: This profile has no plugins — applying will disable all plugins."

package/src/ui/state/types.ts

@@ -12,6 +12,7 @@ import type {
 	ProfileEntry,
 	SkillInfo,
 } from "../../types/index.js";
+import type { ReportBadgeKind } from "../theme-mode.js";
 
 // ============================================================================
 // Route Types
@@ -76,6 +77,13 @@ export interface SelectOption {
 	label: string;
 	value: string;
 	description?: string;
+	/**
+	 * A chip for a discrete state — dark ink on a saturated fill, the shape the
+	 * report already uses. Optional because most selects have no state to say.
+	 */
+	badge?: { label: string; kind: ReportBadgeKind };
+	/** Dim trailing detail — chrome, never the thing being chosen. */
+	meta?: string;
 }
 
 export type ModalState =
@@ -102,6 +110,16 @@ export type ModalState =
 			defaultIndex?: number;
 			onSelect: (value: string) => void;
 			onCancel: () => void;
+			/**
+			 * False for a question that must be answered.
+			 *
+			 * Only changes what the footer PROMISES; `onCancel` decides what Escape
+			 * actually does. The two must agree, and they did not: the profile gate's
+			 * `onCancel` is a no-op, so the footer's "esc cancel" was an instruction
+			 * that did nothing when followed — worse than no hint, because the user
+			 * concludes the app is stuck rather than that the question is required.
+			 */
+			cancellable?: boolean;
 	  }
 	| {
 			type: "message";

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;
@@ -308,6 +396,60 @@ export function trackFill(): string {
 	return TRACK_FILL[detected];
 }
 
+/**
+ * A key hint drawn as ONE two-tone chip: the key on a brighter fill, its label
+ * on a quieter fill of the same hue, butted together with no gap.
+ *
+ * Two halves rather than a chip plus loose text, because a bare label beside a
+ * filled key reads as prose that happens to follow a badge. Both halves filled
+ * makes the pair one object, and the brightness step inside it says which half
+ * you press.
+ *
+ * GREY, and no hue at all. Two earlier passes both failed by colouring it: the
+ * first gave `↵` the info blue and `esc` the danger red, which read as a traffic
+ * light — three saturated chips of unrelated meaning, none of them signalling
+ * anything, since `esc` is not dangerous, it is the way out. The second made all
+ * three magus purple, which stopped lying but competed with the selected row's
+ * purple fill directly above it, so the two most prominent things in the dialog
+ * were the same colour and the eye had nowhere to land.
+ *
+ * A key hint is chrome. It says "these are keys" and nothing more, so it earns
+ * no hue — leaving the dialog exactly one accent, on the row you are choosing.
+ * The two halves separate by INTENSITY: the key steps toward the foreground,
+ * the label sits near the page.
+ *
+ * Both pages are built from the greys already in this file — the light label is
+ * `SCOPE_OFF_FILL.light`, the dark key is `TRACK_FILL.dark` — so the footer sits
+ * in the same neutral family as every other quiet fill rather than introducing a
+ * third grey ramp.
+ */
+const HINT_CHIP = {
+	light: {
+		keyBg: "#B4B4A6",
+		keyFg: "#1F1F1A",
+		labelBg: "#D9D9CC",
+		labelFg: "#44443D",
+	},
+	dark: {
+		keyBg: "#6E6E7A",
+		keyFg: "#FBFBFD",
+		labelBg: "#44444E",
+		labelFg: "#D6D6DE",
+	},
+} as const;
+
+export interface HintChipInk {
+	keyBg: string;
+	keyFg: string;
+	labelBg: string;
+	labelFg: string;
+}
+
+/** The two-tone key-hint chip, for the resolved mode. */
+export function hintChip(): HintChipInk {
+	return HINT_CHIP[detected];
+}
+
 /**
  * Effort's colour ramp — TEXT only, never a fill, so a row never paints two blocks.
  *

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();
-	});
-});