magus-cli 7.11.7 → 7.12.0

package/src/services/marketplace-refresh.ts

@@ -20,9 +20,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import { runBounded } from "../utils/spawn-bounded.js";
+import { parsePluginId } from "../utils/string-utils.js";
+import {
+	readCloneRefreshAge,
+	writeCloneRefreshed,
+} from "./catalog-cache-store.js";
 import {
 	getConfiguredMarketplaces,
 	getGlobalClaudeDir,
+	getGlobalEnabledPlugins,
 	getMarketplaceAutoUpdate,
 } from "./claude-settings.js";
 
@@ -37,10 +43,54 @@ export interface RefreshResult {
 	refreshed: string[];
 	/** Pull errored (network, diverged, timeout) — clone left intact and stale. */
 	failed: string[];
-	/** Nothing to do: no clone on disk, not a git repo, or dirty tree. */
+	/**
+	 * Not pulled because this machine already refreshed the clone successfully
+	 * within CATALOG_TTL_MS — by this project's run or any other.
+	 */
+	fresh: string[];
+	/**
+	 * Report-only: selected, and a writing run would pull it. Always empty when
+	 * the refresh actually ran.
+	 */
+	pending: string[];
+	/**
+	 * Not pulled, and not a failure: no installed plugin comes from it, not a
+	 * github source, autoUpdate off, no clone on disk, or dirty tree.
+	 */
 	skipped: string[];
 }
 
+export interface RefreshOptions {
+	/**
+	 * Plugin ids (`name@marketplace`) this run installs — the profile's
+	 * PROJECT/LOCAL set. Unioned with every plugin installed at USER scope;
+	 * a marketplace none of them comes from is not pulled.
+	 */
+	pluginIds?: Iterable<string>;
+	/** Clock seam for the once-an-hour rule. */
+	now?: number;
+}
+
+/**
+ * The marketplaces some installed plugin comes from: the ones passed in
+ * (PROJECT/LOCAL, from the profile) plus every plugin turned on at USER scope.
+ * A USER entry set to `false` is not installed and does not count.
+ */
+async function neededMarketplaces(
+	pluginIds: Iterable<string>,
+): Promise<Set<string>> {
+	const ids = [...pluginIds];
+	for (const [id, on] of Object.entries(await getGlobalEnabledPlugins())) {
+		if (on === true) ids.push(id);
+	}
+	const needed = new Set<string>();
+	for (const id of ids) {
+		const parsed = parsePluginId(id);
+		if (parsed) needed.add(parsed.marketplace);
+	}
+	return needed;
+}
+
 function cloneDir(name: string): string {
 	return path.join(getGlobalClaudeDir(), "plugins", "marketplaces", name);
 }
@@ -170,46 +220,62 @@ function tap(fn: (() => void) | undefined): void {
 	}
 }
 
-/**
- * Non-destructively fast-forward the on-disk clone of every registered,
- * auto-update-enabled, github-sourced marketplace.
- *
- * @param skip marketplaces already refreshed this run (e.g. re-registered ones),
- *   so they aren't pulled twice.
- * @param progress optional taps for a live progress display.
- * @returns which marketplaces were refreshed, which failed (clone left intact),
- *   and which were skipped. Failures and skips are collected rather than thrown —
- *   one unreachable marketplace must not block launching Claude. Pulls run
- *   concurrently, so a slow one doesn't serialize the rest onto the launch path.
- */
 /**
  * Select and report, writing nothing.
  *
- * Everything above the pull loop is a read — the marketplace registry and each
- * entry's `autoUpdate` flag — so a read-only caller can have the full selection
- * verdict for free. `--dry-run` and `--check` promise to write nothing and
- * therefore cannot pull, but they must still be able to say "your magus clone
- * has autoUpdate off, so its catalog will never advance". Gating the whole call
- * off silently dropped that warning, which is the same "no signal reads as no
- * problem" failure the flag exists to prevent.
+ * Everything above the pull loop is a read — the marketplace registry, each
+ * entry's `autoUpdate` flag, which marketplaces installed plugins come from,
+ * and when each clone was last refreshed — so a read-only caller can have the
+ * full selection verdict for free. `--dry-run` and `--check` promise to write
+ * nothing and therefore cannot pull (nor record a refresh time), but their
+ * report must name the same set a writing run would pull: that set is
+ * `pending`.
  */
 export async function reportRegisteredMarketplaces(
 	skip: Iterable<string> = [],
+	options: RefreshOptions = {},
 ): Promise<RefreshResult> {
-	return refreshRegisteredMarketplaces(skip, {}, { reportOnly: true });
+	return selectAndRefresh(skip, {}, { ...options, reportOnly: true });
 }
 
