claudeup 6.5.1 → 6.7.1

package/src/services/claude-settings.ts

@@ -322,7 +322,7 @@ async function overlayRegistryVersions(
 	// `readSettings(undefined)` already resolves to the current directory, so the
 	// registry lookup has to as well. While it did not, the base map described one
 	// project while the overlay refused to match any project's rows at all, and every
-	// version was deleted as unbacked — which is why the prerunner and the global
+	// version was deleted as unbacked — which is why the global
 	// plugin view, both of which pass no path, saw project-scope plugins as
 	// uninstalled everywhere, not only in a worktree.
 	const target = scope === "user" ? undefined : (projectPath ?? process.cwd());
@@ -347,7 +347,7 @@ async function overlayRegistryVersions(
 		// binary, and `claude plugin install` writes it at no scope — so only
 		// claudeup's own past writes can be in there, and they go stale silently.
 		// Measured: user settings claimed browser-use 1.1.2 / terminal 4.0.2 /
-		// code-analysis 5.1.0 while the registry said 1.4.0 / 4.1.4 / 5.3.1, and
+		// code-search 5.1.0 while the registry said 1.4.0 / 4.1.4 / 5.3.1, and
 		// none of the claimed versions had a cache directory. Keeping the stale
 		// value made every one of them read as a permanent pending update.
 		if (entries && entries.length > 0) delete merged[pluginId];
@@ -677,98 +677,6 @@ export async function saveGlobalInstalledPluginVersion(
 	await updateInstalledPluginsRegistry(pluginId, version, "user");
 }
 
-/**
- * Gap-fill: ensure global installedPluginVersions is at least as high as
- * project and local scopes. When a plugin is updated at project scope,
- * global may lag behind, causing Claude Code to resolve stale cache paths.
- *
- * @returns Array of { pluginId, oldVersion, newVersion } for plugins that were bumped
- */
-export async function gapFillInstalledPluginVersions(
-	projectPath?: string,
-): Promise<
-	Array<{ pluginId: string; oldVersion: string; newVersion: string }>
-> {
-	const globalVersions = await getGlobalInstalledPluginVersions();
-
-	// Collect versions from project and local scopes
-	const allVersions: Record<string, string[]> = {};
-
-	// Start with global versions
-	for (const [id, ver] of Object.entries(globalVersions)) {
-		allVersions[id] = [ver];
-	}
-
-	// Add project scope versions
-	if (projectPath) {
-		try {
-			const settings = await readSettings(projectPath);
-			for (const [id, ver] of Object.entries(
-				settings.installedPluginVersions || {},
-			)) {
-				if (!allVersions[id]) allVersions[id] = [];
-				allVersions[id].push(ver);
-			}
-		} catch {
-			/* skip unreadable */
-		}
-
-		// Add local scope versions
-		try {
-			const localSettings = await readLocalSettings(projectPath);
-			for (const [id, ver] of Object.entries(
-				localSettings.installedPluginVersions || {},
-			)) {
-				if (!allVersions[id]) allVersions[id] = [];
-				allVersions[id].push(ver);
-			}
-		} catch {
-			/* skip unreadable */
-		}
-	}
-
-	// Find plugins where global needs bumping
-	const bumped: Array<{
-		pluginId: string;
-		oldVersion: string;
-		newVersion: string;
-	}> = [];
-
-	for (const [pluginId, versions] of Object.entries(allVersions)) {
-		// Filter to valid semver versions and sort descending
-		const valid = versions.filter((v) => semver.valid(v));
-		if (valid.length === 0) continue;
-
-		const highest = valid.sort((a, b) => semver.rcompare(a, b))[0];
-		const globalVer = globalVersions[pluginId];
-
-		// If global is missing, invalid semver, or lower than the highest, bump it
-		if (
-			!globalVer ||
-			!semver.valid(globalVer) ||
-			semver.lt(globalVer, highest)
-		) {
-			bumped.push({
-				pluginId,
-				oldVersion: globalVer || "(missing)",
-				newVersion: highest,
-			});
-		}
-	}
-
-	// Apply bumps in a single write
-	if (bumped.length > 0) {
-		const settings = await readGlobalSettings();
-		settings.installedPluginVersions = settings.installedPluginVersions || {};
-		for (const { pluginId, newVersion } of bumped) {
-			settings.installedPluginVersions[pluginId] = newVersion;
-		}
-		await writeGlobalSettings(settings);
-	}
-
-	return bumped;
-}
-
 export async function removeGlobalInstalledPluginVersion(
 	pluginId: string,
 ): Promise<void> {
@@ -1362,86 +1270,6 @@ export async function recoverMarketplaceSettings(): Promise<MarketplaceRecoveryR
 	return result;
 }
 
-/**
- * Clean up extraKnownMarketplaces entries that are now properly registered
- * in known_marketplaces.json (the official Claude Code marketplace registry).
- *
- * extraKnownMarketplaces was the old claudeup install mechanism. The official
- * way is `claude plugin marketplace add` which writes to known_marketplaces.json.
- * extraKnownMarketplaces should only be used in project settings for team
- * marketplace suggestions — not in user settings as a primary install path.
- *
- * This function removes magus-related entries from extraKnownMarketplaces in
- * both user and project settings when they're already in known_marketplaces.json.
- */
-export async function cleanupExtraKnownMarketplaces(
-	projectPath?: string,
-): Promise<string[]> {
-	const known = await readKnownMarketplaces();
-	const cleaned: string[] = [];
-
-	// Clean user-level settings
-	try {
-		const globalSettings = await readGlobalSettings();
-		if (globalSettings.extraKnownMarketplaces) {
-			let changed = false;
-			for (const name of Object.keys(globalSettings.extraKnownMarketplaces)) {
-				if (known[name]) {
-					delete globalSettings.extraKnownMarketplaces[name];
-					cleaned.push(`user:${name}`);
-					changed = true;
-				}
-			}
-			// Remove the field entirely if empty
-			if (
-				changed &&
-				Object.keys(globalSettings.extraKnownMarketplaces).length === 0
-			) {
-				// biome-ignore lint/performance/noDelete: the empty block is removed from settings.json entirely; an undefined value would survive Object.keys and `in` checks
-				delete globalSettings.extraKnownMarketplaces;
-			}
-			if (changed) {
-				await writeGlobalSettings(globalSettings);
-			}
-		}
-	} catch {
-		// Non-fatal: user settings cleanup is best-effort
-	}
-
-	// Clean project-level settings
-	if (projectPath) {
-		try {
-			const projectSettings = await readSettings(projectPath);
-			if (projectSettings.extraKnownMarketplaces) {
-				let changed = false;
-				for (const name of Object.keys(
-					projectSettings.extraKnownMarketplaces,
-				)) {
-					if (known[name]) {
-						delete projectSettings.extraKnownMarketplaces[name];
-						cleaned.push(`project:${name}`);
-						changed = true;
-					}
-				}
-				if (
-					changed &&
-					Object.keys(projectSettings.extraKnownMarketplaces).length === 0
-				) {
-					// biome-ignore lint/performance/noDelete: the empty block is removed from settings.json entirely; an undefined value would survive Object.keys and `in` checks
-					delete projectSettings.extraKnownMarketplaces;
-				}
-				if (changed) {
-					await writeSettings(projectSettings, projectPath);
-				}
-			}
-		} catch {
-			// Non-fatal: project settings cleanup is best-effort
-		}
-	}
-
-	return cleaned;
-}
-
 /**
  * Read known_marketplaces.json to get marketplace source info
  */

package/src/services/community-styles.ts

@@ -727,7 +727,7 @@ export function describeCommunityFailure(
 // ─── Staleness: advisory, two-phase, never automatic ─────────────────────────
 
 /**
- * 24 hours, matching image-generate's staleness precedent in the root CLAUDE.md.
+ * 24 hours, matching the image plugin's staleness precedent in the root CLAUDE.md.
  *
  * The TTL is not only a "when to re-check" rule — it is also a "how long may we
  * keep SAYING up-to-date" rule. A check from three days ago is evidence about

package/src/services/{gitignore-prerun.ts → gitignore-check.ts}

@@ -1,11 +1,11 @@
 /**
- * Prerunner integration for the gitignore manager.
+ * Read-only gitignore check for the gitignore manager.
  *
- * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
- * Resolves the manifest, runs detection, and prints a concise warning when
- * violations exist. Does NOT auto-apply fixes — the user must open the
- * Git State tab and confirm. This mirrors the plugin-version-mismatch flow
- * where prerun *warns* and the TUI provides the interactive fix dialog.
+ * Called from the TUI on startup and from `doctor`. Resolves the manifest, runs
+ * detection, and returns a concise warning when violations exist. Does NOT
+ * auto-apply fixes — the user must open the Git State tab and confirm. This
+ * mirrors the plugin-version-mismatch flow, where the check only *reports* and
+ * the TUI provides the interactive fix dialog.
  */
 
 import type { Violation } from "../types/gitignore.js";
@@ -13,12 +13,14 @@ import { detectViolations } from "./gitignore-detector.js";
 import { formatViolationSummary } from "./gitignore-fixer.js";
 import { resolveGitignore } from "./gitignore-resolver.js";
 
-export interface PrerunResult {
+export interface GitignoreCheckResult {
 	violationCount: number;
 	warnings: string[];
 }
 
-export async function checkGitignore(cwd: string): Promise<PrerunResult> {
+export async function checkGitignore(
+	cwd: string,
+): Promise<GitignoreCheckResult> {
 	const warnings: string[] = [];
 	try {
 		const resolved = await resolveGitignore(cwd, {
@@ -38,10 +40,12 @@ export async function checkGitignore(cwd: string): Promise<PrerunResult> {
 }
 
 /**
- * One-line summary suitable for prerun stderr. Returns null when there's
+ * One-line summary suitable for stderr. Returns null when there's
  * nothing to warn about.
  */
-export function formatPrerunWarning(result: PrerunResult): string | null {
+export function formatGitignoreWarning(
+	result: GitignoreCheckResult,
+): string | null {
 	if (result.violationCount === 0) return null;
 	return `⚠ ${result.violationCount} git state issue(s) detected. Run: claudeup → Git State tab to review and fix`;
 }

package/src/services/gitignore-fixer.ts

@@ -12,7 +12,7 @@
  *     Each call handles ONE violation; the caller is responsible for confirming
  *     each one with the user.
  *
- * `formatViolationSummary` is a pure helper for prerun warning + TUI.
+ * `formatViolationSummary` is a pure helper for the warning line + TUI.
  */
 
 import { spawn } from "node:child_process";

package/src/services/marketplace-refresh.ts

@@ -173,9 +173,27 @@ function tap(fn: (() => void) | undefined): void {
  *   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.
+ */
+export async function reportRegisteredMarketplaces(
+	skip: Iterable<string> = [],
+): Promise<RefreshResult> {
+	return refreshRegisteredMarketplaces(skip, {}, { reportOnly: true });
+}
+
 export async function refreshRegisteredMarketplaces(
 	skip: Iterable<string> = [],
 	progress: RefreshProgress = {},
+	options: { reportOnly?: boolean } = {},
 ): Promise<RefreshResult> {
 	const refreshed: string[] = [];
 	const failed: string[] = [];
@@ -200,6 +218,18 @@ export async function refreshRegisteredMarketplaces(
 		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.
+	if (options.reportOnly) {
+		return {
+			refreshed: [],
+			failed: [],
+			skipped: [...skipped, ...eligible],
+			autoUpdateDisabled,
+		};
+	}
+
 	// Fast-forward every eligible clone in parallel so a slow one doesn't
 	// serialize the rest onto the launch path. fastForwardCloneIfPresent never
 	// throws, so the batch always resolves.