claudeup 4.19.0 → 4.23.0

package/src/services/plugin-setup.js

@@ -1,499 +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;
-}
-/**
- * Extract the pinned version from a Go module path, or null when unpinned.
- * e.g., "github.com/MadAppGang/tmux-mcp@v1.6.2" → "v1.6.2"
- *       "github.com/MadAppGang/tmux-mcp@latest" → null (a moving target)
- *       "github.com/user/tool"                  → null
- */
-export function extractGoVersion(pkg) {
-    const at = pkg.lastIndexOf("@");
-    if (at === -1)
-        return null;
-    const version = pkg.slice(at + 1);
-    if (version === "" || version === "latest")
-        return null;
-    return version;
-}
-/** Normalize a semver-ish string for comparison: trim and drop a leading "v". */
-function normalizeVersion(v) {
-    return v.trim().replace(/^v/, "");
-}
-/**
- * Read an installed binary's version via `<binary> --version`, normalized, or
- * null if it produced no usable version string. Used to tell whether a pinned Go
- * dependency is already at the right version.
- */
-async function getInstalledBinaryVersion(binaryName) {
-    const { ok, stdout } = await run(binaryName, ["--version"], 10000);
-    if (!ok || !stdout)
-        return null;
-    const match = stdout.split("\n")[0].match(/v?\d+\.\d+\.\d+[^\s]*/);
-    return match ? normalizeVersion(match[0]) : null;
-}
-/**
- * Decide whether a Go dependency needs (re)installing. This is what makes a
- * plugin *update* actually update its binary: without a version check an
- * already-present binary is skipped forever, so a bumped plugin never pulls the
- * new binary.
- *
- *  - binary absent                                    → yes
- *  - pinned version, installed reports the same one   → no
- *  - pinned version, installed reports a different one → yes
- *  - pinned version, installed version can't be read  → yes (can't confirm the
- *    pin, so reinstall to be safe)
- *  - unpinned (@latest) and present                   → no (a moving target
- *    can't be verified without a network round-trip)
- */
-export async function goDepNeedsInstall(pkg) {
-    const binaryName = extractGoBinaryName(pkg);
-    if (!(await isBinaryAvailable(binaryName)))
-        return true;
-    const pinned = extractGoVersion(pkg);
-    if (!pinned)
-        return false;
-    const installed = await getInstalledBinaryVersion(binaryName);
-    if (installed === null)
-        return true;
-    return normalizeVersion(pinned) !== installed;
-}
-/**
- * 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) {
-        if (!(await goDepNeedsInstall(pkg))) {
-            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) {
-            if (await goDepNeedsInstall(pkg)) {
-                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;
-}