mcpick 0.0.18 → 0.0.20

package/dist/profile-CX97sMGp.js

@@ -0,0 +1,120 @@
+import { c as write_claude_config } from "./config-DijVdEFn.js";
+import { s as write_claude_settings } from "./settings-DEcWtzLE.js";
+import { n as load_profile, r as save_profile, t as list_profiles } from "./profile-DkY_lBEm.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+var profile_default = defineCommand({
+	meta: {
+		name: "profile",
+		description: "Manage profiles (MCP servers + plugins)"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List all saved profiles"
+			},
+			args: { json: {
+				type: "boolean",
+				description: "Output as JSON",
+				default: false
+			} },
+			async run({ args }) {
+				const profiles = await list_profiles();
+				if (args.json) output(profiles, true);
+				else {
+					if (profiles.length === 0) {
+						console.log("No profiles found.");
+						return;
+					}
+					for (const p of profiles) {
+						const parts = [`${p.serverCount} servers`];
+						if (p.pluginCount > 0) parts.push(`${p.pluginCount} plugins`);
+						console.log(`${p.name}  (${parts.join(", ")})`);
+					}
+				}
+			}
+		}),
+		load: defineCommand({
+			meta: {
+				name: "load",
+				description: "Load and apply a saved profile"
+			},
+			args: {
+				name: {
+					type: "positional",
+					description: "Profile name",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				try {
+					const profile = await load_profile(args.name);
+					await write_claude_config(profile.config);
+					const server_count = Object.keys(profile.config.mcpServers || {}).length;
+					let plugin_count = 0;
+					if (profile.enabledPlugins) {
+						await write_claude_settings({ enabledPlugins: profile.enabledPlugins });
+						plugin_count = Object.keys(profile.enabledPlugins).length;
+					}
+					if (args.json) output({
+						profile: args.name,
+						servers: server_count,
+						plugins: plugin_count
+					}, true);
+					else {
+						const parts = [`${server_count} servers`];
+						if (plugin_count > 0) parts.push(`${plugin_count} plugins`);
+						console.log(`Profile '${args.name}' applied (${parts.join(", ")})`);
+					}
+				} catch (err) {
+					error(err instanceof Error ? err.message : "Failed to load profile");
+				}
+			}
+		}),
+		save: defineCommand({
+			meta: {
+				name: "save",
+				description: "Save current config as a profile"
+			},
+			args: {
+				name: {
+					type: "positional",
+					description: "Profile name",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				try {
+					const counts = await save_profile(args.name);
+					if (args.json) output({
+						profile: args.name,
+						servers: counts.serverCount,
+						plugins: counts.pluginCount
+					}, true);
+					else {
+						const parts = [`${counts.serverCount} servers`];
+						if (counts.pluginCount > 0) parts.push(`${counts.pluginCount} plugins`);
+						console.log(`Profile '${args.name}' saved (${parts.join(", ")})`);
+					}
+				} catch (err) {
+					error(err instanceof Error ? err.message : "Failed to save profile");
+				}
+			}
+		})
+	}
+});
+//#endregion
+export { profile_default as default };
+
+//# sourceMappingURL=profile-CX97sMGp.js.map

package/dist/profile-DkY_lBEm.js

