claudeup 1.8.0 → 3.3.0

package/src/services/local-marketplace.ts

@@ -0,0 +1,489 @@
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+
+export interface LocalMarketplacePlugin {
+	name: string;
+	version: string;
+	description: string;
+	source?: string;
+	category?: string;
+	author?: { name: string; email?: string };
+	// Extended info from plugin.json or marketplace.json
+	strict?: boolean;
+	lspServers?: Record<string, unknown>;
+	agents?: string[];
+	commands?: string[];
+	skills?: string[];
+	mcpServers?: string[];
+}
+
+export interface LocalMarketplace {
+	name: string;
+	description: string;
+	plugins: LocalMarketplacePlugin[];
+	gitRepo?: string; // Extracted from git remote
+}
+
+const CLAUDE_PLUGINS_DIR = path.join(
+	os.homedir(),
+	".claude",
+	"plugins",
+	"marketplaces",
+);
+const KNOWN_MARKETPLACES_FILE = path.join(
+	os.homedir(),
+	".claude",
+	"plugins",
+	"known_marketplaces.json",
+);
+
+interface KnownMarketplaceEntry {
+	source: { source: string; url?: string; repo?: string };
+	installLocation: string;
+	lastUpdated: string;
+}
+
+type KnownMarketplaces = Record<string, KnownMarketplaceEntry>;
+
+/**
+ * Read known_marketplaces.json (Claude Code's internal marketplace tracking)
+ */
+async function readKnownMarketplaces(): Promise<KnownMarketplaces> {
+	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: string): string | undefined {
+	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: string,
+	marketplaceName: string,
+): Promise<LocalMarketplace | null> {
+	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: LocalMarketplacePlugin[] = [];
+		const validManifestPlugins: typeof manifest.plugins = [];
+		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: string[] = [];
+				let commands: string[] = [];
+				let skills: string[] = [];
+				let mcpServers: string[] = [];
+
+				// 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(): Promise<
+	Map<string, LocalMarketplace>
+> {
+	const marketplaces = new Map<string, LocalMarketplace>();
+
+	// 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: string,
+): Promise<LocalMarketplace | undefined> {
+	const marketplaces = await scanLocalMarketplaces();
+	return marketplaces.get(name);
+}
+
+/**
+ * Check if a marketplace exists in local cache
+ */
+export async function hasLocalMarketplace(name: string): Promise<boolean> {
+	const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, name);
+	const manifestPath = path.join(
+		marketplacePath,
+		".claude-plugin",
+		"marketplace.json",
+	);
+	return fs.pathExists(manifestPath);
+}
+
+export interface RefreshResult {
+	name: string;
+	success: boolean;
+	updated: boolean;
+	error?: string;
+}
+
+export interface RefreshProgress {
+	current: number;
+	total: number;
+	name: string;
+}
+
+export type ProgressCallback = (progress: RefreshProgress) => void;
+
+export interface RepairResult {
+	repaired: boolean;
+	pluginName: string;
+	added: {
+		agents: string[];
+		commands: string[];
+		skills: string[];
+	};
+}
+
+/**
+ * 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: string,
+): Promise<RepairResult> {
+	const pluginJsonPath = path.join(pluginPath, ".claude-plugin", "plugin.json");
+	const pluginName = path.basename(pluginPath);
+
+	const result: RepairResult = {
+		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;
+}
+
+export interface RepairMarketplaceResult {
+	marketplace: string;
+	repaired: RepairResult[];
+}
+
+/**
+ * Repair all plugins in a marketplace
+ */
+export async function repairMarketplacePlugins(
+	marketplaceName: string,
+): Promise<RepairMarketplaceResult> {
+	const result: RepairMarketplaceResult = {
+		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(): Promise<
+	RepairMarketplaceResult[]
+> {
+	const results: RepairMarketplaceResult[] = [];
+
+	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/{dist → src}/services/mcp-registry.js

@@ -1,18 +1,18 @@
 // Official Model Context Protocol Registry
 // API Docs: https://registry.modelcontextprotocol.io
-const MCP_REGISTRY_API = 'https://registry.modelcontextprotocol.io/v0';
+const MCP_REGISTRY_API = "https://registry.modelcontextprotocol.io/v0";
 export async function searchMcpServers(options = {}) {
-    const { query = '', limit = 20, cursor } = options;
+    const { query = "", limit = 20, cursor } = options;
     const params = new URLSearchParams();
     if (query)
-        params.set('query', query);
-    params.set('limit', String(limit));
+        params.set("query", query);
+    params.set("limit", String(limit));
     if (cursor)
-        params.set('cursor', cursor);
+        params.set("cursor", cursor);
     const url = `${MCP_REGISTRY_API}/servers?${params.toString()}`;
     const response = await fetch(url, {
         headers: {
-            'Accept': 'application/json',
+            Accept: "application/json",
         },
     });
     if (!response.ok) {
@@ -25,9 +25,9 @@ export async function searchMcpServers(options = {}) {
     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'];
+        const meta = item._meta?.["io.modelcontextprotocol.registry/official"];
         // Get URL from remotes (HTTP) or construct from packages
-        let url = '';
+        let url = "";
         if (server.remotes?.length > 0) {
             url = server.remotes[0].url;
         }
@@ -39,7 +39,7 @@ export async function searchMcpServers(options = {}) {
         return {
             name: server.name,
             url,
-            short_description: server.description || 'No description',
+            short_description: server.description || "No description",
             version: server.version,
             source_code_url: server.repository?.url,
             package_registry: server.packages?.[0]?.registryType,
@@ -54,7 +54,7 @@ export async function searchMcpServers(options = {}) {
             return 1;
         if (!b.published_at)
             return -1;
-        return new Date(b.published_at).getTime() - new Date(a.published_at).getTime();
+        return (new Date(b.published_at).getTime() - new Date(a.published_at).getTime());
     });
     return {
         servers,
@@ -68,15 +68,15 @@ export async function getPopularServers(limit = 20) {
 }
 export function formatDate(dateStr) {
     if (!dateStr)
-        return '';
+        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';
+        return "today";
     if (diffDays === 1)
-        return 'yesterday';
+        return "yesterday";
     if (diffDays < 7)
         return `${diffDays}d ago`;
     if (diffDays < 30)
@@ -85,4 +85,3 @@ export function formatDate(dateStr) {
         return `${Math.floor(diffDays / 30)}mo ago`;
     return `${Math.floor(diffDays / 365)}y ago`;
 }
-//# sourceMappingURL=mcp-registry.js.map

package/src/services/mcp-registry.ts

@@ -0,0 +1,105 @@
+import type { McpRegistryServer, McpRegistryResponse } from "../types/index.js";
+
+// Official Model Context Protocol Registry
+// API Docs: https://registry.modelcontextprotocol.io
+const MCP_REGISTRY_API = "https://registry.modelcontextprotocol.io/v0";
+
+export interface SearchOptions {
+	query?: string;
+	limit?: number;
+	cursor?: string;
+}
+
+export async function searchMcpServers(
+	options: SearchOptions = {},
+): Promise<McpRegistryResponse> {
+	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: any = 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: McpRegistryServer[] = (data.servers || [])
+		.map((item: any) => {
+			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: McpRegistryServer) => s.name && s.url)
+		// Sort by publish date (newest first)
+		.sort((a: McpRegistryServer, b: McpRegistryServer) => {
+			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,
+): Promise<McpRegistryServer[]> {
+	const response = await searchMcpServers({ limit });
+	// Already sorted by publish date in searchMcpServers
+	return response.servers;
+}
+
+export function formatDate(dateStr?: string): string {
+	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`;
+}