+/**
+ * Non-destructively fast-forward the on-disk clone of every registered,
+ * auto-update-enabled, github-sourced marketplace that some installed plugin
+ * comes from (USER scope, or `options.pluginIds`), unless this machine already
+ * refreshed it within CATALOG_TTL_MS. A successful pull records its time; a
+ * failed one does not, so the next run retries.
+ *
+ * @param skip marketplaces already refreshed this run (e.g. re-registered ones),
+ *   so they aren't pulled twice.
+ * @param progress optional taps for a live progress display.
+ * @returns which marketplaces were refreshed, which failed (clone left intact),
+ *   which were fresh, and which were skipped. Failures and skips are collected
+ *   rather than thrown — one unreachable marketplace must not block launching
+ *   Claude. Pulls run concurrently, so a slow one doesn't serialize the rest
+ *   onto the launch path.
+ */
 export async function refreshRegisteredMarketplaces(
 	skip: Iterable<string> = [],
 	progress: RefreshProgress = {},
-	options: { reportOnly?: boolean } = {},
+	options: RefreshOptions = {},
+): Promise<RefreshResult> {
+	return selectAndRefresh(skip, progress, { ...options, reportOnly: false });
+}
+
+async function selectAndRefresh(
+	skip: Iterable<string>,
+	progress: RefreshProgress,
+	options: RefreshOptions & { reportOnly: boolean },
 ): Promise<RefreshResult> {
 	const refreshed: string[] = [];
 	const failed: string[] = [];
+	const fresh: string[] = [];
 	const skipped: string[] = [];
+	const now = options.now ?? Date.now();
 
 	const configured = await getConfiguredMarketplaces();
 	const skipSet = new Set(skip);
+	const needed = await neededMarketplaces(options.pluginIds ?? []);
 
 	// Select eligible marketplaces first so the pulls can run concurrently.
 	const eligible: string[] = [];
@@ -228,18 +294,25 @@ export async function refreshRegisteredMarketplaces(
 			skipped.push(name);
 			continue;
 		}
+		// Nothing installed at any scope comes from it, so a pull buys nothing.
+		if (!needed.has(name)) {
+			skipped.push(name);
+			continue;
+		}
+		// Refreshed on this machine within the hour, by any project's run.
+		if ((await readCloneRefreshAge(name, now)) !== null) {
+			fresh.push(name);
+			continue;
+		}
 		eligible.push(name);
 	}
 
 	// A read-only caller stops here, with the selection verdict intact and not
-	// one clone touched. `eligible` becomes `skipped`: nothing was refreshed, so
-	// claiming otherwise would be the false "all current" this module guards.
+	// one clone touched. `eligible` becomes `pending`, never `refreshed`: nothing
+	// was pulled, so claiming otherwise would be the false "all current" this
+	// module guards.
 	if (options.reportOnly) {
-		return {
-			refreshed: [],
-			failed: [],
-			skipped: [...skipped, ...eligible],
-		};
+		return { refreshed: [], failed: [], fresh, pending: eligible, skipped };
 	}
 
 	// Fast-forward every eligible clone in parallel so a slow one doesn't
@@ -261,5 +334,9 @@ export async function refreshRegisteredMarketplaces(
 		else skipped.push(name); // absent | skipped
 	});
 
-	return { refreshed, failed, skipped };
+	// Only a successful pull earns the hour. A failed, absent or dirty clone
+	// records nothing, so the next run — from any project — tries again.
+	for (const name of refreshed) await writeCloneRefreshed(name, now);
+
+	return { refreshed, failed, fresh, pending: [], skipped };
 }

package/src/ui/screens/AliasScreen.tsx