@@ -0,0 +1,70 @@
+import { _ as get_profiles_dir, g as get_profile_path, t as ensure_directory_exists } from "./paths-BPISiJi4.js";
+import { t as validate_claude_config } from "./validation-xMlbgGCF.js";
+import { s as read_claude_config } from "./config-DijVdEFn.js";
+import { a as read_claude_settings } from "./settings-DEcWtzLE.js";
+import { access, readFile, readdir, writeFile } from "node:fs/promises";
+//#region src/core/profile.ts
+async function load_profile(name) {
+	const profile_path = get_profile_path(name);
+	try {
+		await access(profile_path);
+		const content = await readFile(profile_path, "utf-8");
+		const parsed = JSON.parse(content);
+		let config;
+		if (parsed.mcpServers) config = validate_claude_config(parsed);
+		else if (!parsed.enabledPlugins) config = validate_claude_config({ mcpServers: parsed });
+		else config = validate_claude_config({ mcpServers: parsed.mcpServers || {} });
+		return {
+			config,
+			enabledPlugins: parsed.enabledPlugins
+		};
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new Error(`Profile '${name}' not found at ${profile_path}`);
+		throw error;
+	}
+}
+async function list_profiles() {
+	const profiles_dir = get_profiles_dir();
+	try {
+		await access(profiles_dir);
+		const json_files = (await readdir(profiles_dir)).filter((f) => f.endsWith(".json"));
+		const profiles = [];
+		for (const file of json_files) try {
+			const path = get_profile_path(file);
+			const content = await readFile(path, "utf-8");
+			const parsed = JSON.parse(content);
+			const servers = parsed.mcpServers || parsed;
+			const plugins = parsed.enabledPlugins || {};
+			profiles.push({
+				name: file.replace(".json", ""),
+				path,
+				serverCount: Object.keys(servers).length,
+				pluginCount: Object.keys(plugins).length
+			});
+		} catch {}
+		return profiles;
+	} catch {
+		return [];
+	}
+}
+async function save_profile(name) {
+	const config = await read_claude_config();
+	const settings = await read_claude_settings();
+	const servers = config.mcpServers || {};
+	const plugins = settings.enabledPlugins || {};
+	const server_count = Object.keys(servers).length;
+	const plugin_count = Object.keys(plugins).length;
+	if (server_count === 0 && plugin_count === 0) throw new Error("No MCP servers or plugins configured to save");
+	await ensure_directory_exists(get_profiles_dir());
+	const profile_data = { mcpServers: servers };
+	if (plugin_count > 0) profile_data.enabledPlugins = plugins;
+	await writeFile(get_profile_path(name), JSON.stringify(profile_data, null, 2), "utf-8");
+	return {
+		serverCount: server_count,
+		pluginCount: plugin_count
+	};
+}
+//#endregion
+export { load_profile as n, save_profile as r, list_profiles as t };
+
+//# sourceMappingURL=profile-DkY_lBEm.js.map

package/dist/redact-O35tjnRD.js

@@ -0,0 +1,26 @@
+//#region src/utils/redact.ts
+/**
+* Redact sensitive values (env, headers) from a server config.
+* Shows key names but replaces values with "***".
+*/
+function redact_server_base(server) {
+	const redacted = { ...server };
+	if ("env" in redacted && redacted.env) redacted.env = redact_record(redacted.env);
+	if ("headers" in redacted && redacted.headers) redacted.headers = redact_record(redacted.headers);
+	return redacted;
+}
+function redact_server(server) {
+	return {
+		...redact_server_base(server),
+		name: server.name
+	};
+}
+function redact_record(record) {
+	const redacted = {};
+	for (const key of Object.keys(record)) redacted[key] = "***";
+	return redacted;
+}
+//#endregion
+export { redact_server_base as n, redact_server as t };
+
+//# sourceMappingURL=redact-O35tjnRD.js.map

package/dist/registry-CfUKT7_C.js

