claudeup 4.31.0 → 4.32.0

package/src/services/version-snapshot.ts

@@ -42,22 +42,50 @@ export interface PluginChange {
 }
 
 interface SnapshotFile {
-  /** pluginId -> installedVersion as of the last time claudeup rendered it. */
-  seen: Record<string, string>;
+  /**
+   * Legacy flat baseline: pluginId -> version, with no record of which project
+   * it was observed from. Kept only so an existing file can be migrated.
+   */
+  seen?: Record<string, string>;
+  /**
+   * projectPath -> (pluginId -> installedVersion) as of the last time claudeup
+   * rendered that project.
+   *
+   * Versions are per-project (installed_plugins.json keys installs by
+   * projectPath), but this file is global. A single flat map therefore let two
+   * projects legitimately on different versions overwrite each other's
+   * baseline, and every differing plugin was badged "updated" on the next
+   * render — a change that never happened. Keying by project removes the
+   * cross-talk entirely.
+   */
+  byProject?: Record<string, Record<string, string>>;
   /** Set on the run that first created the baseline. */
   seededAt: string;
   updatedAt: string;
 }
 
+/**
+ * Honour CLAUDE_CONFIG_DIR — the same override Claude Code itself uses.
+ *
+ * `os.homedir()` reads the passwd database on macOS and ignores $HOME, so a
+ * test that only overrides HOME writes to the operator's real snapshot file.
+ * That is not hypothetical: it happened while building the tests for this fix.
+ */
 function snapshotPath(): string {
-  return path.join(os.homedir(), ".claude", "claudeup-version-snapshot.json");
+  const configDir =
+    process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return path.join(configDir, "claudeup-version-snapshot.json");
 }
 
 async function read(): Promise<SnapshotFile | null> {
   try {
     const raw = await fs.readFile(snapshotPath(), "utf-8");
     const data = JSON.parse(raw) as SnapshotFile;
-    if (!data || typeof data.seen !== "object" || data.seen === null) return null;
+    if (!data) return null;
+    const hasFlat = typeof data.seen === "object" && data.seen !== null;
+    const hasByProject =
+      typeof data.byProject === "object" && data.byProject !== null;
+    if (!hasFlat && !hasByProject) return null;
     return data;
   } catch {
     return null; // absent or corrupt — treated as "no baseline yet"
@@ -109,10 +137,28 @@ export function diffVersions(
   return changes;
 }
 
-/** Load the previous snapshot's version map, or null when no baseline exists. */
-export async function loadSeenVersions(): Promise<Record<string, string> | null> {
+/**
+ * Load the baseline for one project, or null when that project has none.
+ *
+ * A project seen for the first time returns null, so `diffVersions` stays
+ * silent — the same rule as a first ever run. That is deliberate: opening
+ * claudeup in a new project must not badge every plugin as "updated" just
+ * because this file has never seen that path before.
+ *
+ * A pre-migration flat file is adopted as the baseline for whichever project
+ * asks first, which is the closest thing to the truth it contains.
+ */
+export async function loadSeenVersions(
+  projectPath: string,
+): Promise<Record<string, string> | null> {
   const data = await read();
-  return data ? data.seen : null;
+  if (!data) return null;
+  const scoped = data.byProject?.[projectPath];
+  if (scoped) return scoped;
+  // Legacy flat baseline, project unknown — use it once, then it is replaced
+  // by per-project entries on save.
+  if (data.seen && !data.byProject) return data.seen;
+  return null;
 }
 
 /**
@@ -121,6 +167,7 @@ export async function loadSeenVersions(): Promise<Record<string, string> | null>
  * shows again next launch.
  */
 export async function saveSeenVersions(
+  projectPath: string,
   current: Record<string, string>,
 ): Promise<void> {
   try {
@@ -129,7 +176,9 @@ export async function saveSeenVersions(
     const existing = await read();
     const now = new Date().toISOString();
     const payload: SnapshotFile = {
-      seen: current,
+      // Other projects' baselines are preserved — writing only this project's
+      // slot is the entire point of the fix.
+      byProject: { ...(existing?.byProject ?? {}), [projectPath]: current },
       seededAt: existing?.seededAt ?? now,
       updatedAt: now,
     };

package/src/ui/renderers/pluginRenderers.tsx

@@ -136,10 +136,20 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
 
   let versionStr = "";
   if (plugin.isOrphaned) {
-    versionStr = " deprecated";
+    // "deprecated" alone reads as "delete me" — but a plugin that merely moved
+    // marketplace is still published, and deleting it loses it for no reason.
+    versionStr = plugin.movedTo
+      ? ` moved → ${plugin.movedTo}`
+      : " deprecated";
   } else if (notInstalled) {
     versionStr = " not installed";
   } else if (hasAnyScope) {
+    // "what just changed" and "what is still available" are independent facts,
+    // and both can be true at once: the prerunner can move a plugin 2.9.0→3.0.1
+    // while the marketplace already offers 3.3.1. These used to share one
+    // if/else chain, so the "updated" badge silently swallowed the pending
+    // update — and the update only reappeared on the next refresh, which read
+    // as the state spontaneously changing. Render them as separate clauses.
     if (plugin.recentlyUpdatedFrom && shownVersion) {
       // Show what actually happened, not just where it landed — the update may
       // have come from Claude Code or the prerunner without ever telling us.
@@ -150,9 +160,15 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
       versionStr = shownVersion ? ` v${shownVersion} new` : " new";
     } else if (shownVersion) {
       versionStr = ` v${shownVersion}`;
-      if (plugin.hasUpdate && plugin.version) {
-        versionStr += ` → v${plugin.version}`;
-      }
+    }
+
+    // Pending update, regardless of which badge above applied.
+    if (plugin.hasUpdate && plugin.version && versionStr) {
+      versionStr += ` → v${plugin.version} available`;
+    } else if (plugin.contentStale && versionStr) {
+      // Same version, different files. The version compare says "up to date"
+      // and is wrong — only a reinstall delivers the current content.
+      versionStr += " stale — reinstall";
     }
   }
 

package/src/ui/screens/PluginsScreen.tsx

@@ -7,6 +7,7 @@ import { ScrollableList } from "../components/ScrollableList.js";
 import { EmptyFilterState } from "../components/EmptyFilterState.js";
 import { fuzzyFilter } from "../../utils/fuzzy-search.js";
 import { getAllMarketplaces } from "../../data/marketplaces.js";
+import { clearContentDriftCache } from "../../services/content-drift.js";
 import {
 	diffVersions,
 	loadSeenVersions,
@@ -30,6 +31,7 @@ import {
 import { saveProfile } from "../../services/profiles.js";
 import {
 	installPlugin as cliInstallPlugin,
+	repairPlugin as cliRepairPlugin,
 	uninstallPlugin as cliUninstallPlugin,
 	updatePlugin as cliUpdatePlugin,
 	type PluginScope,
@@ -87,7 +89,8 @@ export function PluginsScreen() {
 			for (const p of pluginData) {
 				if (p.installedVersion) current[p.id] = p.installedVersion;
 			}
-			const previous = await loadSeenVersions();
+			const projectPath = state.projectPath || process.cwd();
+			const previous = await loadSeenVersions(projectPath);
 			for (const change of diffVersions(previous, current)) {
 				const target = pluginData.find((p) => p.id === change.pluginId);
 				if (!target) continue;
@@ -97,8 +100,10 @@ export function PluginsScreen() {
 					target.recentlyInstalled = true;
 				}
 			}
-			// Record now so the same change is not reported on the next launch.
-			void saveSeenVersions(current);
+			// Await the write. Fire-and-forget raced the next fetchData() — a
+			// refresh or a post-action refetch could load the baseline before the
+			// previous save landed and re-report the same change.
+			await saveSeenVersions(projectPath, current);
 
 			dispatch({
 				type: "PLUGINS_DATA_SUCCESS",
@@ -352,6 +357,9 @@ export function PluginsScreen() {
 				progress.show(`${p.name}`, p.current, p.total);
 			});
 			clearMarketplaceCache();
+			// Drift is answered by diffing against the clone's HEAD, so a refresh
+			// that moves HEAD invalidates every cached answer.
+			clearContentDriftCache();
 			progress.hide();
 
 			let message =
@@ -705,17 +713,29 @@ export function PluginsScreen() {
 
 	const handleUpdate = async () => {
 		const item = selectableItems[pluginsState.selectedIndex];
-		if (!item || item.kind !== "plugin" || !item.plugin.hasUpdate) return;
+		if (!item || item.kind !== "plugin") return;
+		if (!item.plugin.hasUpdate && !item.plugin.contentStale) return;
 
 		const plugin = item.plugin;
 		const scope: PluginScope =
 			pluginsState.scope === "global" ? "user" : "project";
 
+		// No version bump to install over — the files changed underneath an
+		// unchanged version, and `plugin install` no-ops on "already installed".
+		// Only uninstall+install re-copies. See claude-cli.ts repairPlugin.
+		const repairing = !plugin.hasUpdate && plugin.contentStale;
+
 		modal.loading(
-			`Updating ${plugin.name}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
+			repairing
+				? `Repairing ${plugin.name}…\nclaude plugin uninstall ${plugin.id} --scope ${scope} && claude plugin install ${plugin.id} --scope ${scope}`
+				: `Updating ${plugin.name}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
 		);
 		try {
-			await cliUpdatePlugin(plugin.id, scope);
+			if (repairing) {
+				await cliRepairPlugin(plugin.id, scope, state.projectPath);
+			} else {
+				await cliUpdatePlugin(plugin.id, scope);
+			}
 			if (plugin.version) {
 				await saveVersionForScope(plugin.id, plugin.version, scope);
 			}
@@ -731,7 +751,11 @@ export function PluginsScreen() {
 	const handleUpdateAll = async () => {
 		if (pluginsState.plugins.status !== "success") return;
 
-		const updatable = pluginsState.plugins.data.filter((p) => p.hasUpdate);
+		// Content-stale plugins are included: they need repairing, and excluding
+		// them meant "update all" left the machine with silently outdated files.
+		const updatable = pluginsState.plugins.data.filter(
+			(p) => p.hasUpdate || p.contentStale,
+		);
 		if (updatable.length === 0) return;
 
 		const scope: PluginScope =
@@ -741,10 +765,15 @@ export function PluginsScreen() {
 		try {
 			for (let i = 0; i < updatable.length; i++) {
 				const plugin = updatable[i];
+				const repairing = !plugin.hasUpdate && plugin.contentStale;
 				modal.loading(
-					`Updating ${plugin.name} (${i + 1}/${updatable.length})…\nclaude plugin install ${plugin.id} --scope ${scope}`,
+					`${repairing ? "Repairing" : "Updating"} ${plugin.name} (${i + 1}/${updatable.length})…\nclaude plugin install ${plugin.id} --scope ${scope}`,
 				);
-				await cliUpdatePlugin(plugin.id, scope);
+				if (repairing) {
+					await cliRepairPlugin(plugin.id, scope, state.projectPath);
+				} else {
+					await cliUpdatePlugin(plugin.id, scope);
+				}
 				if (plugin.version) {
 					await saveVersionForScope(plugin.id, plugin.version, scope);
 				}
@@ -872,19 +901,62 @@ export function PluginsScreen() {
 		if (!item || item.kind !== "plugin" || !item.plugin.isOrphaned) return;
 
 		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
+		// seo, instantly, 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;
+		}
+
 		try {
 			// Remove from all scopes — try all to clean up stale references
 			const scopes: PluginScope[] = ["user", "project", "local"];
+			const removedFrom: PluginScope[] = [];
 			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}`,
+					);
+					await cliInstallPlugin(newId, scope);
+				}
+			}
+
 			modal.hideModal();
 			fetchData();
 		} catch (error) {
@@ -986,7 +1058,7 @@ export function PluginsScreen() {
 	const installedCount = plugins.filter((p) => p.enabled).length;
 	const updateCount = plugins.filter(
 		(p) =>
-			p.hasUpdate &&
+			(p.hasUpdate || p.contentStale) &&
 			(p.userScope?.enabled ||
 				p.projectScope?.enabled ||
 				p.localScope?.enabled),