claudeup 4.10.1 → 4.11.0

package/src/prerunner/index.js

@@ -5,6 +5,7 @@ import { UpdateCache } from "../services/update-cache.js";
 import { getAvailablePlugins, clearMarketplaceCache, } from "../services/plugin-manager.js";
 import { runClaude } from "../services/claude-runner.js";
 import { recoverMarketplaceSettings, migrateMarketplaceRename, cleanupExtraKnownMarketplaces, getGlobalEnabledPlugins, getEnabledPlugins, getLocalEnabledPlugins, readGlobalSettings, writeGlobalSettings, saveGlobalInstalledPluginVersion, gapFillInstalledPluginVersions, } from "../services/claude-settings.js";
+import { checkPluginVersionMismatches, formatMismatchWarning, } from "../services/plugin-version-check.js";
 import { parsePluginId } from "../utils/string-utils.js";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import { updatePlugin, addMarketplace, isClaudeAvailable, } from "../services/claude-cli.js";
@@ -200,6 +201,22 @@ export async function prerunClaude(claudeArgs, options = {}) {
         catch {
             // Non-fatal: gap-fill is best-effort
         }
+        // STEP 0.8: Detect plugin version mismatches caused by the [0] index bug
+        // Claude Code's pluginLoader.ts takes entries[0] regardless of project,
+        // so if another project installed a different version first, this project
+        // will silently load the wrong version.
+        try {
+            const cwd = process.cwd();
+            const mismatches = await checkPluginVersionMismatches(cwd);
+            if (mismatches.length > 0) {
+                console.warn("");
+                console.warn(formatMismatchWarning(mismatches));
+                console.warn("");
+            }
+        }
+        catch {
+            // Non-fatal: mismatch detection is best-effort
+        }
         // STEP 1: Check if we should update (time-based cache, or forced)
         const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
         if (options.force) {

package/src/prerunner/index.ts

@@ -19,6 +19,10 @@ import {
 	saveGlobalInstalledPluginVersion,
 	gapFillInstalledPluginVersions,
 } from "../services/claude-settings.js";
+import {
+	checkPluginVersionMismatches,
+	formatMismatchWarning,
+} from "../services/plugin-version-check.js";
 import { parsePluginId } from "../utils/string-utils.js";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import {
@@ -273,6 +277,22 @@ export async function prerunClaude(
 			// Non-fatal: gap-fill is best-effort
 		}
 
+		// STEP 0.8: Detect plugin version mismatches caused by the [0] index bug
+		// Claude Code's pluginLoader.ts takes entries[0] regardless of project,
+		// so if another project installed a different version first, this project
+		// will silently load the wrong version.
+		try {
+			const cwd = process.cwd();
+			const mismatches = await checkPluginVersionMismatches(cwd);
+			if (mismatches.length > 0) {
+				console.warn("");
+				console.warn(formatMismatchWarning(mismatches));
+				console.warn("");
+			}
+		} catch {
+			// Non-fatal: mismatch detection is best-effort
+		}
+
 		// STEP 1: Check if we should update (time-based cache, or forced)
 		const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
 

package/src/services/plugin-setup.js

@@ -9,12 +9,18 @@
  * - brew: Homebrew formulae (macOS/Linux)
  * - npm: Global npm packages
  * - cargo: Rust crates
+ * - go: Go modules (via go install)
+ *
+ * Special keys:
+ * - required: System binaries that must exist in PATH (not auto-installed)
  *
  * Example plugin.json:
  * {
  *   "setup": {
  *     "pip": ["browser-use", "mcp"],
- *     "brew": ["memextech/tap/ht-mcp"]
+ *     "brew": ["memextech/tap/ht-mcp"],
+ *     "go": ["github.com/MadAppGang/tmux-mcp@latest"],
+ *     "required": ["tmux"]
  *   }
  * }
  */
@@ -224,6 +230,60 @@ async function installCargoPackages(packages, result) {
         }
     }
 }
+/**
+ * Extract binary name from a Go module path.
+ * The binary name is the last path segment before @version.
+ * e.g., "github.com/MadAppGang/tmux-mcp@latest" → "tmux-mcp"
+ *       "github.com/user/tool" → "tool"
+ */
+export function extractGoBinaryName(pkg) {
+    // Strip @version suffix first
+    const withoutVersion = pkg.replace(/@[^/]*$/, "");
+    return withoutVersion.split("/").pop() || pkg;
+}
+/**
+ * Install Go packages via `go install`
+ */
+async function installGoPackages(packages, result) {
+    const goPath = await which("go");
+    if (!goPath) {
+        for (const pkg of packages) {
+            result.failed.push({ pkg: `go:${pkg}`, error: "go not found" });
+        }
+        return;
+    }
+    for (const pkg of packages) {
+        const binaryName = extractGoBinaryName(pkg);
+        if (await isBinaryAvailable(binaryName)) {
+            result.skipped.push(`go:${pkg}`);
+            continue;
+        }
+        const { ok, stderr } = await run(goPath, ["install", pkg], 300000);
+        if (ok) {
+            result.installed.push(`go:${pkg}`);
+        }
+        else {
+            result.failed.push({ pkg: `go:${pkg}`, error: stderr });
+        }
+    }
+}
+/**
+ * Check required system binaries and report missing ones.
+ * These are NOT installed by claudeup — the user must install them manually.
+ */
+async function checkRequiredBinaries(binaries, result) {
+    for (const name of binaries) {
+        if (await isBinaryAvailable(name)) {
+            result.skipped.push(`required:${name}`);
+        }
+        else {
+            result.failed.push({
+                pkg: `required:${name}`,
+                error: `Required binary '${name}' not found in PATH. Please install it manually.`,
+            });
+        }
+    }
+}
 /**
  * Read the setup config from a plugin's cached manifest
  */
@@ -304,6 +364,12 @@ export async function installPluginDeps(setup) {
     if (setup.cargo?.length) {
         await installCargoPackages(setup.cargo, result);
     }
+    if (setup.go?.length) {
+        await installGoPackages(setup.go, result);
+    }
+    if (setup.required?.length) {
+        await checkRequiredBinaries(setup.required, result);
+    }
     return result;
 }
 /**
@@ -353,5 +419,26 @@ export async function checkMissingDeps(setup) {
         if (missingCargo.length > 0)
             missing.cargo = missingCargo;
     }
+    if (setup.go?.length) {
+        const missingGo = [];
+        for (const pkg of setup.go) {
+            const bin = extractGoBinaryName(pkg);
+            if (!(await isBinaryAvailable(bin))) {
+                missingGo.push(pkg);
+            }
+        }
+        if (missingGo.length > 0)
+            missing.go = missingGo;
+    }
+    if (setup.required?.length) {
+        const missingRequired = [];
+        for (const name of setup.required) {
+            if (!(await isBinaryAvailable(name))) {
+                missingRequired.push(name);
+            }
+        }
+        if (missingRequired.length > 0)
+            missing.required = missingRequired;
+    }
     return missing;
 }

package/src/services/plugin-setup.ts

@@ -9,12 +9,18 @@
  * - brew: Homebrew formulae (macOS/Linux)
  * - npm: Global npm packages
  * - cargo: Rust crates
+ * - go: Go modules (via go install)
+ *
+ * Special keys:
+ * - required: System binaries that must exist in PATH (not auto-installed)
  *
  * Example plugin.json:
  * {
  *   "setup": {
  *     "pip": ["browser-use", "mcp"],
- *     "brew": ["memextech/tap/ht-mcp"]
+ *     "brew": ["memextech/tap/ht-mcp"],
+ *     "go": ["github.com/MadAppGang/tmux-mcp@latest"],
+ *     "required": ["tmux"]
  *   }
  * }
  */
@@ -33,6 +39,8 @@ export interface SetupConfig {
 	brew?: string[];
 	npm?: string[];
 	cargo?: string[];
+	go?: string[];
+	required?: string[];
 }
 
 export interface SetupResult {
@@ -275,6 +283,69 @@ async function installCargoPackages(
 	}
 }
 
+/**
+ * Extract binary name from a Go module path.
+ * The binary name is the last path segment before @version.
+ * e.g., "github.com/MadAppGang/tmux-mcp@latest" → "tmux-mcp"
+ *       "github.com/user/tool" → "tool"
+ */
+export function extractGoBinaryName(pkg: string): string {
+	// Strip @version suffix first
+	const withoutVersion = pkg.replace(/@[^/]*$/, "");
+	return withoutVersion.split("/").pop() || pkg;
+}
+
+/**
+ * Install Go packages via `go install`
+ */
+async function installGoPackages(
+	packages: string[],
+	result: SetupResult,
+): Promise<void> {
+	const goPath = await which("go");
+	if (!goPath) {
+		for (const pkg of packages) {
+			result.failed.push({ pkg: `go:${pkg}`, error: "go not found" });
+		}
+		return;
+	}
+
+	for (const pkg of packages) {
+		const binaryName = extractGoBinaryName(pkg);
+		if (await isBinaryAvailable(binaryName)) {
+			result.skipped.push(`go:${pkg}`);
+			continue;
+		}
+
+		const { ok, stderr } = await run(goPath, ["install", pkg], 300000);
+		if (ok) {
+			result.installed.push(`go:${pkg}`);
+		} else {
+			result.failed.push({ pkg: `go:${pkg}`, error: stderr });
+		}
+	}
+}
+
+/**
+ * Check required system binaries and report missing ones.
+ * These are NOT installed by claudeup — the user must install them manually.
+ */
+async function checkRequiredBinaries(
+	binaries: string[],
+	result: SetupResult,
+): Promise<void> {
+	for (const name of binaries) {
+		if (await isBinaryAvailable(name)) {
+			result.skipped.push(`required:${name}`);
+		} else {
+			result.failed.push({
+				pkg: `required:${name}`,
+				error: `Required binary '${name}' not found in PATH. Please install it manually.`,
+			});
+		}
+	}
+}
+
 /**
  * Read the setup config from a plugin's cached manifest
  */
@@ -381,6 +452,12 @@ export async function installPluginDeps(
 	if (setup.cargo?.length) {
 		await installCargoPackages(setup.cargo, result);
 	}
+	if (setup.go?.length) {
+		await installGoPackages(setup.go, result);
+	}
+	if (setup.required?.length) {
+		await checkRequiredBinaries(setup.required, result);
+	}
 
 	return result;
 }
@@ -435,5 +512,26 @@ export async function checkMissingDeps(
 		if (missingCargo.length > 0) missing.cargo = missingCargo;
 	}
 
+	if (setup.go?.length) {
+		const missingGo: string[] = [];
+		for (const pkg of setup.go) {
+			const bin = extractGoBinaryName(pkg);
+			if (!(await isBinaryAvailable(bin))) {
+				missingGo.push(pkg);
+			}
+		}
+		if (missingGo.length > 0) missing.go = missingGo;
+	}
+
+	if (setup.required?.length) {
+		const missingRequired: string[] = [];
+		for (const name of setup.required) {
+			if (!(await isBinaryAvailable(name))) {
+				missingRequired.push(name);
+			}
+		}
+		if (missingRequired.length > 0) missing.required = missingRequired;
+	}
+
 	return missing;
 }

