claudeup 4.18.0 → 4.22.0

package/src/services/plugin-setup.js

@@ -1,444 +0,0 @@
-/**
- * Plugin system dependency installer
- *
- * Auto-detects available package managers and installs plugin dependencies
- * declared in plugin.json's "setup" section.
- *
- * Supported managers:
- * - pip: Python packages (auto-detects uv > pip3 > pip)
- * - 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"],
- *     "go": ["github.com/MadAppGang/tmux-mcp@latest"],
- *     "required": ["tmux"]
- *   }
- * }
- */
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
-import { which } from "../utils/command-utils.js";
-const execFileAsync = promisify(execFile);
-/**
- * Run a command and return success/failure
- */
-async function run(cmd, args, timeoutMs = 120000) {
-    try {
-        const { stdout, stderr } = await execFileAsync(cmd, args, {
-            timeout: timeoutMs,
-        });
-        return { ok: true, stdout: stdout.trim(), stderr: stderr.trim() };
-    }
-    catch (error) {
-        const e = error;
-        return {
-            ok: false,
-            stdout: e.stdout?.trim() || "",
-            stderr: e.stderr?.trim() || e.message || "unknown error",
-        };
-    }
-}
-/**
- * Detect the best available Python package installer
- * Prefers: uv > pip3 > pip
- */
-async function detectPipCommand() {
-    // Prefer uv (fast, modern)
-    if (await which("uv")) {
-        return {
-            cmd: "uv",
-            args: ["pip", "install", "--system", "--break-system-packages"],
-        };
-    }
-    // Fall back to pip3
-    if (await which("pip3")) {
-        return {
-            cmd: "pip3",
-            args: ["install", "--break-system-packages"],
-        };
-    }
-    // Fall back to pip
-    if (await which("pip")) {
-        return {
-            cmd: "pip",
-            args: ["install", "--break-system-packages"],
-        };
-    }
-    return null;
-}
-/**
- * Check if a Python package is already installed
- */
-async function isPythonPackageInstalled(pkg) {
-    // Convert package name to importable module name (e.g., browser-use → browser_use)
-    const moduleName = pkg.replace(/-/g, "_");
-    const result = await run("python3", ["-c", `import ${moduleName}`]);
-    return result.ok;
-}
-/**
- * Check if a binary is available in PATH
- */
-async function isBinaryAvailable(name) {
-    return (await which(name)) !== null;
-}
-/**
- * Extract binary name from a brew formula or npm package
- * e.g., "memextech/tap/ht-mcp" → "ht-mcp"
- */
-function extractBinaryName(pkg) {
-    return pkg.split("/").pop() || pkg;
-}
-/**
- * Install pip packages
- */
-async function installPipPackages(packages, result) {
-    const pip = await detectPipCommand();
-    if (!pip) {
-        for (const pkg of packages) {
-            result.failed.push({ pkg: `pip:${pkg}`, error: "No pip/uv found" });
-        }
-        return;
-    }
-    // Filter out already installed
-    const toInstall = [];
-    for (const pkg of packages) {
-        if (await isPythonPackageInstalled(pkg)) {
-            result.skipped.push(`pip:${pkg}`);
-        }
-        else {
-            toInstall.push(pkg);
-        }
-    }
-    if (toInstall.length === 0)
-        return;
-    // Install all at once
-    const { ok, stderr } = await run(pip.cmd, [...pip.args, ...toInstall]);
-    if (ok) {
-        for (const pkg of toInstall) {
-            result.installed.push(`pip:${pkg}`);
-        }
-    }
-    else {
-        for (const pkg of toInstall) {
-            result.failed.push({ pkg: `pip:${pkg}`, error: stderr });
-        }
-    }
-}
-/**
- * Install brew packages
- */
-async function installBrewPackages(packages, result) {
-    const brewPath = await which("brew");
-    if (!brewPath) {
-        for (const pkg of packages) {
-            result.failed.push({
-                pkg: `brew:${pkg}`,
-                error: "Homebrew not installed",
-            });
-        }
-        return;
-    }
-    for (const pkg of packages) {
-        const binaryName = extractBinaryName(pkg);
-        if (await isBinaryAvailable(binaryName)) {
-            result.skipped.push(`brew:${pkg}`);
-            continue;
-        }
-        const { ok, stderr } = await run(brewPath, ["install", pkg]);
-        if (ok) {
-            result.installed.push(`brew:${pkg}`);
-        }
-        else {
-            result.failed.push({ pkg: `brew:${pkg}`, error: stderr });
-        }
-    }
-}
-/**
- * Detect the best available Node.js package installer for globals
- * Prefers: bun > npm
- */
-async function detectNpmCommand() {
-    const bunPath = await which("bun");
-    if (bunPath) {
-        return { cmd: bunPath, args: ["install", "-g"], label: "bun" };
-    }
-    const npmPath = await which("npm");
-    if (npmPath) {
-        return { cmd: npmPath, args: ["install", "-g"], label: "npm" };
-    }
-    return null;
-}
-/**
- * Install global Node.js packages (prefers bun > npm)
- */
-async function installNpmPackages(packages, result) {
-    const installer = await detectNpmCommand();
-    if (!installer) {
-        for (const pkg of packages) {
-            result.failed.push({ pkg: `npm:${pkg}`, error: "No bun or npm found" });
-        }
-        return;
-    }
-    for (const pkg of packages) {
-        if (await isBinaryAvailable(pkg)) {
-            result.skipped.push(`npm:${pkg}`);
-            continue;
-        }
-        const { ok, stderr } = await run(installer.cmd, [...installer.args, pkg]);
-        if (ok) {
-            result.installed.push(`${installer.label}:${pkg}`);
-        }
-        else {
-            result.failed.push({ pkg: `${installer.label}:${pkg}`, error: stderr });
-        }
-    }
-}
-/**
- * Install cargo packages
- */
-async function installCargoPackages(packages, result) {
-    const cargoPath = await which("cargo");
-    if (!cargoPath) {
-        for (const pkg of packages) {
-            result.failed.push({ pkg: `cargo:${pkg}`, error: "cargo not found" });
-        }
-        return;
-    }
-    for (const pkg of packages) {
-        if (await isBinaryAvailable(pkg)) {
-            result.skipped.push(`cargo:${pkg}`);
-            continue;
-        }
-        const { ok, stderr } = await run(cargoPath, ["install", pkg], 300000);
-        if (ok) {
-            result.installed.push(`cargo:${pkg}`);
-        }
-        else {
-            result.failed.push({ pkg: `cargo:${pkg}`, error: stderr });
-        }
-    }
-}
-/**
- * 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
- */
-export async function getPluginSetupConfig(marketplace, pluginName) {
-    const cacheDir = path.join(os.homedir(), ".claude", "plugins", "cache", marketplace);
-    // Find the plugin directory (versioned)
-    if (!(await fs.pathExists(cacheDir)))
-        return null;
-    const entries = await fs.readdir(cacheDir);
-    // Look for the plugin name directory
-    const pluginDir = entries.find((e) => e === pluginName);
-    if (!pluginDir)
-        return null;
-    const pluginPath = path.join(cacheDir, pluginDir);
-    const stat = await fs.stat(pluginPath);
-    if (!stat.isDirectory())
-        return null;
-    // Find the version directory
-    const versions = await fs.readdir(pluginPath);
-    if (versions.length === 0)
-        return null;
-    // Use the latest version directory
-    const latestVersion = versions.sort().pop();
-    const manifestPath = path.join(pluginPath, latestVersion, "plugin.json");
-    if (!(await fs.pathExists(manifestPath)))
-        return null;
-    try {
-        const manifest = await fs.readJson(manifestPath);
-        return manifest.setup || null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Read setup config from a local plugin directory (marketplace source)
- */
-export async function getPluginSetupFromSource(marketplace, pluginName) {
-    const marketplaceDir = path.join(os.homedir(), ".claude", "plugins", "marketplaces", marketplace);
-    if (!(await fs.pathExists(marketplaceDir)))
-        return null;
-    // Try common plugin locations
-    for (const subdir of ["plugins", ""]) {
-        const pluginJson = subdir
-            ? path.join(marketplaceDir, subdir, pluginName, "plugin.json")
-            : path.join(marketplaceDir, pluginName, "plugin.json");
-        if (await fs.pathExists(pluginJson)) {
-            try {
-                const manifest = await fs.readJson(pluginJson);
-                return manifest.setup || null;
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Install all dependencies declared in a plugin's setup config.
- * Auto-detects available package managers.
- */
-export async function installPluginDeps(setup) {
-    const result = {
-        installed: [],
-        skipped: [],
-        failed: [],
-    };
-    if (setup.pip?.length) {
-        await installPipPackages(setup.pip, result);
-    }
-    if (setup.brew?.length) {
-        await installBrewPackages(setup.brew, result);
-    }
-    if (setup.npm?.length) {
-        await installNpmPackages(setup.npm, result);
-    }
-    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;
-}
-/**
- * Check which dependencies from a setup config are missing.
- * Returns a filtered SetupConfig with only missing deps.
- */
-export async function checkMissingDeps(setup) {
-    const missing = {};
-    if (setup.pip?.length) {
-        const missingPip = [];
-        for (const pkg of setup.pip) {
-            if (!(await isPythonPackageInstalled(pkg))) {
-                missingPip.push(pkg);
-            }
-        }
-        if (missingPip.length > 0)
-            missing.pip = missingPip;
-    }
-    if (setup.brew?.length) {
-        const missingBrew = [];
-        for (const pkg of setup.brew) {
-            const bin = extractBinaryName(pkg);
-            if (!(await isBinaryAvailable(bin))) {
-                missingBrew.push(pkg);
-            }
-        }
-        if (missingBrew.length > 0)
-            missing.brew = missingBrew;
-    }
-    if (setup.npm?.length) {
-        const missingNpm = [];
-        for (const pkg of setup.npm) {
-            if (!(await isBinaryAvailable(pkg))) {
-                missingNpm.push(pkg);
-            }
-        }
-        if (missingNpm.length > 0)
-            missing.npm = missingNpm;
-    }
-    if (setup.cargo?.length) {
-        const missingCargo = [];
-        for (const pkg of setup.cargo) {
-            if (!(await isBinaryAvailable(pkg))) {
-                missingCargo.push(pkg);
-            }
-        }
-        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-version-check.js

@@ -1,262 +0,0 @@
-/**
- * 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 modal display.
- * Returns a multi-line string suitable for a modal message.
- */
-export function formatMismatchModal(mismatches) {
-    const lines = [];
-    lines.push("Your plugins will not work correctly in this project.");
-    lines.push("");
-    lines.push("Due to a Claude Code bug, the plugin loader ignores");
-    lines.push("per-project versions and loads an older version instead.");
-    lines.push("Commands, MCP tools, and skills will be outdated.");
-    lines.push("");
-    for (const m of mismatches) {
-        const name = m.pluginId.split("@")[0];
-        lines.push(`  ${name}: v${m.firstEntryVersion} loaded, expected v${m.currentProjectVersion}`);
-    }
-    lines.push("");
-    lines.push("Fix: align all projects to the same version.");
-    lines.push("Details: github.com/anthropics/claude-code/issues/45997");
-    return lines.join("\n");
-}
-// ── 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;
-}