claudeup 4.19.0 → 4.22.0

package/src/services/local-marketplace.js

@@ -1,339 +0,0 @@
-import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
-import { execSync } from "node:child_process";
-const CLAUDE_PLUGINS_DIR = path.join(os.homedir(), ".claude", "plugins", "marketplaces");
-const KNOWN_MARKETPLACES_FILE = path.join(os.homedir(), ".claude", "plugins", "known_marketplaces.json");
-/**
- * Read known_marketplaces.json (Claude Code's internal marketplace tracking)
- */
-async function readKnownMarketplaces() {
-    try {
-        if (await fs.pathExists(KNOWN_MARKETPLACES_FILE)) {
-            return await fs.readJson(KNOWN_MARKETPLACES_FILE);
-        }
-    }
-    catch {
-        // Return empty if can't read
-    }
-    return {};
-}
-/**
- * Get git remote URL from a marketplace directory
- */
-function getGitRemote(marketplacePath) {
-    try {
-        const gitDir = path.join(marketplacePath, ".git");
-        if (!fs.existsSync(gitDir))
-            return undefined;
-        const result = execSync("git remote get-url origin", {
-            cwd: marketplacePath,
-            encoding: "utf-8",
-            timeout: 5000,
-        }).trim();
-        // Convert SSH URL to HTTPS format: git@github.com:user/repo.git -> user/repo
-        if (result.startsWith("git@github.com:")) {
-            return result.replace("git@github.com:", "").replace(/\.git$/, "");
-        }
-        // HTTPS URL: https://github.com/user/repo -> user/repo
-        if (result.includes("github.com")) {
-            const match = result.match(/github\.com[/:]([^/]+\/[^/\s.]+)/);
-            if (match)
-                return match[1].replace(/\.git$/, "");
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Scan a single marketplace directory and return marketplace info
- */
-async function scanSingleMarketplace(marketplacePath, marketplaceName) {
-    const manifestPath = path.join(marketplacePath, ".claude-plugin", "marketplace.json");
-    if (!(await fs.pathExists(manifestPath)))
-        return null;
-    try {
-        const manifest = await fs.readJson(manifestPath);
-        const gitRepo = getGitRemote(marketplacePath);
-        const plugins = [];
-        const validManifestPlugins = [];
-        let manifestModified = false;
-        if (manifest.plugins && Array.isArray(manifest.plugins)) {
-            for (const plugin of manifest.plugins) {
-                // Try to scan plugin directory for component counts
-                let agents = [];
-                let commands = [];
-                let skills = [];
-                let mcpServers = [];
-                // Handle both string sources (local paths) and object sources (remote URLs)
-                const sourceStr = typeof plugin.source === "string" ? plugin.source : null;
-                if (sourceStr) {
-                    const pluginPath = path.join(marketplacePath, sourceStr.replace("./", ""));
-                    // Remove plugins whose source directory doesn't exist
-                    if (!(await fs.pathExists(pluginPath))) {
-                        manifestModified = true;
-                        continue;
-                    }
-                    try {
-                        // Scan for agents
-                        const agentsDir = path.join(pluginPath, "agents");
-                        if (await fs.pathExists(agentsDir)) {
-                            const agentFiles = await fs.readdir(agentsDir);
-                            agents = agentFiles
-                                .filter((f) => f.endsWith(".md"))
-                                .map((f) => f.replace(".md", ""));
-                        }
-                        // Scan for commands
-                        const commandsDir = path.join(pluginPath, "commands");
-                        if (await fs.pathExists(commandsDir)) {
-                            const cmdFiles = await fs.readdir(commandsDir);
-                            commands = cmdFiles
-                                .filter((f) => f.endsWith(".md"))
-                                .map((f) => f.replace(".md", ""));
-                        }
-                        // Scan for skills
-                        const skillsDir = path.join(pluginPath, "skills");
-                        if (await fs.pathExists(skillsDir)) {
-                            const skillFiles = await fs.readdir(skillsDir);
-                            skills = skillFiles.filter((f) => f.endsWith(".md") ||
-                                fs.statSync(path.join(skillsDir, f)).isDirectory());
-                        }
-                        // Scan for MCP servers
-                        const mcpDir = path.join(pluginPath, "mcp-servers");
-                        if (await fs.pathExists(mcpDir)) {
-                            const mcpFiles = await fs.readdir(mcpDir);
-                            mcpServers = mcpFiles
-                                .filter((f) => f.endsWith(".json"))
-                                .map((f) => f.replace(".json", ""));
-                        }
-                    }
-                    catch {
-                        // Ignore scan errors
-                    }
-                }
-                validManifestPlugins.push(plugin);
-                plugins.push({
-                    name: plugin.name,
-                    version: plugin.version || "0.0.0",
-                    description: plugin.description || "",
-                    source: plugin.source,
-                    category: plugin.category,
-                    author: plugin.author,
-                    strict: plugin.strict,
-                    lspServers: plugin.lspServers,
-                    agents,
-                    commands,
-                    skills,
-                    mcpServers,
-                });
-            }
-        }
-        // Update marketplace.json if we removed invalid plugins
-        if (manifestModified) {
-            manifest.plugins = validManifestPlugins;
-            await fs.writeJson(manifestPath, manifest, { spaces: 2 });
-        }
-        return {
-            name: manifest.name || marketplaceName,
-            description: manifest.description || manifest.metadata?.description || "",
-            plugins,
-            gitRepo,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Scan local marketplace cache and return marketplace info
- * Includes both:
- * - Marketplaces in ~/.claude/plugins/marketplaces/
- * - Directory-based marketplaces from known_marketplaces.json
- */
-export async function scanLocalMarketplaces() {
-    const marketplaces = new Map();
-    // 1. Scan marketplaces from the standard directory
-    if (await fs.pathExists(CLAUDE_PLUGINS_DIR)) {
-        try {
-            const entries = await fs.readdir(CLAUDE_PLUGINS_DIR, {
-                withFileTypes: true,
-            });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, entry.name);
-                const marketplace = await scanSingleMarketplace(marketplacePath, entry.name);
-                if (marketplace) {
-                    marketplaces.set(entry.name, marketplace);
-                }
-            }
-        }
-        catch {
-            // Ignore read errors
-        }
-    }
-    // 2. Add directory-based marketplaces from known_marketplaces.json
-    try {
-        const known = await readKnownMarketplaces();
-        for (const [name, entry] of Object.entries(known)) {
-            // Only add if it's a directory source AND not already in the map
-            if (entry.source.source === "directory" &&
-                entry.installLocation &&
-                !marketplaces.has(name)) {
-                if (await fs.pathExists(entry.installLocation)) {
-                    const marketplace = await scanSingleMarketplace(entry.installLocation, name);
-                    if (marketplace) {
-                        marketplaces.set(name, marketplace);
-                    }
-                }
-            }
-        }
-    }
-    catch {
-        // Ignore errors reading known_marketplaces
-    }
-    return marketplaces;
-}
-/**
- * Get a specific local marketplace by name
- */
-export async function getLocalMarketplace(name) {
-    const marketplaces = await scanLocalMarketplaces();
-    return marketplaces.get(name);
-}
-/**
- * Check if a marketplace exists in local cache
- */
-export async function hasLocalMarketplace(name) {
-    const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, name);
-    const manifestPath = path.join(marketplacePath, ".claude-plugin", "marketplace.json");
-    return fs.pathExists(manifestPath);
-}
-/**
- * Repair a plugin's plugin.json by adding missing agents/commands/skills arrays
- * based on what files exist on disk.
- *
- * This fixes plugins where the author forgot to add the arrays to plugin.json,
- * causing Claude Code to not load the agents/commands even though files exist.
- */
-export async function repairPluginJson(pluginPath) {
-    const pluginJsonPath = path.join(pluginPath, ".claude-plugin", "plugin.json");
-    const pluginName = path.basename(pluginPath);
-    const result = {
-        repaired: false,
-        pluginName,
-        added: { agents: [], commands: [], skills: [] },
-    };
-    if (!(await fs.pathExists(pluginJsonPath))) {
-        return result;
-    }
-    try {
-        const pluginJson = await fs.readJson(pluginJsonPath);
-        let modified = false;
-        // Scan and add agents if array is missing
-        const agentsDir = path.join(pluginPath, "agents");
-        if (await fs.pathExists(agentsDir)) {
-            const files = (await fs.readdir(agentsDir))
-                .filter((f) => f.endsWith(".md"))
-                .map((f) => `./agents/${f}`);
-            if (files.length > 0 && !pluginJson.agents) {
-                pluginJson.agents = files;
-                result.added.agents = files;
-                modified = true;
-            }
-        }
-        // Scan and add commands if array is missing
-        const commandsDir = path.join(pluginPath, "commands");
-        if (await fs.pathExists(commandsDir)) {
-            const files = (await fs.readdir(commandsDir))
-                .filter((f) => f.endsWith(".md"))
-                .map((f) => `./commands/${f}`);
-            if (files.length > 0 && !pluginJson.commands) {
-                pluginJson.commands = files;
-                result.added.commands = files;
-                modified = true;
-            }
-        }
-        // Scan and add skills if array is missing
-        const skillsDir = path.join(pluginPath, "skills");
-        if (await fs.pathExists(skillsDir)) {
-            const entries = await fs.readdir(skillsDir, { withFileTypes: true });
-            const skills = entries
-                .filter((e) => e.isDirectory() || e.name.endsWith(".md"))
-                .map((e) => `./skills/${e.name}`);
-            if (skills.length > 0 && !pluginJson.skills) {
-                pluginJson.skills = skills;
-                result.added.skills = skills;
-                modified = true;
-            }
-        }
-        if (modified) {
-            await fs.writeJson(pluginJsonPath, pluginJson, { spaces: 2 });
-            result.repaired = true;
-        }
-    }
-    catch {
-        // Ignore repair errors for individual plugins
-    }
-    return result;
-}
-/**
- * Repair all plugins in a marketplace
- */
-export async function repairMarketplacePlugins(marketplaceName) {
-    const result = {
-        marketplace: marketplaceName,
-        repaired: [],
-    };
-    const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
-    const manifestPath = path.join(marketplacePath, ".claude-plugin", "marketplace.json");
-    if (!(await fs.pathExists(manifestPath))) {
-        return result;
-    }
-    try {
-        const manifest = await fs.readJson(manifestPath);
-        if (manifest.plugins && Array.isArray(manifest.plugins)) {
-            for (const plugin of manifest.plugins) {
-                if (plugin.source) {
-                    const pluginPath = path.join(marketplacePath, plugin.source.replace("./", ""));
-                    const repairResult = await repairPluginJson(pluginPath);
-                    if (repairResult.repaired) {
-                        result.repaired.push(repairResult);
-                    }
-                }
-            }
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return result;
-}
-/**
- * Repair all plugins in all marketplaces
- */
-export async function repairAllMarketplaces() {
-    const results = [];
-    if (!(await fs.pathExists(CLAUDE_PLUGINS_DIR))) {
-        return results;
-    }
-    try {
-        const entries = await fs.readdir(CLAUDE_PLUGINS_DIR, {
-            withFileTypes: true,
-        });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const repairResult = await repairMarketplacePlugins(entry.name);
-            if (repairResult.repaired.length > 0) {
-                results.push(repairResult);
-            }
-        }
-    }
-    catch {
-        // Return empty on error
-    }
-    return results;
-}

package/src/services/marketplace-fetcher.js

@@ -1,96 +0,0 @@
-/**
- * Marketplace.json fetcher with offline fallback.
- *
- * Extracted from `plugin-manager.ts` so the fetch + fallback logic can be
- * unit-tested without dragging in claude-settings.ts's module-level
- * `os.homedir()` constants (which contaminate the test suite when
- * imported via plugin-manager.ts).
- */
-import { isValidGitHubRepo } from "../utils/string-utils.js";
-// Session-level cache for fetched marketplace data (no TTL - persists until explicit refresh)
-const marketplaceCache = new Map();
-export function clearMarketplaceCache() {
-    marketplaceCache.clear();
-}
-export async function fetchMarketplacePlugins(marketplaceName, repo) {
-    // Check cache first - session-level, no TTL
-    const cached = marketplaceCache.get(marketplaceName);
-    if (cached) {
-        return cached;
-    }
-    // Validate repo format to prevent SSRF
-    if (!isValidGitHubRepo(repo)) {
-        console.error(`Invalid GitHub repo format: ${repo}`);
-        return [];
-    }
-    try {
-        // Fetch marketplace.json from GitHub
-        const url = `https://raw.githubusercontent.com/${repo}/main/.claude-plugin/marketplace.json`;
-        const response = await fetch(url, {
-            signal: AbortSignal.timeout(10000), // 10s timeout
-        });
-        if (!response.ok) {
-            console.error(`Failed to fetch marketplace: ${response.status}`);
-            return [];
-        }
-        // Validate content-type
-        const contentType = response.headers.get("content-type");
-        if (contentType &&
-            !contentType.includes("application/json") &&
-            !contentType.includes("text/plain")) {
-            console.error(`Invalid content-type for marketplace: ${contentType}`);
-            return [];
-        }
-        const data = (await response.json());
-        const plugins = [];
-        if (data.plugins && Array.isArray(data.plugins)) {
-            for (const plugin of data.plugins) {
-                plugins.push({
-                    name: plugin.name,
-                    version: plugin.version || null,
-                    description: plugin.description || "",
-                    category: plugin.category,
-                    author: plugin.author,
-                    homepage: plugin.homepage,
-                    tags: plugin.tags,
-                });
-            }
-        }
-        // Cache the result (session-level)
-        marketplaceCache.set(marketplaceName, plugins);
-        return plugins;
-    }
-    catch (error) {
-        console.error(`Error fetching marketplace ${marketplaceName}:`, error);
-        return [];
-    }
-}
-/**
- * Resolve marketplace plugins with offline fallback.
- *
- * Calls `fetchMarketplacePlugins` (which hits GitHub) and, when it returns
- * empty AND a local marketplace cache exists for the same name, falls back
- * to the cached plugin manifest. This prevents every installed plugin from
- * being flagged `isOrphaned: true` (and rendered "deprecated") whenever the
- * machine can't reach `raw.githubusercontent.com` — the local cache already
- * has the data, it just wasn't being consulted as a fallback.
- *
- * The two shapes are nearly identical; we drop a couple of LocalMarketplacePlugin
- * fields (lspServers, agents, etc.) that MarketplacePlugin doesn't carry
- * since the caller doesn't read them at this layer.
- */
-export async function resolveMarketplacePlugins(mpName, repo, localMarketplaces) {
-    const remote = await fetchMarketplacePlugins(mpName, repo);
-    if (remote.length > 0)
-        return remote;
-    const local = localMarketplaces.get(mpName);
-    if (!local || local.plugins.length === 0)
-        return remote;
-    return local.plugins.map((p) => ({
-        name: p.name,
-        version: p.version,
-        description: p.description,
-        category: p.category,
-        author: p.author,
-    }));
-}

package/src/services/marketplace-sync.js

@@ -1,94 +0,0 @@
-/**
- * Marketplace sync service
- *
- * Auto-registers marketplaces that are referenced by `enabledPlugins`
- * in any settings scope (global, project, local) but are not installed
- * locally. Fixes the "new employee clones repo with committed .claude/
- * settings but has never run `claude plugin marketplace add`" scenario.
- *
- * IMPORTANT: Only uses `marketplace add` (never `marketplace update`).
- * Claude Code's `marketplace update` calls cacheMarketplaceFromGit()
- * which deletes the marketplace directory before re-cloning. If the
- * clone fails (network, auth, timeout), the directory stays permanently
- * deleted. See ai-docs/plugin-marketplace-bug-investigation.md.
- */
-import fs from "fs-extra";
-import path from "node:path";
-import os from "node:os";
-import { getGlobalEnabledPlugins, getEnabledPlugins, getLocalEnabledPlugins, isMarketplaceRegistered, } from "./claude-settings.js";
-import { parsePluginId } from "../utils/string-utils.js";
-import { defaultMarketplaces } from "../data/marketplaces.js";
-import { addMarketplace } from "./claude-cli.js";
-const MARKETPLACES_DIR = path.join(os.homedir(), ".claude", "plugins", "marketplaces");
-/**
- * Collect unique marketplace names from enabled plugins across all settings
- * scopes. When `projectPath` is provided, project and local scopes are
- * included; otherwise only the global scope is scanned.
- */
-export async function getReferencedMarketplaces(projectPath) {
-    const marketplaceNames = new Set();
-    const allPluginIds = new Set();
-    try {
-        const global = await getGlobalEnabledPlugins();
-        for (const id of Object.keys(global))
-            allPluginIds.add(id);
-    }
-    catch {
-        /* skip if unreadable */
-    }
-    if (projectPath) {
-        try {
-            const project = await getEnabledPlugins(projectPath);
-            for (const id of Object.keys(project))
-                allPluginIds.add(id);
-        }
-        catch {
-            /* skip if unreadable */
-        }
-        try {
-            const local = await getLocalEnabledPlugins(projectPath);
-            for (const id of Object.keys(local))
-                allPluginIds.add(id);
-        }
-        catch {
-            /* skip if unreadable */
-        }
-    }
-    for (const pluginId of allPluginIds) {
-        const parsed = parsePluginId(pluginId);
-        if (parsed)
-            marketplaceNames.add(parsed.marketplace);
-    }
-    return marketplaceNames;
-}
-/** Re-exported for convenience — canonical implementation lives in claude-settings. */
-export { isMarketplaceRegistered };
-/**
- * Register any referenced marketplaces that are missing locally.
- * Looks up the GitHub repo in `defaultMarketplaces` and calls
- * `claude plugin marketplace add` for each. Always writes to the global
- * registry (`~/.claude/plugins/known_marketplaces.json`) — scope only
- * controls which settings are scanned to build the reference list.
- *
- * Returns the names of marketplaces that were successfully added.
- */
-export async function autoAddMissingMarketplaces(projectPath) {
-    const referenced = await getReferencedMarketplaces(projectPath);
-    const added = [];
-    for (const mpName of referenced) {
-        const mpDir = path.join(MARKETPLACES_DIR, mpName);
-        if (await fs.pathExists(mpDir))
-            continue;
-        const defaultMp = defaultMarketplaces.find((m) => m.name === mpName);
-        if (!defaultMp?.source.repo)
-            continue;
-        try {
-            await addMarketplace(defaultMp.source.repo);
-            added.push(mpName);
-        }
-        catch (error) {
-            console.warn(`⚠ Failed to auto-add marketplace ${mpName}:`, error instanceof Error ? error.message : "Unknown error");
-        }
-    }
-    return added;
-}

package/src/services/mcp-registry.js

@@ -1,87 +0,0 @@
-// Official Model Context Protocol Registry
-// API Docs: https://registry.modelcontextprotocol.io
-const MCP_REGISTRY_API = "https://registry.modelcontextprotocol.io/v0";
-export async function searchMcpServers(options = {}) {
-    const { query = "", limit = 20, cursor } = options;
-    const params = new URLSearchParams();
-    if (query)
-        params.set("query", query);
-    params.set("limit", String(limit));
-    if (cursor)
-        params.set("cursor", cursor);
-    const url = `${MCP_REGISTRY_API}/servers?${params.toString()}`;
-    const response = await fetch(url, {
-        headers: {
-            Accept: "application/json",
-        },
-    });
-    if (!response.ok) {
-        throw new Error(`MCP Registry API error: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    // The official registry returns data in a nested format:
-    // { servers: [{ server: {...}, _meta: {...} }] }
-    // Convert it to match our expected McpRegistryResponse format
-    const servers = (data.servers || [])
-        .map((item) => {
-        const server = item.server || item; // Handle both nested and flat structures
-        const meta = item._meta?.["io.modelcontextprotocol.registry/official"];
-        // Get URL from remotes (HTTP) or construct from packages
-        let url = "";
-        if (server.remotes?.length > 0) {
-            url = server.remotes[0].url;
-        }
-        else if (server.packages?.length > 0) {
-            // For package-based servers, use the package identifier as reference
-            const pkg = server.packages[0];
-            url = `${pkg.registryType}:${pkg.identifier}`;
-        }
-        return {
-            name: server.name,
-            url,
-            short_description: server.description || "No description",
-            version: server.version,
-            source_code_url: server.repository?.url,
-            package_registry: server.packages?.[0]?.registryType,
-            published_at: meta?.publishedAt,
-        };
-    })
-        // Filter out servers without name or URL
-        .filter((s) => s.name && s.url)
-        // Sort by publish date (newest first)
-        .sort((a, b) => {
-        if (!a.published_at)
-            return 1;
-        if (!b.published_at)
-            return -1;
-        return (new Date(b.published_at).getTime() - new Date(a.published_at).getTime());
-    });
-    return {
-        servers,
-        next_cursor: data.metadata?.nextCursor || data.next_cursor,
-    };
-}
-export async function getPopularServers(limit = 20) {
-    const response = await searchMcpServers({ limit });
-    // Already sorted by publish date in searchMcpServers
-    return response.servers;
-}
-export function formatDate(dateStr) {
-    if (!dateStr)
-        return "";
-    const date = new Date(dateStr);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    if (diffDays === 0)
-        return "today";
-    if (diffDays === 1)
-        return "yesterday";
-    if (diffDays < 7)
-        return `${diffDays}d ago`;
-    if (diffDays < 30)
-        return `${Math.floor(diffDays / 7)}w ago`;
-    if (diffDays < 365)
-        return `${Math.floor(diffDays / 30)}mo ago`;
-    return `${Math.floor(diffDays / 365)}y ago`;
-}