package/src/services/plugin-version-check.js

@@ -0,0 +1,248 @@
+/**
+ * Plugin version mismatch detection and fix.
+ *
+ * Claude Code's plugin loader (pluginLoader.ts:2051) takes the FIRST entry
+ * from installed_plugins.json for each plugin ID:
+ *
+ *   const installEntry = installedPluginsData.plugins[pluginId]?.[0]
+ *
+ * This means the first project to install a plugin determines which version
+ * loads for ALL projects. When different projects install different versions,
+ * only the one at index [0] takes effect.
+ *
+ * Bug report: https://github.com/anthropics/claude-code/issues/45997
+ */
+import { getEnabledPlugins, getGlobalEnabledPlugins, getLocalEnabledPlugins, readInstalledPluginsRegistry, writeInstalledPluginsRegistry, } from "./claude-settings.js";
+const BUG_REPORT_URL = "https://github.com/anthropics/claude-code/issues/45997";
+// ── Detection ────────────────────────────────────────────────────────────────
+/**
+ * Check for plugin version mismatches caused by the [0] index bug.
+ *
+ * For each enabled plugin in the current project:
+ * 1. Reads the plugin's entry array from installed_plugins.json
+ * 2. Finds the entry matching the current project
+ * 3. Checks if entries[0] has a DIFFERENT version than the current project's entry
+ * 4. If yes: this project will load the wrong version
+ *
+ * @param projectPath - The current project path to check
+ * @returns Array of mismatch info for each affected plugin
+ */
+export async function checkPluginVersionMismatches(projectPath) {
+    const registry = await readInstalledPluginsRegistry();
+    const enabledPluginIds = await collectEnabledPluginIds(projectPath);
+    const mismatches = [];
+    for (const pluginId of enabledPluginIds) {
+        const entries = registry.plugins[pluginId];
+        if (!entries || entries.length < 2)
+            continue;
+        // Find the entry for the current project
+        const currentEntry = entries.find((e) => e.scope === "project" &&
+            normalizePath(e.projectPath) === normalizePath(projectPath));
+        if (!currentEntry)
+            continue;
+        const firstEntry = entries[0];
+        // Compare the version at [0] with the current project's version
+        if (firstEntry.version !== currentEntry.version) {
+            mismatches.push({
+                pluginId,
+                firstEntryVersion: firstEntry.version,
+                firstEntryProject: firstEntry.projectPath,
+                currentProjectVersion: currentEntry.version,
+                allEntries: entries,
+            });
+        }
+    }
+    return mismatches;
+}
+/**
+ * Check a single plugin for version mismatch (used after plugin update).
+ *
+ * @param pluginId - The plugin ID to check
+ * @param projectPath - The current project path
+ * @returns Mismatch info or null if no mismatch
+ */
+export async function checkSinglePluginMismatch(pluginId, projectPath) {
+    const registry = await readInstalledPluginsRegistry();
+    const entries = registry.plugins[pluginId];
+    if (!entries || entries.length < 2)
+        return null;
+    const currentEntry = entries.find((e) => e.scope === "project" &&
+        normalizePath(e.projectPath) === normalizePath(projectPath));
+    if (!currentEntry)
+        return null;
+    const firstEntry = entries[0];
+    if (firstEntry.version === currentEntry.version)
+        return null;
+    return {
+        pluginId,
+        firstEntryVersion: firstEntry.version,
+        firstEntryProject: firstEntry.projectPath,
+        currentProjectVersion: currentEntry.version,
+        allEntries: entries,
+    };
+}
+// ── Fix ──────────────────────────────────────────────────────────────────────
+/**
+ * Fix a version mismatch by updating ALL entries for a plugin to use
+ * the target version. This is a JSON-only operation that rewrites
+ * installPath and version in each entry.
+ *
+ * IMPORTANT: This modifies installed_plugins.json which is Claude Code-owned.
+ * Only call after explicit user consent.
+ *
+ * @param pluginId - The plugin ID to fix
+ * @param targetVersion - The version to normalize all entries to
+ * @returns Number of updated entries and which projects were affected
+ */
+export async function fixPluginVersionMismatch(pluginId, targetVersion) {
+    const registry = await readInstalledPluginsRegistry();
+    const entries = registry.plugins[pluginId];
+    if (!entries || entries.length === 0) {
+        return { updated: 0, projects: [] };
+    }
+    // Find an existing entry with the target version to get the correct installPath
+    const templateEntry = entries.find((e) => e.version === targetVersion);
+    if (!templateEntry) {
+        return { updated: 0, projects: [] };
+    }
+    const targetInstallPath = templateEntry.installPath;
+    const updated = [];
+    for (const entry of entries) {
+        if (entry.version !== targetVersion) {
+            entry.version = targetVersion;
+            entry.installPath = targetInstallPath;
+            entry.lastUpdated = new Date().toISOString();
+            updated.push(entry.projectPath || "(global)");
+        }
+    }
+    if (updated.length > 0) {
+        await writeInstalledPluginsRegistry(registry);
+    }
+    return { updated: updated.length, projects: updated };
+}
+/**
+ * Fix all version mismatches by normalizing each plugin to its latest version.
+ *
+ * @param mismatches - Array of mismatches from checkPluginVersionMismatches
+ * @returns Map of pluginId to FixResult
+ */
+export async function fixAllPluginVersionMismatches(mismatches) {
+    const results = new Map();
+    // Read registry once, apply all fixes, write once
+    const registry = await readInstalledPluginsRegistry();
+    for (const mismatch of mismatches) {
+        const entries = registry.plugins[mismatch.pluginId];
+        if (!entries || entries.length === 0) {
+            results.set(mismatch.pluginId, { updated: 0, projects: [] });
+            continue;
+        }
+        // Use the current project's version as the target (the version the user expects)
+        const targetVersion = mismatch.currentProjectVersion;
+        const templateEntry = entries.find((e) => e.version === targetVersion);
+        if (!templateEntry) {
+            results.set(mismatch.pluginId, { updated: 0, projects: [] });
+            continue;
+        }
+        const targetInstallPath = templateEntry.installPath;
+        const updated = [];
+        for (const entry of entries) {
+            if (entry.version !== targetVersion) {
+                entry.version = targetVersion;
+                entry.installPath = targetInstallPath;
+                entry.lastUpdated = new Date().toISOString();
+                updated.push(entry.projectPath || "(global)");
+            }
+        }
+        results.set(mismatch.pluginId, {
+            updated: updated.length,
+            projects: updated,
+        });
+    }
+    await writeInstalledPluginsRegistry(registry);
+    return results;
+}
+// ── Formatting ───────────────────────────────────────────────────────────────
+/**
+ * Format mismatch info for console output (prerunner).
+ */
+export function formatMismatchWarning(mismatches) {
+    const lines = [];
+    lines.push("WARNING: Plugin version mismatch detected (Claude Code bug #45997)");
+    lines.push("Claude Code loads the first entry from installed_plugins.json for ALL projects.");
+    lines.push("The following plugins will load a different version than what this project has installed:\n");
+    for (const m of mismatches) {
+        const firstProject = m.firstEntryProject
+            ? shortenPath(m.firstEntryProject)
+            : "(global)";
+        lines.push(`  ${m.pluginId}:`);
+        lines.push(`    Loading v${m.firstEntryVersion} (from ${firstProject})`);
+        lines.push(`    Expected v${m.currentProjectVersion} (this project)`);
+    }
+    lines.push("");
+    lines.push(`Bug report: ${BUG_REPORT_URL}`);
+    lines.push("Run claudeup to fix — it can align all projects to the same version.");
+    return lines.join("\n");
+}
+/**
+ * Format mismatch info for TUI display.
+ */
+export function formatMismatchBanner(mismatches) {
+    const parts = mismatches.map((m) => `${m.pluginId}: loading v${m.firstEntryVersion} instead of v${m.currentProjectVersion}`);
+    return `Version mismatch: ${parts.join(", ")}`;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Collect all enabled plugin IDs across all scopes for a project.
+ */
+async function collectEnabledPluginIds(projectPath) {
+    const pluginIds = new Set();
+    try {
+        const global = await getGlobalEnabledPlugins();
+        for (const [id, enabled] of Object.entries(global)) {
+            if (enabled)
+                pluginIds.add(id);
+        }
+    }
+    catch {
+        /* skip unreadable */
+    }
+    try {
+        const project = await getEnabledPlugins(projectPath);
+        for (const [id, enabled] of Object.entries(project)) {
+            if (enabled)
+                pluginIds.add(id);
+        }
+    }
+    catch {
+        /* skip unreadable */
+    }
+    try {
+        const local = await getLocalEnabledPlugins(projectPath);
+        for (const [id, enabled] of Object.entries(local)) {
+            if (enabled)
+                pluginIds.add(id);
+        }
+    }
+    catch {
+        /* skip unreadable */
+    }
+    return pluginIds;
+}
+/**
+ * Normalize a path for comparison (resolve and trailing-slash normalize).
+ */
+function normalizePath(p) {
+    if (!p)
+        return "";
+    return p.replace(/\/+$/, "");
+}
+/**
+ * Shorten a path for display by replacing homedir with ~.
+ */
+function shortenPath(p) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (home && p.startsWith(home)) {
+        return `~${p.slice(home.length)}`;
+    }
+    return p;
+}