claudeup 4.31.0 → 4.32.1

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

@@ -16,9 +16,13 @@ import {
 import { theme } from "../theme.js";
 import { highlightMatches } from "../../utils/fuzzy-search.js";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
-import { isEnabledButNotInstalled } from "../../services/plugin-manager.js";
+import {
+  isEnabledButNotInstalled,
+  isInstalledInScope,
+} from "../../services/plugin-manager.js";
 import { isKnownVersion } from "../../services/version-snapshot.js";
 import type { PluginRelease } from "../../types/index.js";
+import type { ScopeStatus } from "../../services/plugin-manager.js";
 
 // ─── Category renderers ───────────────────────────────────────────────────────
 
@@ -136,10 +140,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 +164,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";
     }
   }
 
@@ -207,10 +227,14 @@ function pluginRow(item: PluginPluginItem, isSelected: boolean): React.ReactNode
 
 function pluginDetail(item: PluginPluginItem): React.ReactNode {
   const { plugin } = item;
+  // "Installed" has to mean the same thing here as in the list row. Reading the
+  // `enabledPlugins` flag alone made this panel print "● Installed" for the
+  // exact plugin the row beside it was labelling "not installed".
   const isInstalled =
-    plugin.userScope?.enabled ||
-    plugin.projectScope?.enabled ||
-    plugin.localScope?.enabled;
+    isInstalledInScope(plugin.userScope) ||
+    isInstalledInScope(plugin.projectScope) ||
+    isInstalledInScope(plugin.localScope);
+  const brokenInstall = isEnabledButNotInstalled(plugin);
 
   // Orphaned/deprecated plugin
   if (plugin.isOrphaned) {
@@ -268,10 +292,30 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
 
       {/* Status line */}
       <box marginTop={1}>
-        <text fg={isInstalled ? theme.colors.success : theme.colors.muted}>
-          {isInstalled ? "● Installed" : "○ Not installed"}
+        <text
+          fg={
+            isInstalled
+              ? theme.colors.success
+              : brokenInstall
+                ? theme.colors.warning
+                : theme.colors.muted
+          }
+        >
+          {isInstalled
+            ? "● Installed"
+            : brokenInstall
+              ? "○ Not installed — enabled in settings, no files on disk"
+              : "○ Not installed"}
         </text>
       </box>
+      {brokenInstall ? (
+        <box>
+          <text fg={theme.colors.muted}>
+            Claude Code cannot load it in this state. Press the scope key to
+            repair.
+          </text>
+        </box>
+      ) : null}
 
       {/* Description */}
       <box marginTop={1} marginBottom={1}>
@@ -315,48 +359,27 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
           <strong>Scopes:</strong>
         </text>
         <box marginTop={1} flexDirection="column">
-          <text>
-            <span bg={theme.scopes.user} fg="black">
-              {" "}
-              u{" "}
-            </span>
-            <span fg={plugin.userScope?.enabled ? theme.scopes.user : theme.colors.muted}>
-              {plugin.userScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.user}>User</span>
-            <span> global</span>
-            {plugin.userScope?.version ? (
-              <span fg={theme.scopes.user}> v{plugin.userScope.version}</span>
-            ) : null}
-          </text>
-          <text>
-            <span bg={theme.scopes.project} fg="black">
-              {" "}
-              p{" "}
-            </span>
-            <span fg={plugin.projectScope?.enabled ? theme.scopes.project : theme.colors.muted}>
-              {plugin.projectScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.project}>Project</span>
-            <span> team</span>
-            {plugin.projectScope?.version ? (
-              <span fg={theme.scopes.project}> v{plugin.projectScope.version}</span>
-            ) : null}
-          </text>
-          <text>
-            <span bg={theme.scopes.local} fg="black">
-              {" "}
-              l{" "}
-            </span>
-            <span fg={plugin.localScope?.enabled ? theme.scopes.local : theme.colors.muted}>
-              {plugin.localScope?.enabled ? " ● " : " ○ "}
-            </span>
-            <span fg={theme.scopes.local}>Local</span>
-            <span> private</span>
-            {plugin.localScope?.version ? (
-              <span fg={theme.scopes.local}> v{plugin.localScope.version}</span>
-            ) : null}
-          </text>
+          <ScopeLine
+            keyHint="u"
+            name="User"
+            qualifier="global"
+            color={theme.scopes.user}
+            scope={plugin.userScope}
+          />
+          <ScopeLine
+            keyHint="p"
+            name="Project"
+            qualifier="team"
+            color={theme.scopes.project}
+            scope={plugin.projectScope}
+          />
+          <ScopeLine
+            keyHint="l"
+            name="Local"
+            qualifier="private"
+            color={theme.scopes.local}
+            scope={plugin.localScope}
+          />
         </box>
       </DetailSection>
 
@@ -373,6 +396,47 @@ function pluginDetail(item: PluginPluginItem): React.ReactNode {
   );
 }
 
+/**
+ * One line of the detail panel's scope breakdown.
+ *
+ * The filled dot means installed — registry-backed, same as everywhere else.
+ * A scope that is enabled with nothing installed is called out explicitly
+ * rather than shown as a plain empty dot, because those two states need
+ * different actions from the user and used to look identical.
+ */
+function ScopeLine({
+  keyHint,
+  name,
+  qualifier,
+  color,
+  scope,
+}: {
+  keyHint: string;
+  name: string;
+  qualifier: string;
+  color: string;
+  scope?: ScopeStatus;
+}): React.ReactNode {
+  const installed = isInstalledInScope(scope);
+  return (
+    <text>
+      <span bg={color} fg="black">
+        {" "}
+        {keyHint}{" "}
+      </span>
+      <span fg={installed ? color : theme.colors.muted}>
+        {installed ? " ● " : " ○ "}
+      </span>
+      <span fg={color}>{name}</span>
+      <span> {qualifier}</span>
+      {scope?.version ? <span fg={color}> v{scope.version}</span> : null}
+      {!installed && scope?.enabled ? (
+        <span fg={theme.colors.warning}> enabled, not installed</span>
+      ) : null}
+    </text>
+  );
+}
+
 /**
  * Recent release history, newest first.
  *

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,
@@ -17,8 +18,11 @@ import {
 	refreshAllMarketplaces,
 	clearMarketplaceCache,
 	getLocalMarketplacesInfo,
+	isInstalledInScope,
+	resolveScopeAction,
 	saveInstalledPluginVersion,
 	type PluginInfo,
+	type ScopeStatus,
 } from "../../services/plugin-manager.js";
 import {
 	setMcpEnvVar,
@@ -30,6 +34,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 +92,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 +103,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 +360,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 =
@@ -597,10 +608,10 @@ export function PluginsScreen() {
 
 			const buildScopeLabel = (
 				name: string,
-				scope: { enabled?: boolean; version?: string } | undefined,
+				scope: ScopeStatus | undefined,
 				desc: string,
 			) => {
-				const installed = scope?.enabled;
+				const installed = isInstalledInScope(scope);
 				const ver = scope?.version;
 				const hasUpdate =
 					ver &&
@@ -611,6 +622,10 @@ export function PluginsScreen() {
 				label += ` (${desc})`;
 				if (ver) label += ` v${ver}`;
 				if (hasUpdate) label += ` → v${latestVersion}`;
+				// Enabled in settings with nothing installed. Without saying so the
+				// row reads exactly like a scope that was never enabled, and the
+				// user cannot tell that picking it repairs rather than adds.
+				if (!installed && scope?.enabled) label += " — not installed, repairs";
 				return label;
 			};
 
@@ -642,8 +657,6 @@ export function PluginsScreen() {
 					: scopeValue === "project"
 						? plugin.projectScope
 						: plugin.localScope;
-			const isInstalledInScope = selectedScope?.enabled;
-			const installedVersion = selectedScope?.version;
 			const scopeLabel =
 				scopeValue === "user"
 					? "User"
@@ -651,20 +664,9 @@ export function PluginsScreen() {
 						? "Project"
 						: "Local";
 
-			const hasUpdateInScope =
-				isInstalledInScope &&
-				installedVersion &&
-				latestVersion !== "0.0.0" &&
-				installedVersion !== latestVersion;
-
-			let action: "update" | "install" | "uninstall";
-			if (isInstalledInScope && hasUpdateInScope) {
-				action = "update";
-			} else if (isInstalledInScope) {
-				action = "uninstall";
-			} else {
-				action = "install";
-			}
+			// Decided from the registry-backed version, not the `enabledPlugins`
+			// flag alone — see resolveScopeAction.
+			const action = resolveScopeAction(selectedScope, latestVersion);
 
 			try {
 				const scope = scopeValue as PluginScope;
@@ -705,17 +707,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 +745,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 +759,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);
 				}
@@ -814,23 +837,12 @@ export function PluginsScreen() {
 				: scope === "project"
 					? plugin.projectScope
 					: plugin.localScope;
-		const isInstalledInScope = scopeData?.enabled;
-		const installedVersion = scopeData?.version;
-
-		const hasUpdateInScope =
-			isInstalledInScope &&
-			installedVersion &&
-			latestVersion !== "0.0.0" &&
-			installedVersion !== latestVersion;
-
-		let action: "update" | "install" | "uninstall";
-		if (isInstalledInScope && hasUpdateInScope) {
-			action = "update";
-		} else if (isInstalledInScope) {
-			action = "uninstall";
-		} else {
-			action = "install";
-		}
+
+		// This used to key off `scopeData.enabled` alone, so a plugin the list
+		// had just labelled "not installed" answered its own scope key by
+		// uninstalling itself — the `enabledPlugins` flag was set, the registry
+		// entry was missing, and only the flag was consulted.
+		const action = resolveScopeAction(scopeData, latestVersion);
 
 		try {
 			if (action === "uninstall") {
@@ -872,19 +884,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 +1041,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),