@@ -0,0 +1,92 @@
+import { p as get_mcpick_dir, r as get_backups_dir, t as ensure_directory_exists, y as get_server_registry_path } from "./paths-BPISiJi4.js";
+import { r as validate_server_registry } from "./validation-xMlbgGCF.js";
+import { access, readFile, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/core/registry.ts
+async function read_server_registry() {
+	const registry_path = get_server_registry_path();
+	try {
+		await access(registry_path);
+		const registry_content = await readFile(registry_path, "utf-8");
+		return validate_server_registry(JSON.parse(registry_content));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+			await ensure_directory_exists(get_mcpick_dir());
+			const default_registry = { servers: [] };
+			await write_server_registry(default_registry);
+			return default_registry;
+		}
+		throw error;
+	}
+}
+async function write_server_registry(registry) {
+	const registry_path = get_server_registry_path();
+	await ensure_directory_exists(get_mcpick_dir());
+	await writeFile(registry_path, JSON.stringify(registry, null, 2), "utf-8");
+}
+async function add_server_to_registry(server) {
+	const registry = await read_server_registry();
+	const existing_index = registry.servers.findIndex((s) => s.name === server.name);
+	if (existing_index >= 0) registry.servers[existing_index] = server;
+	else registry.servers.push(server);
+	await write_server_registry(registry);
+}
+async function get_all_available_servers() {
+	const { get_enabled_servers, read_claude_config } = await import("./config-DijVdEFn.js").then((n) => n.t);
+	const registry = await read_server_registry();
+	const config_servers = get_enabled_servers(await read_claude_config());
+	const config_by_name = new Map(config_servers.map((s) => [s.name, s]));
+	const known_names = /* @__PURE__ */ new Set();
+	let registry_updated = false;
+	for (let i = 0; i < registry.servers.length; i++) {
+		const name = registry.servers[i].name;
+		known_names.add(name);
+		const config_server = config_by_name.get(name);
+		if (config_server) {
+			registry.servers[i] = config_server;
+			registry_updated = true;
+		}
+	}
+	for (const server of config_servers) if (!known_names.has(server.name)) {
+		registry.servers.push(server);
+		registry_updated = true;
+	}
+	if (registry_updated) await write_server_registry(registry);
+	return registry.servers;
+}
+async function sync_servers_to_registry(servers) {
+	const registry = await read_server_registry();
+	servers.forEach((server) => {
+		const existing_index = registry.servers.findIndex((s) => s.name === server.name);
+		if (existing_index >= 0) registry.servers[existing_index] = server;
+		else registry.servers.push(server);
+	});
+	await write_server_registry(registry);
+}
+function parse_backups(prefix, pattern) {
+	return async () => {
+		const backups_dir = get_backups_dir();
+		try {
+			await access(backups_dir);
+			return (await readdir(backups_dir)).filter((file) => file.startsWith(prefix) && file.endsWith(".json")).map((file) => {
+				const timestamp_match = file.match(pattern);
+				if (!timestamp_match) return null;
+				const [, year, month, day, hour, minute, second] = timestamp_match;
+				return {
+					filename: file,
+					timestamp: new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second)),
+					path: join(backups_dir, file)
+				};
+			}).filter((backup) => backup !== null).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return [];
+			throw error;
+		}
+	};
+}
+const list_backups = parse_backups("mcp-servers-", /mcp-servers-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
+const list_plugin_backups = parse_backups("plugins-", /plugins-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
+//#endregion
+export { read_server_registry as a, list_plugin_backups as i, get_all_available_servers as n, sync_servers_to_registry as o, list_backups as r, write_server_registry as s, add_server_to_registry as t };
+
+//# sourceMappingURL=registry-CfUKT7_C.js.map

package/dist/reload-CYDhkCVZ.js

@@ -0,0 +1,31 @@
+import { n as output } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/reload.ts
+var reload_default = defineCommand({
+	meta: {
+		name: "reload",
+		description: "Reload plugins in Claude Code"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "Output as JSON",
+		default: false
+	} },
+	async run({ args }) {
+		const info = {
+			supported: false,
+			message: "Claude Code does not expose a programmatic reload API.",
+			instructions: ["Run /reload-plugins inside an active Claude Code session", "Or restart your Claude Code session to pick up changes"]
+		};
+		if (args.json) output(info, true);
+		else {
+			console.log(info.message);
+			console.log("\nTo reload plugins:");
+			for (const instruction of info.instructions) console.log(`  - ${instruction}`);
+		}
+	}
+});
+//#endregion
+export { reload_default as default };
+
+//# sourceMappingURL=reload-CYDhkCVZ.js.map

package/dist/remove-D1owHLhG.js

@@ -0,0 +1,31 @@
+import { a as read_server_registry, n as get_all_available_servers, s as write_server_registry } from "./registry-CfUKT7_C.js";
+import { p as remove_mcp_via_cli } from "./claude-cli-DnmBJrjg.js";
+import { t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/remove.ts
+var remove_default = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove an MCP server from the registry and disable it"
+	},
+	args: { server: {
+		type: "positional",
+		description: "Server name to remove",
+		required: true
+	} },
+	async run({ args }) {
+		if (!(await get_all_available_servers()).find((s) => s.name === args.server)) error(`Server '${args.server}' not found. Run 'mcpick list' to see available servers.`);
+		const registry = await read_server_registry();
+		const index = registry.servers.findIndex((s) => s.name === args.server);
+		if (index >= 0) {
+			registry.servers.splice(index, 1);
+			await write_server_registry(registry);
+		}
+		await remove_mcp_via_cli(args.server);
+		console.log(`Removed '${args.server}'`);
+	}
+});
+//#endregion
+export { remove_default as default };
+
+//# sourceMappingURL=remove-D1owHLhG.js.map

