claudeup 4.19.0 → 4.22.0

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;
-}

package/src/services/profiles.js

@@ -1,161 +0,0 @@
-import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
-const PROFILES_FILE = "profiles.json";
-// ─── Path helpers ──────────────────────────────────────────────────────────────
-export function getUserProfilesPath() {
-    return path.join(os.homedir(), ".claude", PROFILES_FILE);
-}
-export function getProjectProfilesPath(projectPath) {
-    const base = projectPath ?? process.cwd();
-    return path.join(base, ".claude", PROFILES_FILE);
-}
-// ─── Low-level read/write ──────────────────────────────────────────────────────
-export async function readProfiles(scope, projectPath) {
-    const filePath = scope === "user"
-        ? getUserProfilesPath()
-        : getProjectProfilesPath(projectPath);
-    try {
-        if (await fs.pathExists(filePath)) {
-            const data = await fs.readJson(filePath);
-            if (data.version && data.profiles)
-                return data;
-        }
-    }
-    catch {
-        // fall through to default
-    }
-    return { version: 1, profiles: {} };
-}
-async function writeProfiles(scope, data, projectPath) {
-    const filePath = scope === "user"
-        ? getUserProfilesPath()
-        : getProjectProfilesPath(projectPath);
-    await fs.ensureDir(path.dirname(filePath));
-    await fs.writeJson(filePath, data, { spaces: 2 });
-}
-// ─── CRUD ──────────────────────────────────────────────────────────────────────
-/** Return all profiles from both scopes, merged into a flat list */
-export async function listProfiles(projectPath) {
-    const [user, project] = await Promise.all([
-        readProfiles("user"),
-        readProfiles("project", projectPath),
-    ]);
-    const entries = [];
-    for (const [id, p] of Object.entries(user.profiles)) {
-        entries.push({ id, scope: "user", ...p });
-    }
-    for (const [id, p] of Object.entries(project.profiles)) {
-        entries.push({ id, scope: "project", ...p });
-    }
-    // Sort: user profiles first, then project, each by updatedAt desc
-    entries.sort((a, b) => {
-        if (a.scope !== b.scope)
-            return a.scope === "user" ? -1 : 1;
-        return b.updatedAt.localeCompare(a.updatedAt);
-    });
-    return entries;
-}
-/**
- * Save (create or overwrite) a profile.
- * Returns the generated profile ID.
- */
-export async function saveProfile(name, plugins, scope, projectPath) {
-    const data = await readProfiles(scope, projectPath);
-    const id = generateUniqueId(name, data.profiles);
-    const now = new Date().toISOString();
-    data.profiles[id] = {
-        name,
-        plugins,
-        createdAt: now,
-        updatedAt: now,
-    };
-    await writeProfiles(scope, data, projectPath);
-    return id;
-}
-/**
- * Apply a profile: replaces enabledPlugins in the target settings scope.
- * targetScope is where the settings will be written, independent of where
- * the profile is stored.
- */
-export async function applyProfile(profileId, profileScope, targetScope, projectPath) {
-    const data = await readProfiles(profileScope, projectPath);
-    const profile = data.profiles[profileId];
-    if (!profile)
-        throw new Error(`Profile "${profileId}" not found`);
-    // Import settings functions dynamically to avoid circular deps
-    const { readSettings, writeSettings, readGlobalSettings, writeGlobalSettings, } = await import("./claude-settings.js");
-    if (targetScope === "user") {
-        const settings = await readGlobalSettings();
-        settings.enabledPlugins = { ...profile.plugins };
-        await writeGlobalSettings(settings);
-    }
-    else {
-        // project or local both write to project settings.json
-        const settings = await readSettings(projectPath);
-        settings.enabledPlugins = { ...profile.plugins };
-        await writeSettings(settings, projectPath);
-    }
-}
-/** Rename a profile in-place (preserves id, createdAt) */
-export async function renameProfile(profileId, newName, scope, projectPath) {
-    const data = await readProfiles(scope, projectPath);
-    if (!data.profiles[profileId]) {
-        throw new Error(`Profile "${profileId}" not found in ${scope} scope`);
-    }
-    data.profiles[profileId].name = newName;
-    data.profiles[profileId].updatedAt = new Date().toISOString();
-    await writeProfiles(scope, data, projectPath);
-}
-export async function deleteProfile(profileId, scope, projectPath) {
-    const data = await readProfiles(scope, projectPath);
-    if (!data.profiles[profileId]) {
-        throw new Error(`Profile "${profileId}" not found in ${scope} scope`);
-    }
-    delete data.profiles[profileId];
-    await writeProfiles(scope, data, projectPath);
-}
-// ─── Import / Export ───────────────────────────────────────────────────────────
-/** Serialize a profile to a compact JSON string for clipboard sharing */
-export async function exportProfileToJson(profileId, scope, projectPath) {
-    const data = await readProfiles(scope, projectPath);
-    const profile = data.profiles[profileId];
-    if (!profile)
-        throw new Error(`Profile "${profileId}" not found`);
-    const entry = { id: profileId, scope, ...profile };
-    return JSON.stringify(entry, null, 2);
-}
-/**
- * Parse a clipboard JSON string and save into the specified scope.
- * Returns the saved profile id.
- */
-export async function importProfileFromJson(json, targetScope, projectPath) {
-    let entry;
-    try {
-        entry = JSON.parse(json);
-    }
-    catch {
-        throw new Error("Invalid JSON — could not parse clipboard content");
-    }
-    if (!entry.name || typeof entry.plugins !== "object") {
-        throw new Error("Invalid profile format — expected { name, plugins }");
-    }
-    return saveProfile(entry.name, entry.plugins, targetScope, projectPath);
-}
-// ─── Internal helpers ──────────────────────────────────────────────────────────
-function slugify(name) {
-    return name
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "");
-}
-function generateUniqueId(name, existing) {
-    const base = slugify(name) || "profile";
-    if (!existing[base])
-        return base;
-    let n = 2;
-    while (existing[`${base}-${n}`])
-        n++;
-    return `${base}-${n}`;
-}

