claudeup 1.7.0 → 3.3.0

package/src/services/local-marketplace.js

@@ -0,0 +1,339 @@
+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;
+}