@@ -7,6 +7,7 @@ import {
 	ALIAS_FLAGS,
 	type AliasFlag,
 	FLAG_GROUPS,
+	getFlagById,
 } from "../../data/alias-flags.js";
 import { loadAliasName, saveAliasName } from "../../services/alias-settings.js";
 import {
@@ -18,6 +19,7 @@ import {
 	findAdoptableAlias,
 	parseAliasFromRc,
 	renderArgs,
+	renderEnv,
 	validateConfig,
 	writeAliasToShell,
 } from "../../services/alias-shell-writer.js";
@@ -521,9 +523,10 @@ export function AliasScreen() {
 			selectedRow.flag,
 			selectedRow.value,
 			modal,
+			showFailures,
 		);
 		if (next) updateFlag(selectedRow.flag.id, next);
-	}, [selectedRow, modal, updateFlag, editAliasName]);
+	}, [selectedRow, modal, showFailures, updateFlag, editAliasName]);
 
 	const toggleSelected = useCallback(async () => {
 		if (!selectedRow) return;
@@ -680,6 +683,7 @@ export function AliasScreen() {
 
 	// ── Render ────────────────────────────────────────────────────────────
 	const previewSegments = config ? renderArgs(config) : [];
+	const previewEnv = config ? renderEnv(config) : [];
 	const previewAliasName = config?.aliasName ?? "";
 
 	// Native OpenTUI scrollboxes own the scroll math. We render every item
@@ -767,6 +771,7 @@ export function AliasScreen() {
 		selectedRow,
 		isGated,
 		previewAliasName,
+		previewEnv,
 		previewSegments,
 	);
 	// When editing --channels and there are derived rows, the right pane carries
@@ -795,6 +800,7 @@ export function AliasScreen() {
 				detailFlag,
 				detailValue,
 				previewAliasName,
+				previewEnv,
 				previewSegments,
 				derivedNote,
 				stateOverride,
@@ -1081,6 +1087,7 @@ async function editFlagValue(
 	flag: AliasFlag,
 	value: FlagValue,
 	modal: ReturnType<typeof useModal>,
+	showFailures: ReturnType<typeof useFailurePopup>,
 ): Promise<FlagValue | null> {
 	switch (value.kind) {
 		case "boolean":
@@ -1154,6 +1161,17 @@ async function editFlagValue(
 			}
 			const v = await modal.input(flag.label, flag.description, value.value);
 			if (v === null) return null;
+			// An empty value disables the flag, so only a non-empty one is checked.
+			// A refused value leaves the old one in place.
+			const reason = v.length > 0 ? (flag.validateValue?.(v) ?? null) : null;
+			if (reason) {
+				await showFailures(
+					failureReport(`The ${flag.label.toLowerCase()} was not changed`, [
+						{ subject: v, reason },
+					]),
+				);
+				return null;
+			}
 			return { kind: "text", enabled: v.length > 0, value: v };
 		}
 
@@ -1336,6 +1354,7 @@ function renderDetail(
 	row: Row | undefined,
 	isGated: (f: AliasFlag) => boolean,
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 ): React.ReactNode {
 	if (!row) {
@@ -1357,7 +1376,7 @@ function renderDetail(
 			{headerAndBody}
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Preview:</text>
-			{renderPreviewLines(aliasName, segments)}
+			{renderPreviewLines(aliasName, env, segments)}
 		</box>
 	);
 }
@@ -1407,7 +1426,7 @@ function renderFlagDetail(
 			</text>
 			{gated && (
 				<text fg={theme.colors.muted}>
-					{`Depends on --${row.flag.requires}. Enabling this will turn that on too.`}
+					{`Depends on ${getFlagById(row.flag.requires ?? "").flag}. Enabling this will turn that on too.`}
 				</text>
 			)}
 			{row.issue && (
@@ -1438,18 +1457,23 @@ function renderFlagDetail(
  */
 function renderPreviewLines(
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 ): React.ReactNode {
+	// Env assignments run before `claude`, so they sit on the head line.
+	const command = [...env, "claude"].join(" ");
 	if (segments.length === 0) {
 		return (
-			<text fg={theme.colors.text}>{`alias ${aliasName || "?"}='claude'`}</text>
+			<text
+				fg={theme.colors.text}
+			>{`alias ${aliasName || "?"}='${command}'`}</text>
 		);
 	}
 	const lines: React.ReactNode[] = [
 		<text
 			key="head"
 			fg={theme.colors.text}
-		>{`alias ${aliasName || "?"}='claude`}</text>,
+		>{`alias ${aliasName || "?"}='${command}`}</text>,
 	];
 	segments.forEach((seg, i) => {
 		lines.push(
@@ -1530,6 +1554,7 @@ function renderFlagDetailRightPane(
 	flag: AliasFlag,
 	value: FlagValue,
 	aliasName: string,
+	env: string[],
 	segments: Segment[],
 	derivedNote?: string,
 	stateOverride?: string,
@@ -1555,7 +1580,7 @@ function renderFlagDetailRightPane(
 			</text>
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Preview:</text>
-			{renderPreviewLines(aliasName, segments)}
+			{renderPreviewLines(aliasName, env, segments)}
 			<text fg={theme.colors.text}> </text>
 			<text fg={theme.colors.muted}>Keys:</text>
 			<text fg={theme.colors.text}>