package/dist/reset-project-choices-BfRSNN3m.js

@@ -0,0 +1,28 @@
+import { f as mcp_reset_project_choices_via_cli } from "./claude-cli-DnmBJrjg.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/reset-project-choices.ts
+var reset_project_choices_default = defineCommand({
+	meta: {
+		name: "reset-project-choices",
+		description: "Reset all approved and rejected project-scoped MCP servers"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "Output as JSON",
+		default: false
+	} },
+	async run({ args }) {
+		const result = await mcp_reset_project_choices_via_cli();
+		if (args.json) output({
+			success: result.success,
+			error: result.error
+		}, true);
+		else if (result.success) console.log("Project MCP server choices have been reset.");
+		else error(result.error || "Unknown error");
+	}
+});
+//#endregion
+export { reset_project_choices_default as default };
+
+//# sourceMappingURL=reset-project-choices-BfRSNN3m.js.map

package/dist/restore-DdMfUljI.js

@@ -0,0 +1,84 @@
+import { t as validate_claude_config } from "./validation-xMlbgGCF.js";
+import { i as list_plugin_backups, r as list_backups } from "./registry-CfUKT7_C.js";
+import { c as write_claude_config } from "./config-DijVdEFn.js";
+import { s as write_claude_settings } from "./settings-DEcWtzLE.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { readFile } from "node:fs/promises";
+import { defineCommand } from "citty";
+//#region src/cli/commands/restore.ts
+var restore_default = defineCommand({
+	meta: {
+		name: "restore",
+		description: "Restore config from a backup (latest if no file specified)"
+	},
+	args: {
+		file: {
+			type: "positional",
+			description: "Backup filename or path (optional, defaults to latest)",
+			required: false
+		},
+		type: {
+			type: "string",
+			description: "What to restore: mcp (default), plugins, or all",
+			default: "mcp"
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const restore_type = args.type;
+		const results = {};
+		if (restore_type === "mcp" || restore_type === "all") {
+			const backups = await list_backups();
+			if (backups.length === 0) {
+				if (restore_type === "mcp") error("No MCP backups found. Run \"mcpick backup\" first.");
+			} else {
+				let backup_path;
+				if (args.file && restore_type === "mcp") {
+					const found = backups.find((b) => b.filename === args.file || b.path === args.file);
+					if (!found) error(`Backup '${args.file}' not found. Available: ${backups.map((b) => b.filename).join(", ")}`);
+					backup_path = found.path;
+				} else backup_path = backups[0].path;
+				const content = await readFile(backup_path, "utf-8");
+				const config = validate_claude_config(JSON.parse(content));
+				await write_claude_config(config);
+				const server_count = Object.keys(config.mcpServers || {}).length;
+				results.mcp = {
+					restored: backup_path,
+					servers: server_count
+				};
+				if (!args.json) console.log(`Restored MCP: ${backup_path} (${server_count} servers)`);
+			}
+		}
+		if (restore_type === "plugins" || restore_type === "all") {
+			const backups = await list_plugin_backups();
+			if (backups.length === 0) {
+				if (restore_type === "plugins") error("No plugin backups found. Run \"mcpick backup\" first.");
+			} else {
+				let backup_path;
+				if (args.file && restore_type === "plugins") {
+					const found = backups.find((b) => b.filename === args.file || b.path === args.file);
+					if (!found) error(`Backup '${args.file}' not found. Available: ${backups.map((b) => b.filename).join(", ")}`);
+					backup_path = found.path;
+				} else backup_path = backups[0].path;
+				const content = await readFile(backup_path, "utf-8");
+				const parsed = JSON.parse(content);
+				await write_claude_settings({ enabledPlugins: parsed.enabledPlugins || {} });
+				const plugin_count = Object.keys(parsed.enabledPlugins || {}).length;
+				results.plugins = {
+					restored: backup_path,
+					plugins: plugin_count
+				};
+				if (!args.json) console.log(`Restored plugins: ${backup_path} (${plugin_count} plugins)`);
+			}
+		}
+		if (args.json) output(results, true);
+	}
+});
+//#endregion
+export { restore_default as default };
+
+//# sourceMappingURL=restore-DdMfUljI.js.map

package/dist/rolldown-runtime-CiIaOW0V.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };