mcpick 0.0.18 → 0.0.19

package/dist/plugin-cache-Bby9Dxm9.js

@@ -0,0 +1,405 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { d as get_marketplace_manifest_path, h as get_plugin_cache_dir, l as get_installed_plugins_path, t as ensure_directory_exists, u as get_known_marketplaces_path } from "./paths-BPISiJi4.js";
+import { t as atomic_json_write } from "./atomic-write-BqEykHp9.js";
+import { lstat, readFile, readdir, readlink, rename, rm, symlink } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/core/plugin-cache.ts
+var plugin_cache_exports = /* @__PURE__ */ __exportAll({
+	clean_orphaned_versions: () => clean_orphaned_versions,
+	clear_plugin_caches: () => clear_plugin_caches,
+	get_cached_plugins_info: () => get_cached_plugins_info,
+	link_local_plugin: () => link_local_plugin,
+	list_linked_plugins: () => list_linked_plugins,
+	parse_plugin_key: () => parse_plugin_key,
+	read_installed_plugins: () => read_installed_plugins,
+	read_known_marketplaces: () => read_known_marketplaces,
+	read_marketplace_manifest: () => read_marketplace_manifest,
+	refresh_all_marketplaces: () => refresh_all_marketplaces,
+	refresh_marketplace: () => refresh_marketplace,
+	scan_all_cache_keys: () => scan_all_cache_keys,
+	unlink_local_plugin: () => unlink_local_plugin,
+	write_installed_plugins: () => write_installed_plugins
+});
+const execAsync = promisify(exec);
+const EMPTY_INSTALLED = {
+	version: 2,
+	plugins: {}
+};
+async function read_installed_plugins() {
+	try {
+		const content = await readFile(get_installed_plugins_path(), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {
+			...EMPTY_INSTALLED,
+			plugins: {}
+		};
+	}
+}
+async function write_installed_plugins(data) {
+	await atomic_json_write(get_installed_plugins_path(), () => data);
+}
+async function read_known_marketplaces() {
+	try {
+		const content = await readFile(get_known_marketplaces_path(), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+async function read_marketplace_manifest(name) {
+	try {
+		const content = await readFile(get_marketplace_manifest_path(name), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+async function get_marketplace_head_sha(marketplace_path) {
+	try {
+		const { stdout } = await execAsync(`git -C ${JSON.stringify(marketplace_path)} rev-parse HEAD`, { timeout: 1e4 });
+		return stdout.trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Recover a marketplace clone stuck on a deleted branch.
+* Resets the fetch refspec, fetches all branches, and checks out the default branch.
+*/
+async function recover_deleted_branch(dir) {
+	const q = JSON.stringify(dir);
+	try {
+		await execAsync(`git -C ${q} remote set-branches origin '*'`, { timeout: 1e4 });
+		await execAsync(`git -C ${q} fetch origin`, { timeout: 3e4 });
+		let default_branch = "main";
+		try {
+			const { stdout } = await execAsync(`git -C ${q} symbolic-ref refs/remotes/origin/HEAD`, { timeout: 5e3 });
+			const match = stdout.trim().match(/refs\/remotes\/origin\/(.+)/);
+			if (match) default_branch = match[1];
+		} catch {
+			try {
+				await execAsync(`git -C ${q} rev-parse --verify origin/main`, { timeout: 5e3 });
+				default_branch = "main";
+			} catch {
+				default_branch = "master";
+			}
+		}
+		await execAsync(`git -C ${q} checkout ${default_branch}`, { timeout: 1e4 });
+		await execAsync(`git -C ${q} reset --hard origin/${default_branch}`, { timeout: 1e4 });
+		return { recovered: true };
+	} catch (err) {
+		return {
+			recovered: false,
+			error: err instanceof Error ? err.message : "Unknown error"
+		};
+	}
+}
+async function refresh_marketplace(name, marketplace) {
+	const dir = marketplace.installLocation;
+	try {
+		await execAsync(`git -C ${JSON.stringify(dir)} pull --ff-only`, { timeout: 3e4 });
+		return { success: true };
+	} catch {
+		const recovery = await recover_deleted_branch(dir);
+		if (recovery.recovered) return { success: true };
+		return {
+			success: false,
+			error: `${name}: recovery failed: ${recovery.error}`
+		};
+	}
+}
+async function refresh_all_marketplaces() {
+	const marketplaces = await read_known_marketplaces();
+	const results = /* @__PURE__ */ new Map();
+	for (const [name, info] of Object.entries(marketplaces)) results.set(name, await refresh_marketplace(name, info));
+	return results;
+}
+async function find_orphaned_versions(marketplace, plugin_name) {
+	const plugin_dir = join(get_plugin_cache_dir(), marketplace, plugin_name);
+	const orphaned = [];
+	try {
+		const versions = await readdir(plugin_dir, { withFileTypes: true });
+		for (const entry of versions) {
+			if (!entry.isDirectory()) continue;
+			try {
+				await readFile(join(plugin_dir, entry.name, ".orphaned_at"));
+				orphaned.push(entry.name);
+			} catch {}
+		}
+	} catch {}
+	return orphaned;
+}
+function parse_plugin_key(key) {
+	const at_index = key.lastIndexOf("@");
+	return {
+		name: at_index > 0 ? key.substring(0, at_index) : key,
+		marketplace: at_index > 0 ? key.substring(at_index + 1) : "unknown"
+	};
+}
+async function get_cached_plugins_info() {
+	const installed = await read_installed_plugins();
+	const marketplaces = await read_known_marketplaces();
+	const manifests = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(marketplaces)) {
+		const manifest = await read_marketplace_manifest(name);
+		if (manifest) manifests.set(name, manifest);
+	}
+	const sha_cache = /* @__PURE__ */ new Map();
+	for (const [name, info] of Object.entries(marketplaces)) sha_cache.set(name, await get_marketplace_head_sha(info.installLocation));
+	const results = [];
+	for (const [key, entries] of Object.entries(installed.plugins)) {
+		const entry = entries[0];
+		if (!entry) continue;
+		const { name, marketplace } = parse_plugin_key(key);
+		const latest_version = (manifests.get(marketplace)?.plugins.find((p) => p.name === name))?.version ?? null;
+		const is_version_stale = latest_version !== null && latest_version !== entry.version;
+		const remote_sha = sha_cache.get(marketplace) ?? null;
+		const is_sha_stale = remote_sha !== null && entry.gitCommitSha !== "" && remote_sha !== entry.gitCommitSha;
+		const orphaned = await find_orphaned_versions(marketplace, name);
+		results.push({
+			key,
+			name,
+			marketplace,
+			installedVersion: entry.version,
+			latestVersion: latest_version,
+			installedSha: entry.gitCommitSha,
+			remoteSha: remote_sha,
+			isVersionStale: is_version_stale,
+			isShaStale: is_sha_stale,
+			orphanedVersions: orphaned,
+			installPath: entry.installPath
+		});
+	}
+	return results;
+}
+/**
+* Scan the cache directory on disk to find all plugin keys,
+* including marketplace-sourced plugins not tracked in installed_plugins.json.
+*/
+async function scan_all_cache_keys() {
+	const cache_dir = get_plugin_cache_dir();
+	const keys = [];
+	try {
+		const marketplaces = await readdir(cache_dir, { withFileTypes: true });
+		for (const mkt of marketplaces) {
+			if (!mkt.isDirectory() && !mkt.isSymbolicLink()) continue;
+			const mkt_path = join(cache_dir, mkt.name);
+			try {
+				const plugins = await readdir(mkt_path, { withFileTypes: true });
+				for (const plugin of plugins) {
+					if (!plugin.isDirectory() && !plugin.isSymbolicLink()) continue;
+					keys.push(`${plugin.name}@${mkt.name}`);
+				}
+			} catch {}
+		}
+	} catch {}
+	return keys;
+}
+function is_safe_cache_path(path) {
+	const cache_dir = resolve(get_plugin_cache_dir());
+	return resolve(path).startsWith(cache_dir + "/");
+}
+async function clear_plugin_caches(keys) {
+	const installed = await read_installed_plugins();
+	const marketplaces = await read_known_marketplaces();
+	const cleared = [];
+	const errors = [];
+	const marketplace_names = /* @__PURE__ */ new Set();
+	for (const key of keys) {
+		const { marketplace } = parse_plugin_key(key);
+		marketplace_names.add(marketplace);
+	}
+	for (const mkt_name of marketplace_names) {
+		const mkt_info = marketplaces[mkt_name];
+		if (mkt_info) {
+			const result = await refresh_marketplace(mkt_name, mkt_info);
+			if (!result.success) errors.push(`Marketplace refresh failed: ${result.error}`);
+		}
+	}
+	const cache_dir = get_plugin_cache_dir();
+	for (const key of keys) {
+		const { name, marketplace } = parse_plugin_key(key);
+		const plugin_cache_path = join(cache_dir, marketplace, name);
+		if (!is_safe_cache_path(plugin_cache_path)) {
+			errors.push(`Unsafe path, skipped: ${plugin_cache_path}`);
+			continue;
+		}
+		try {
+			await rm(plugin_cache_path, {
+				recursive: true,
+				force: true
+			});
+			delete installed.plugins[key];
+			cleared.push(key);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : "Unknown error";
+			errors.push(`Failed to clear ${key}: ${msg}`);
+		}
+	}
+	await write_installed_plugins(installed);
+	return {
+		cleared,
+		errors
+	};
+}
+async function clean_orphaned_versions() {
+	const cache_dir = get_plugin_cache_dir();
+	const cleaned_paths = [];
+	try {
+		const marketplaces = await readdir(cache_dir, { withFileTypes: true });
+		for (const mkt of marketplaces) {
+			if (!mkt.isDirectory()) continue;
+			const mkt_path = join(cache_dir, mkt.name);
+			const plugins = await readdir(mkt_path, { withFileTypes: true });
+			for (const plugin of plugins) {
+				if (!plugin.isDirectory()) continue;
+				const plugin_path = join(mkt_path, plugin.name);
+				const versions = await readdir(plugin_path, { withFileTypes: true });
+				for (const version of versions) {
+					if (!version.isDirectory()) continue;
+					const version_path = join(plugin_path, version.name);
+					try {
+						await readFile(join(version_path, ".orphaned_at"));
+						if (is_safe_cache_path(version_path)) {
+							await rm(version_path, {
+								recursive: true,
+								force: true
+							});
+							cleaned_paths.push(`${mkt.name}/${plugin.name}/${version.name}`);
+						}
+					} catch {}
+				}
+			}
+		}
+	} catch {}
+	return {
+		cleaned: cleaned_paths.length,
+		paths: cleaned_paths
+	};
+}
+/**
+* Symlink a local directory into the plugin cache.
+* Backs up existing cache directory if present.
+*/
+async function link_local_plugin(local_path, key) {
+	const resolved_path = resolve(local_path);
+	const { name, marketplace } = parse_plugin_key(key);
+	try {
+		if (!(await lstat(resolved_path)).isDirectory()) return {
+			success: false,
+			key,
+			symlinkPath: "",
+			targetPath: resolved_path,
+			error: `Path is not a directory: ${resolved_path}`
+		};
+	} catch {
+		return {
+			success: false,
+			key,
+			symlinkPath: "",
+			targetPath: resolved_path,
+			error: `Path does not exist: ${resolved_path}`
+		};
+	}
+	const cache_dir = get_plugin_cache_dir();
+	const plugin_dir = join(cache_dir, marketplace, name);
+	await ensure_directory_exists(join(cache_dir, marketplace));
+	try {
+		const stat = await lstat(plugin_dir);
+		if (stat.isSymbolicLink()) await rm(plugin_dir);
+		else if (stat.isDirectory()) await rename(plugin_dir, `${plugin_dir}.backup`);
+	} catch {}
+	try {
+		await symlink(resolved_path, plugin_dir, "dir");
+	} catch (err) {
+		return {
+			success: false,
+			key,
+			symlinkPath: plugin_dir,
+			targetPath: resolved_path,
+			error: `Failed to create symlink: ${err instanceof Error ? err.message : "Unknown error"}`
+		};
+	}
+	return {
+		success: true,
+		key,
+		symlinkPath: plugin_dir,
+		targetPath: resolved_path
+	};
+}
+/**
+* Remove a symlink from the plugin cache and restore backup if present.
+*/
+async function unlink_local_plugin(key) {
+	const { name, marketplace } = parse_plugin_key(key);
+	const plugin_dir = join(get_plugin_cache_dir(), marketplace, name);
+	try {
+		if (!(await lstat(plugin_dir)).isSymbolicLink()) return {
+			success: false,
+			key,
+			restored: false,
+			error: `'${key}' is not a symlink — nothing to unlink`
+		};
+	} catch {
+		return {
+			success: false,
+			key,
+			restored: false,
+			error: `'${key}' not found in cache`
+		};
+	}
+	await rm(plugin_dir);
+	const backup_path = `${plugin_dir}.backup`;
+	let restored = false;
+	try {
+		await lstat(backup_path);
+		await rename(backup_path, plugin_dir);
+		restored = true;
+	} catch {}
+	return {
+		success: true,
+		key,
+		restored
+	};
+}
+/**
+* List all symlinked entries in the plugin cache.
+*/
+async function list_linked_plugins() {
+	const cache_dir = get_plugin_cache_dir();
+	const links = [];
+	try {
+		const marketplaces = await readdir(cache_dir, { withFileTypes: true });
+		for (const mkt of marketplaces) {
+			if (!mkt.isDirectory() && !mkt.isSymbolicLink()) continue;
+			const mkt_path = join(cache_dir, mkt.name);
+			let entries;
+			try {
+				entries = await readdir(mkt_path, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const entry of entries) {
+				const entry_path = join(mkt_path, entry.name);
+				try {
+					if ((await lstat(entry_path)).isSymbolicLink()) {
+						const target = await readlink(entry_path);
+						links.push({
+							key: `${entry.name}@${mkt.name}`,
+							symlinkPath: entry_path,
+							targetPath: resolve(join(cache_dir, mkt.name), target)
+						});
+					}
+				} catch {}
+			}
+		}
+	} catch {}
+	return links;
+}
+//#endregion
+export { list_linked_plugins as a, read_installed_plugins as c, refresh_all_marketplaces as d, scan_all_cache_keys as f, link_local_plugin as i, read_known_marketplaces as l, clear_plugin_caches as n, parse_plugin_key as o, unlink_local_plugin as p, get_cached_plugins_info as r, plugin_cache_exports as s, clean_orphaned_versions as t, read_marketplace_manifest as u };
+
+//# sourceMappingURL=plugin-cache-Bby9Dxm9.js.map

package/dist/plugins-DHYJF5CP.js

@@ -0,0 +1,212 @@
+import { a as install_plugin_via_cli, g as validate_plugin_via_cli, h as update_plugin_via_cli, m as uninstall_plugin_via_cli } from "./claude-cli-BeA-bmoW.js";
+import { a as read_claude_settings, i as get_all_plugins, n as build_enabled_plugins, s as write_claude_settings } from "./settings-DEcWtzLE.js";
+import { l as read_known_marketplaces, o as parse_plugin_key } from "./plugin-cache-Bby9Dxm9.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+var plugins_default = defineCommand({
+	meta: {
+		name: "plugins",
+		description: "Manage Claude Code plugins (bundles of skills, hooks, agents, and MCP servers). Install from a marketplace with: mcpick plugins install <name>@<marketplace>"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List all plugins and their status"
+			},
+			args: { json: {
+				type: "boolean",
+				description: "Output as JSON",
+				default: false
+			} },
+			async run({ args }) {
+				const plugins = get_all_plugins(await read_claude_settings());
+				if (args.json) output(plugins, true);
+				else {
+					if (plugins.length === 0) {
+						console.log("No plugins found.");
+						return;
+					}
+					for (const p of plugins) {
+						const status = p.enabled ? "on" : "off";
+						console.log(`${p.name}@${p.marketplace}  ${status}`);
+					}
+				}
+			}
+		}),
+		enable: defineCommand({
+			meta: {
+				name: "enable",
+				description: "Enable a plugin"
+			},
+			args: { plugin: {
+				type: "positional",
+				description: "Plugin key (name@marketplace)",
+				required: true
+			} },
+			async run({ args }) {
+				const plugins = get_all_plugins(await read_claude_settings());
+				const key = args.plugin;
+				const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+				if (!plugin) error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+				plugin.enabled = true;
+				await write_claude_settings({ enabledPlugins: build_enabled_plugins(plugins) });
+				console.log(`Enabled plugin '${key}'`);
+			}
+		}),
+		disable: defineCommand({
+			meta: {
+				name: "disable",
+				description: "Disable a plugin"
+			},
+			args: { plugin: {
+				type: "positional",
+				description: "Plugin key (name@marketplace)",
+				required: true
+			} },
+			async run({ args }) {
+				const plugins = get_all_plugins(await read_claude_settings());
+				const key = args.plugin;
+				const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+				if (!plugin) error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+				plugin.enabled = false;
+				await write_claude_settings({ enabledPlugins: build_enabled_plugins(plugins) });
+				console.log(`Disabled plugin '${key}'`);
+			}
+		}),
+		install: defineCommand({
+			meta: {
+				name: "install",
+				description: "Install a plugin from a marketplace"
+			},
+			args: {
+				plugin: {
+					type: "positional",
+					description: "Plugin key (name@marketplace)",
+					required: true
+				},
+				scope: {
+					type: "string",
+					description: "Installation scope: user, project, or local",
+					default: "user"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const scope = args.scope;
+				const result = await install_plugin_via_cli(args.plugin, scope);
+				if (args.json) output(result, true);
+				else if (result.success) console.log(`Installed plugin '${args.plugin}' (scope: ${scope})`);
+				else error(result.error ?? "Unknown error");
+			}
+		}),
+		uninstall: defineCommand({
+			meta: {
+				name: "uninstall",
+				description: "Uninstall a plugin"
+			},
+			args: {
+				plugin: {
+					type: "positional",
+					description: "Plugin key (name@marketplace)",
+					required: true
+				},
+				scope: {
+					type: "string",
+					description: "Uninstall from scope: user, project, or local",
+					default: "user"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const scope = args.scope;
+				const { marketplace } = parse_plugin_key(args.plugin);
+				if ((await read_known_marketplaces())[marketplace]) {
+					const msg = `'${args.plugin}' is managed by marketplace '${marketplace}'.\nTo remove the marketplace: mcpick marketplace remove ${marketplace}\nOr via Claude CLI: claude plugin marketplace remove ${marketplace}`;
+					if (args.json) output({
+						success: false,
+						error: msg,
+						marketplace_managed: true
+					}, true);
+					else error(msg);
+					return;
+				}
+				const result = await uninstall_plugin_via_cli(args.plugin, scope);
+				if (args.json) output(result, true);
+				else if (result.success) console.log(`Uninstalled plugin '${args.plugin}' (scope: ${scope})`);
+				else error(result.error ?? "Unknown error");
+			}
+		}),
+		update: defineCommand({
+			meta: {
+				name: "update",
+				description: "Update a plugin to latest version"
+			},
+			args: {
+				plugin: {
+					type: "positional",
+					description: "Plugin key (name@marketplace)",
+					required: true
+				},
+				scope: {
+					type: "string",
+					description: "Scope to update: user, project, or local",
+					default: "user"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const scope = args.scope;
+				const result = await update_plugin_via_cli(args.plugin, scope);
+				if (args.json) output(result, true);
+				else if (result.success) console.log(`Updated plugin '${args.plugin}' (scope: ${scope})`);
+				else error(result.error ?? "Unknown error");
+			}
+		}),
+		validate: defineCommand({
+			meta: {
+				name: "validate",
+				description: "Validate a plugin or marketplace manifest"
+			},
+			args: {
+				path: {
+					type: "positional",
+					description: "Path to plugin or marketplace manifest",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const result = await validate_plugin_via_cli(args.path);
+				if (args.json) output({
+					path: args.path,
+					valid: result.success,
+					output: result.stdout,
+					error: result.error
+				}, true);
+				else if (result.success) console.log(result.stdout || "Validation passed.");
+				else error(result.error || "Validation failed");
+			}
+		})
+	}
+});
+//#endregion
+export { plugins_default as default };
+
+//# sourceMappingURL=plugins-DHYJF5CP.js.map