package/src/services/settings-manager.js

@@ -1,243 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { readSettings, writeSettings, readGlobalSettings, writeGlobalSettings, } from "./claude-settings.js";
-/** Read the current value of a setting from the given scope */
-export async function readSettingValue(setting, scope, projectPath) {
-    const settings = scope === "user"
-        ? await readGlobalSettings()
-        : await readSettings(projectPath);
-    if (setting.storage.type === "attribution") {
-        // Attribution is an object: { commit: "", pr: "" } means disabled
-        const attr = settings.attribution;
-        if (attr && attr.commit === "" && attr.pr === "") {
-            return "false";
-        }
-        return undefined; // default (enabled)
-    }
-    else if (setting.storage.type === "attribution-text") {
-        // Custom attribution text: read from attribution.commit, strip the Co-Authored-By trailer prefix
-        const attr = settings.attribution;
-        if (!attr || (attr.commit === "" && attr.pr === "")) {
-            // Attribution is disabled or not set — no custom text stored
-            return undefined;
-        }
-        const commit = attr.commit;
-        if (!commit) {
-            return undefined;
-        }
-        // The commit value is "Co-Authored-By: Magus <magus@madappgang.com>\n\n{customText}"
-        // Strip the trailer prefix if present
-        const trailerPrefix = "Co-Authored-By: Magus <magus@madappgang.com>\n\n";
-        if (commit.startsWith(trailerPrefix)) {
-            const text = commit.slice(trailerPrefix.length);
-            return text.length > 0 ? text : undefined;
-        }
-        // If no trailer prefix, the value is the raw text (or Claude default — return undefined)
-        return undefined;
-    }
-    else if (setting.storage.type === "env") {
-        const env = settings.env;
-        return env?.[setting.storage.key];
-    }
-    else {
-        // Direct settings key (supports dot notation like "permissions.defaultMode")
-        const keys = setting.storage.key.split(".");
-        let value = settings;
-        for (const k of keys) {
-            value = value?.[k];
-        }
-        return value !== undefined && value !== null ? String(value) : undefined;
-    }
-}
-/** Write a setting value to the given scope */
-export async function writeSettingValue(setting, value, scope, projectPath) {
-    const settings = scope === "user"
-        ? await readGlobalSettings()
-        : await readSettings(projectPath);
-    if (setting.storage.type === "attribution") {
-        // Boolean toggle: "false" -> write { commit: "", pr: "" }, "true"/undefined -> delete key
-        if (value === "false") {
-            settings.attribution = { commit: "", pr: "" };
-        }
-        else {
-            delete settings.attribution;
-        }
-    }
-    else if (setting.storage.type === "attribution-text") {
-        if (value && value.trim().length > 0) {
-            // Write custom text: commit gets a Co-Authored-By trailer + the text; pr gets the text
-            settings.attribution = {
-                commit: `Co-Authored-By: Magus <magus@madappgang.com>\n\n${value}`,
-                pr: value,
-            };
-        }
-        else {
-            // Empty value: remove attribution key entirely (revert to Claude defaults)
-            delete settings.attribution;
-        }
-    }
-    else if (setting.storage.type === "env") {
-        // Write to the "env" block in settings.json
-        settings.env = settings.env || {};
-        if (value === undefined || value === "" || value === setting.defaultValue) {
-            delete settings.env[setting.storage.key];
-            // Clean up empty env block
-            if (Object.keys(settings.env).length === 0) {
-                delete settings.env;
-            }
-        }
-        else {
-            settings.env[setting.storage.key] = value;
-        }
-    }
-    else {
-        // Direct settings key (supports dot notation)
-        const keys = setting.storage.key.split(".");
-        if (keys.length === 1) {
-            if (value === undefined || value === "") {
-                delete settings[keys[0]];
-            }
-            else {
-                // Try to preserve type: boolean, number, or string
-                settings[keys[0]] = parseSettingValue(value, setting.type);
-            }
-        }
-        else {
-            // Nested key like "permissions.defaultMode"
-            let obj = settings;
-            for (let i = 0; i < keys.length - 1; i++) {
-                obj[keys[i]] = obj[keys[i]] || {};
-                obj = obj[keys[i]];
-            }
-            const lastKey = keys[keys.length - 1];
-            if (value === undefined || value === "") {
-                delete obj[lastKey];
-            }
-            else {
-                obj[lastKey] = parseSettingValue(value, setting.type);
-            }
-        }
-    }
-    if (scope === "user") {
-        await writeGlobalSettings(settings);
-    }
-    else {
-        await writeSettings(settings, projectPath);
-    }
-}
-function parseSettingValue(value, type) {
-    if (type === "boolean") {
-        return value === "true" || value === "1";
-    }
-    // Try number
-    const num = Number(value);
-    if (!Number.isNaN(num) && value.trim() !== "") {
-        return value; // Keep as string for env vars
-    }
-    return value;
-}
-/** Read all setting values for the catalog */
-export async function readAllSettings(catalog, scope, projectPath) {
-    const values = new Map();
-    for (const setting of catalog) {
-        values.set(setting.id, await readSettingValue(setting, scope, projectPath));
-    }
-    return values;
-}
-/** Read all setting values from both scopes simultaneously */
-export async function readAllSettingsBothScopes(catalog, projectPath) {
-    const result = new Map();
-    const [userValues, projectValues] = await Promise.all([
-        readAllSettings(catalog, "user", projectPath),
-        readAllSettings(catalog, "project", projectPath),
-    ]);
-    for (const setting of catalog) {
-        result.set(setting.id, {
-            user: userValues.get(setting.id),
-            project: projectValues.get(setting.id),
-        });
-    }
-    return result;
-}
-/**
- * Discover available output styles from installed plugins.
- * Scans enabled plugins for outputStyles entries and *-output-style plugin names.
- * Returns options suitable for a select setting.
- */
-export async function discoverOutputStyles(projectPath) {
-    const styles = [
-        { label: "Default", value: "" },
-    ];
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const cacheDir = path.join(homeDir, ".claude", "plugins", "cache");
-    // Collect enabled plugins from both scopes
-    const enabledPlugins = new Set();
-    try {
-        const userSettings = await readGlobalSettings();
-        for (const [k, v] of Object.entries(userSettings.enabledPlugins || {})) {
-            if (v)
-                enabledPlugins.add(k);
-        }
-    }
-    catch { }
-    try {
-        const projSettings = await readSettings(projectPath);
-        for (const [k, v] of Object.entries(projSettings.enabledPlugins || {})) {
-            if (v)
-                enabledPlugins.add(k);
-        }
-    }
-    catch { }
-    const seen = new Set();
-    for (const pluginId of enabledPlugins) {
-        const [pluginName, marketplace] = pluginId.split("@");
-        // Check if this is a dedicated output-style plugin (e.g. "explanatory-output-style")
-        if (pluginName.endsWith("-output-style")) {
-            const styleName = pluginName
-                .replace(/-output-style$/, "")
-                .split("-")
-                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                .join(" ");
-            if (!seen.has(styleName)) {
-                seen.add(styleName);
-                styles.push({ label: styleName, value: styleName });
-            }
-            continue;
-        }
-        // Check plugin.json for outputStyles entries
-        if (!marketplace)
-            continue;
-        const pluginDir = path.join(cacheDir, marketplace, pluginName);
-        try {
-            const versions = fs.readdirSync(pluginDir).sort();
-            const latest = versions[versions.length - 1];
-            if (!latest)
-                continue;
-            const manifestPath = path.join(pluginDir, latest, "plugin.json");
-            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-            const outputStyles = manifest.outputStyles;
-            if (!outputStyles?.length)
-                continue;
-            for (const stylePath of outputStyles) {
-                const fullPath = path.join(pluginDir, latest, stylePath);
-                try {
-                    const content = fs.readFileSync(fullPath, "utf-8");
-                    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-                    if (fmMatch) {
-                        const nameMatch = fmMatch[1].match(/^name:\s*(.+)$/m);
-                        if (nameMatch) {
-                            const name = nameMatch[1].trim();
-                            if (!seen.has(name)) {
-                                seen.add(name);
-                                styles.push({ label: name, value: name });
-                            }
-                        }
-                    }
-                }
-                catch { }
-            }
-        }
-        catch { }
-    }
-    return styles;
-}