mcpick 0.0.17 → 0.0.19

package/dist/index.js

@@ -1,322 +1,1249 @@
 #!/usr/bin/env node
-import { cancel, intro, isCancel, log, outro, select, text, } from '@clack/prompts';
-import { add_server } from './commands/add-server.js';
-import { backup_config } from './commands/backup.js';
-import { edit_config } from './commands/edit-config.js';
-import { edit_plugins } from './commands/edit-plugins.js';
-import { manage_cache } from './commands/manage-cache.js';
-import { manage_hooks } from './commands/manage-hooks.js';
-import { manage_marketplace } from './commands/manage-marketplace.js';
-import { restore_config } from './commands/restore.js';
-import { write_claude_config } from './core/config.js';
-import { list_profiles, load_profile, save_profile, } from './core/profile.js';
-import { write_claude_settings } from './core/settings.js';
+import { m as get_plugin_backup_filename, n as get_backup_filename, r as get_backups_dir, t as ensure_directory_exists } from "./paths-BPISiJi4.js";
+import { n as validate_mcp_server } from "./validation-xMlbgGCF.js";
+import { i as list_plugin_backups, n as get_all_available_servers, o as sync_servers_to_registry, r as list_backups, t as add_server_to_registry } from "./registry-CfUKT7_C.js";
+import { a as install_plugin_via_cli, c as marketplace_remove_via_cli, h as update_plugin_via_cli, i as get_scope_options, l as marketplace_update_via_cli, m as uninstall_plugin_via_cli, n as check_claude_cli, o as marketplace_add_via_cli, p as remove_mcp_via_cli, r as get_scope_description, t as add_mcp_via_cli } from "./claude-cli-BeA-bmoW.js";
+import { a as get_enabled_servers, c as write_claude_config, n as create_config_from_servers, o as get_enabled_servers_for_scope, s as read_claude_config } from "./config-DijVdEFn.js";
+import { a as read_claude_settings, i as get_all_plugins, n as build_enabled_plugins, r as get_all_hooks, s as write_claude_settings } from "./settings-DEcWtzLE.js";
+import { d as refresh_all_marketplaces, l as read_known_marketplaces, n as clear_plugin_caches, r as get_cached_plugins_info, t as clean_orphaned_versions, u as read_marketplace_manifest } from "./plugin-cache-Bby9Dxm9.js";
+import { a as redisable_restored_hooks, i as read_disabled_hooks, n as disable_plugin_hook, r as enable_plugin_hook, t as check_restored_hooks } from "./hook-state-Di8lUsPr.js";
+import { n as load_profile, r as save_profile, t as list_profiles } from "./profile-DkY_lBEm.js";
+import { cancel, confirm, intro, isCancel, log, multiselect, note, outro, select, text } from "@clack/prompts";
+import { readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/commands/add-server.ts
+function format_server_details(server) {
+	const details = [`Name: ${server.name}`];
+	if ("command" in server) details.push(`Command: ${server.command} ${(server.args || []).join(" ")}`);
+	if ("url" in server) details.push(`URL: ${server.url}`);
+	details.push(`Description: ${server.description || "None"}`);
+	if (server.type) details.push(`Transport: ${server.type}`);
+	if (server.env) details.push(`Environment: ${Object.keys(server.env).length} variables`);
+	if ("headers" in server && server.headers) details.push(`Headers: ${Object.keys(server.headers).length} headers`);
+	return details;
+}
+async function add_server() {
+	try {
+		const cli_available = await check_claude_cli();
+		const scope = await select({
+			message: "Where should this server be installed?",
+			options: get_scope_options(),
+			initialValue: "local"
+		});
+		if (typeof scope === "symbol") return;
+		const config_method = await select({
+			message: "How would you like to add the server?",
+			options: [{
+				value: "json",
+				label: "Paste JSON configuration",
+				hint: "Paste complete server config as JSON"
+			}, {
+				value: "form",
+				label: "Step-by-step form",
+				hint: "Fill out fields one by one"
+			}],
+			initialValue: "json"
+		});
+		if (typeof config_method === "symbol") return;
+		if (config_method === "json") return await add_server_from_json(scope, cli_available);
+		const name = await text({
+			message: "Server name:",
+			placeholder: "e.g., mcp-sqlite-tools",
+			validate: (value) => {
+				if (!value || value.trim().length === 0) return "Server name is required";
+			}
+		});
+		if (typeof name === "symbol") return;
+		const command = await text({
+			message: "Command to run:",
+			placeholder: "e.g., uvx, npx, node",
+			validate: (value) => {
+				if (!value || value.trim().length === 0) return "Command is required";
+			}
+		});
+		if (typeof command === "symbol") return;
+		const args_input = await text({
+			message: "Arguments (comma-separated):",
+			placeholder: "e.g., mcp-sqlite-tools, --port, 3000",
+			defaultValue: ""
+		});
+		if (typeof args_input === "symbol") return;
+		const args = args_input.split(",").map((arg) => arg.trim()).filter((arg) => arg.length > 0);
+		const description = await text({
+			message: "Description (optional):",
+			placeholder: "Brief description of what this server provides"
+		});
+		if (typeof description === "symbol") return;
+		const configure_advanced = await confirm({
+			message: "Configure advanced settings (env variables, transport, etc.)?",
+			initialValue: false
+		});
+		if (typeof configure_advanced === "symbol") return;
+		let server_data = {
+			name: name.trim(),
+			type: "stdio",
+			command: command.trim(),
+			args,
+			...description && description.trim() && { description: description.trim() }
+		};
+		if (configure_advanced) {
+			const transport_type = await select({
+				message: "Transport type:",
+				options: [
+					{
+						value: "stdio",
+						label: "stdio (default)",
+						hint: "Standard input/output"
+					},
+					{
+						value: "sse",
+						label: "sse",
+						hint: "Server-sent events"
+					},
+					{
+						value: "http",
+						label: "http",
+						hint: "HTTP transport"
+					}
+				],
+				initialValue: "stdio"
+			});
+			if (typeof transport_type === "symbol") return;
+			server_data.type = transport_type;
+			if (transport_type === "sse" || transport_type === "http") {
+				delete server_data.command;
+				delete server_data.args;
+				const url = await text({
+					message: "Server URL:",
+					placeholder: "e.g., http://localhost:3000",
+					validate: (value) => {
+						if (!value || value.trim().length === 0) return "URL is required for non-stdio transport";
+					}
+				});
+				if (typeof url === "symbol") return;
+				server_data.url = url.trim();
+			}
+			const env_input = await text({
+				message: "Environment variables (KEY=value, comma-separated):",
+				placeholder: "e.g., API_KEY=abc123, TIMEOUT=30"
+			});
+			if (typeof env_input === "symbol") return;
+			if (env_input && env_input.trim()) {
+				const env = {};
+				env_input.split(",").forEach((pair) => {
+					const [key, ...valueParts] = pair.split("=");
+					if (key && valueParts.length > 0) env[key.trim()] = valueParts.join("=").trim();
+				});
+				if (Object.keys(env).length > 0) server_data.env = env;
+			}
+			if (transport_type === "http") {
+				const headers_input = await text({
+					message: "HTTP headers (KEY=value, comma-separated):",
+					placeholder: "e.g., Authorization=Bearer token, Content-Type=application/json"
+				});
+				if (typeof headers_input === "symbol") return;
+				if (headers_input && headers_input.trim()) {
+					const headers = {};
+					headers_input.split(",").forEach((pair) => {
+						const [key, ...valueParts] = pair.split("=");
+						if (key && valueParts.length > 0) headers[key.trim()] = valueParts.join("=").trim();
+					});
+					if (Object.keys(headers).length > 0) server_data.headers = headers;
+				}
+			}
+		}
+		const validated_server = validate_mcp_server(server_data);
+		const details = format_server_details(validated_server);
+		details.push(`Scope: ${get_scope_description(scope)}`);
+		note(`Server to add:\n${details.join("\n")}`);
+		const should_add = await confirm({ message: "Add this server?" });
+		if (typeof should_add === "symbol" || !should_add) return;
+		await add_server_to_registry(validated_server);
+		if (cli_available) {
+			const result = await add_mcp_via_cli(validated_server, scope);
+			if (result.success) note(`Server "${validated_server.name}" installed successfully!\nScope: ${get_scope_description(scope)}\nAlso added to mcpick registry for profile management.`);
+			else log.warn(`CLI installation failed: ${result.error}\nServer added to registry only. Use 'claude mcp add' manually.`);
+		} else log.warn("Claude CLI not found. Server added to registry only.\nInstall Claude Code CLI and run 'claude mcp add' to activate.");
+	} catch (error) {
+		throw new Error(`Failed to add server: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function add_server_from_json(scope, cli_available) {
+	const json_input = await text({
+		message: "Paste JSON configuration:",
+		placeholder: "{ \"name\": \"mcp-sqlite-tools\", \"command\": \"npx\", \"args\": [\"-y\", \"mcp-sqlite-tools\"] }",
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "JSON configuration is required";
+			let jsonString = value.trim();
+			if (!jsonString.startsWith("{")) jsonString = `{${jsonString}}`;
+			try {
+				const parsed = JSON.parse(jsonString);
+				if (typeof parsed !== "object" || parsed === null) return "JSON must be an object";
+				if (!parsed.command) return "Server configuration must include a \"command\" field";
+			} catch {
+				return "Invalid JSON format";
+			}
+		}
+	});
+	if (typeof json_input === "symbol") return;
+	try {
+		let jsonString = json_input.trim();
+		if (!jsonString.startsWith("{")) jsonString = `{${jsonString}}`;
+		const server_data = JSON.parse(jsonString);
+		if (!server_data.type && server_data.command) server_data.type = "stdio";
+		if (server_data.type !== "stdio") {
+			delete server_data.command;
+			delete server_data.args;
+		}
+		if (server_data.command && !server_data.args) server_data.args = [];
+		const validated_server = validate_mcp_server(server_data);
+		const details = format_server_details(validated_server);
+		details.push(`Scope: ${get_scope_description(scope)}`);
+		note(`Server to add:\n${details.join("\n")}`);
+		const should_add = await confirm({ message: "Add this server?" });
+		if (typeof should_add === "symbol" || !should_add) return;
+		await add_server_to_registry(validated_server);
+		if (cli_available) {
+			const result = await add_mcp_via_cli(validated_server, scope);
+			if (result.success) note(`Server "${validated_server.name}" installed successfully!\nScope: ${get_scope_description(scope)}\nAlso added to mcpick registry for profile management.`);
+			else log.warn(`CLI installation failed: ${result.error}\nServer added to registry only. Use 'claude mcp add' manually.`);
+		} else log.warn("Claude CLI not found. Server added to registry only.\nInstall Claude Code CLI and run 'claude mcp add' to activate.");
+	} catch (error) {
+		throw new Error(`Failed to parse or validate JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+//#endregion
+//#region src/commands/backup.ts
+const MAX_BACKUPS = 10;
+async function backup_config() {
+	try {
+		const current_config = await read_claude_config();
+		const current_settings = await read_claude_settings();
+		const backups_dir = get_backups_dir();
+		await ensure_directory_exists(backups_dir);
+		const mcp_path = join(backups_dir, get_backup_filename());
+		const mcp_backup = { mcpServers: current_config.mcpServers || {} };
+		await writeFile(mcp_path, JSON.stringify(mcp_backup, null, 2), "utf-8");
+		const plugins = current_settings.enabledPlugins || {};
+		const plugin_count = Object.keys(plugins).length;
+		let plugin_msg = "";
+		if (plugin_count > 0) {
+			const plugin_path = join(backups_dir, get_plugin_backup_filename());
+			await writeFile(plugin_path, JSON.stringify({ enabledPlugins: plugins }, null, 2), "utf-8");
+			plugin_msg = `\nPlugins backup: ${plugin_path}\n(${plugin_count} plugins backed up)`;
+		}
+		await cleanup_old_backups("mcp-servers-");
+		await cleanup_old_backups("plugins-");
+		const server_count = Object.keys(current_config.mcpServers || {}).length;
+		note(`MCP servers backup: ${mcp_path}\n(${server_count} servers backed up)${plugin_msg}`);
+	} catch (error) {
+		throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function cleanup_old_backups(prefix) {
+	try {
+		const backups_dir = get_backups_dir();
+		const backup_files = (await readdir(backups_dir)).filter((file) => file.startsWith(prefix) && file.endsWith(".json")).sort().reverse();
+		if (backup_files.length > MAX_BACKUPS) {
+			const files_to_delete = backup_files.slice(MAX_BACKUPS);
+			for (const file of files_to_delete) await unlink(join(backups_dir, file));
+		}
+	} catch {}
+}
+//#endregion
+//#region src/commands/edit-config.ts
+async function edit_config() {
+	try {
+		const cli_available = await check_claude_cli();
+		const scope = await select({
+			message: "Which configuration do you want to edit?",
+			options: get_scope_options(),
+			initialValue: "local"
+		});
+		if (typeof scope === "symbol") return;
+		const current_config = await read_claude_config();
+		let all_servers = await get_all_available_servers();
+		if (all_servers.length === 0 && current_config.mcpServers) {
+			const current_servers = get_enabled_servers(current_config);
+			if (current_servers.length > 0) {
+				await sync_servers_to_registry(current_servers);
+				all_servers = current_servers;
+				note(`Imported ${current_servers.length} servers from your .claude.json file into registry.`);
+			}
+		}
+		if (all_servers.length === 0) {
+			note("No MCP servers found in .claude.json or registry. Add servers first.");
+			return;
+		}
+		const currently_enabled = await get_enabled_servers_for_scope(scope);
+		const server_choices = all_servers.map((server) => ({
+			value: server.name,
+			label: server.name,
+			hint: server.description || ""
+		}));
+		const selected_server_names = await multiselect({
+			message: `Select MCP servers for ${get_scope_description(scope)}:`,
+			options: server_choices,
+			initialValues: currently_enabled,
+			required: false
+		});
+		if (typeof selected_server_names === "symbol") return;
+		const selected_servers = all_servers.filter((server) => selected_server_names.includes(server.name));
+		const servers_to_add = selected_server_names.filter((name) => !currently_enabled.includes(name));
+		const servers_to_remove = currently_enabled.filter((name) => !selected_server_names.includes(name));
+		if (cli_available && (scope === "local" || scope === "project")) {
+			let success_count = 0;
+			let error_count = 0;
+			for (const name of servers_to_add) {
+				const server = all_servers.find((s) => s.name === name);
+				if (server) {
+					const result = await add_mcp_via_cli(server, scope);
+					if (result.success) success_count++;
+					else {
+						error_count++;
+						log.warn(`Failed to add ${name}: ${result.error}`);
+					}
+				}
+			}
+			for (const name of servers_to_remove) {
+				const result = await remove_mcp_via_cli(name);
+				if (result.success) success_count++;
+				else {
+					error_count++;
+					log.warn(`Failed to remove ${name}: ${result.error}`);
+				}
+			}
+			await sync_servers_to_registry(selected_servers);
+			if (error_count > 0) note(`Configuration updated with ${error_count} errors.\nScope: ${get_scope_description(scope)}\nAdded: ${servers_to_add.length}, Removed: ${servers_to_remove.length}`);
+			else note(`Configuration updated!\nScope: ${get_scope_description(scope)}\nEnabled servers: ${selected_servers.length}`);
+		} else {
+			await write_claude_config(create_config_from_servers(selected_servers));
+			await sync_servers_to_registry(selected_servers);
+			if (!cli_available && scope !== "user") log.warn(`Claude CLI not available. Changes written to ~/.claude.json (user scope) instead of ${scope} scope.`);
+			note(`Configuration updated!\nEnabled servers: ${selected_servers.length}`);
+		}
+	} catch (error) {
+		throw new Error(`Failed to edit configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+//#endregion
+//#region src/commands/edit-plugins.ts
+async function handle_toggle() {
+	const plugins = get_all_plugins(await read_claude_settings());
+	if (plugins.length === 0) {
+		note("No plugins found in ~/.claude/settings.json.\nInstall plugins via Claude Code: /plugin");
+		return;
+	}
+	const plugin_choices = plugins.map((plugin) => ({
+		value: `${plugin.name}@${plugin.marketplace}`,
+		label: plugin.name,
+		hint: plugin.marketplace
+	}));
+	const currently_enabled = plugins.filter((p) => p.enabled).map((p) => `${p.name}@${p.marketplace}`);
+	const selected = await multiselect({
+		message: "Select plugins to enable:",
+		options: plugin_choices,
+		initialValues: currently_enabled,
+		required: false
+	});
+	if (typeof selected === "symbol") return;
+	const selected_set = new Set(selected);
+	const updated_plugins = plugins.map((plugin) => ({
+		...plugin,
+		enabled: selected_set.has(`${plugin.name}@${plugin.marketplace}`)
+	}));
+	await write_claude_settings({ enabledPlugins: build_enabled_plugins(updated_plugins) });
+	const enabled_count = updated_plugins.filter((p) => p.enabled).length;
+	const disabled_count = updated_plugins.filter((p) => !p.enabled).length;
+	note(`Plugins updated!\nEnabled: ${enabled_count}, Disabled: ${disabled_count}`);
+	const newly_enabled = updated_plugins.filter((p) => p.enabled && !currently_enabled.includes(`${p.name}@${p.marketplace}`));
+	const newly_disabled = updated_plugins.filter((p) => !p.enabled && currently_enabled.includes(`${p.name}@${p.marketplace}`));
+	if (newly_enabled.length > 0) log.success(`Enabled: ${newly_enabled.map((p) => p.name).join(", ")}`);
+	if (newly_disabled.length > 0) log.warn(`Disabled: ${newly_disabled.map((p) => p.name).join(", ")}`);
+}
+async function handle_install() {
+	const key = await text({
+		message: "Plugin to install (name@marketplace):",
+		placeholder: "e.g. commit-commands@claude-plugins-official",
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "Plugin key is required";
+			if (!value.includes("@")) return "Format: plugin-name@marketplace-name";
+		}
+	});
+	if (isCancel(key)) return;
+	const scope = await select({
+		message: "Installation scope:",
+		options: [
+			{
+				value: "user",
+				label: "User",
+				hint: "Global (default)"
+			},
+			{
+				value: "project",
+				label: "Project",
+				hint: "Shared with team"
+			},
+			{
+				value: "local",
+				label: "Local",
+				hint: "This project only (gitignored)"
+			}
+		]
+	});
+	if (isCancel(scope)) return;
+	const result = await install_plugin_via_cli(key, scope);
+	if (result.success) log.success(`Installed '${key}' (scope: ${scope})`);
+	else log.error(result.error ?? "Unknown error");
+}
+async function handle_uninstall() {
+	const plugins = get_all_plugins(await read_claude_settings());
+	if (plugins.length === 0) {
+		log.info("No plugins installed.");
+		return;
+	}
+	const selected = await select({
+		message: "Select plugin to uninstall:",
+		options: plugins.map((p) => ({
+			value: `${p.name}@${p.marketplace}`,
+			label: p.name,
+			hint: p.marketplace
+		}))
+	});
+	if (isCancel(selected)) return;
+	const should_uninstall = await confirm({ message: `Uninstall '${selected}'?` });
+	if (isCancel(should_uninstall) || !should_uninstall) return;
+	const result = await uninstall_plugin_via_cli(selected);
+	if (result.success) log.success(`Uninstalled '${selected}'`);
+	else log.error(result.error ?? "Unknown error");
+}
+async function handle_update$1() {
+	const plugins = get_all_plugins(await read_claude_settings());
+	if (plugins.length === 0) {
+		log.info("No plugins installed.");
+		return;
+	}
+	const selected = await select({
+		message: "Select plugin to update:",
+		options: plugins.map((p) => ({
+			value: `${p.name}@${p.marketplace}`,
+			label: p.name,
+			hint: p.marketplace
+		}))
+	});
+	if (isCancel(selected)) return;
+	const result = await update_plugin_via_cli(selected);
+	if (result.success) log.success(`Updated '${selected}'`);
+	else log.error(result.error ?? "Unknown error");
+}
+async function edit_plugins() {
+	while (true) {
+		const action = await select({
+			message: "Plugin management:",
+			options: [
+				{
+					value: "toggle",
+					label: "Enable / Disable plugins",
+					hint: "Toggle plugins on/off"
+				},
+				{
+					value: "install",
+					label: "Install plugin",
+					hint: "Install from a marketplace"
+				},
+				{
+					value: "uninstall",
+					label: "Uninstall plugin",
+					hint: "Remove a plugin entirely"
+				},
+				{
+					value: "update",
+					label: "Update plugin",
+					hint: "Update to latest version"
+				},
+				{
+					value: "back",
+					label: "Back",
+					hint: "Return to main menu"
+				}
+			]
+		});
+		if (isCancel(action) || action === "back") return;
+		try {
+			switch (action) {
+				case "toggle":
+					await handle_toggle();
+					break;
+				case "install":
+					await handle_install();
+					break;
+				case "uninstall":
+					await handle_uninstall();
+					break;
+				case "update":
+					await handle_update$1();
+					break;
+			}
+		} catch (err) {
+			log.error(err instanceof Error ? err.message : "Unknown error");
+		}
+	}
+}
+//#endregion
+//#region src/commands/manage-cache.ts
+function format_status_line(p) {
+	const markers = [];
+	if (p.isVersionStale) markers.push(`version: ${p.installedVersion} → ${p.latestVersion}`);
+	if (p.isShaStale) markers.push("commits behind");
+	if (p.orphanedVersions.length > 0) markers.push(`${p.orphanedVersions.length} orphaned`);
+	const status = markers.length > 0 ? `[stale: ${markers.join(", ")}]` : "[up to date]";
+	return `${p.name}@${p.marketplace}  v${p.installedVersion}  ${status}`;
+}
+async function handle_status() {
+	const plugins = await get_cached_plugins_info();
+	if (plugins.length === 0) {
+		log.info("No cached plugins found.");
+		return;
+	}
+	note(plugins.map(format_status_line).join("\n"), "Plugin Cache Status");
+}
+async function handle_clear() {
+	const plugins = await get_cached_plugins_info();
+	if (plugins.length === 0) {
+		log.info("No cached plugins to clear.");
+		return;
+	}
+	const selected = await multiselect({
+		message: "Select plugins to clear cache for:",
+		options: plugins.map((p) => {
+			const stale = p.isVersionStale || p.isShaStale;
+			return {
+				value: p.key,
+				label: `${p.name}@${p.marketplace}`,
+				hint: stale ? `v${p.installedVersion} → ${p.latestVersion ?? "unknown"} (stale)` : `v${p.installedVersion}`
+			};
+		}),
+		initialValues: plugins.filter((p) => p.isVersionStale || p.isShaStale).map((p) => p.key)
+	});
+	if (isCancel(selected) || selected.length === 0) return;
+	const should_clear = await confirm({ message: `Clear cache for ${selected.length} plugin(s)? This will also refresh the marketplace.` });
+	if (isCancel(should_clear) || !should_clear) return;
+	const result = await clear_plugin_caches(selected);
+	for (const key of result.cleared) log.success(`Cleared: ${key}`);
+	for (const err of result.errors) log.error(`Error: ${err}`);
+	if (result.cleared.length > 0) note("Run /reload-plugins in Claude Code or restart your session to apply changes.", "Next Steps");
+}
+async function handle_clean_orphaned() {
+	const should_clean = await confirm({ message: "Remove all orphaned plugin version directories?" });
+	if (isCancel(should_clean) || !should_clean) return;
+	const result = await clean_orphaned_versions();
+	if (result.cleaned === 0) log.info("No orphaned versions found.");
+	else {
+		for (const p of result.paths) log.success(`Removed: ${p}`);
+		log.info(`Cleaned ${result.cleaned} orphaned version(s).`);
+	}
+}
+async function handle_refresh() {
+	const should_refresh = await confirm({ message: "Refresh all marketplace clones (git pull)?" });
+	if (isCancel(should_refresh) || !should_refresh) return;
+	const results = await refresh_all_marketplaces();
+	if (results.size === 0) {
+		log.info("No marketplaces configured.");
+		return;
+	}
+	for (const [name, result] of results) if (result.success) log.success(`${name}: refreshed`);
+	else log.error(`${name}: ${result.error}`);
+}
+async function manage_cache() {
+	while (true) {
+		const action = await select({
+			message: "Plugin cache management:",
+			options: [
+				{
+					value: "status",
+					label: "View cache status",
+					hint: "Show plugins with staleness info"
+				},
+				{
+					value: "clear",
+					label: "Clear plugin caches",
+					hint: "Refresh marketplace + clear selected caches"
+				},
+				{
+					value: "clean-orphaned",
+					label: "Clean orphaned versions",
+					hint: "Remove old version directories"
+				},
+				{
+					value: "refresh",
+					label: "Refresh marketplaces",
+					hint: "Git pull all marketplace clones"
+				},
+				{
+					value: "back",
+					label: "Back",
+					hint: "Return to main menu"
+				}
+			]
+		});
+		if (isCancel(action) || action === "back") return;
+		switch (action) {
+			case "status":
+				await handle_status();
+				break;
+			case "clear":
+				await handle_clear();
+				break;
+			case "clean-orphaned":
+				await handle_clean_orphaned();
+				break;
+			case "refresh":
+				await handle_refresh();
+				break;
+		}
+	}
+}
+//#endregion
+//#region src/commands/manage-hooks.ts
+function format_hook(entry) {
+	const detail = entry.handler.command || entry.handler.url || entry.handler.prompt || "(unknown)";
+	const truncated = detail.length > 50 ? detail.substring(0, 47) + "..." : detail;
+	return `${entry.event} → ${entry.handler.type}: ${truncated}`;
+}
+function format_source(entry) {
+	if (entry.source === "plugin" && entry.plugin_key) return entry.plugin_key;
+	return entry.scope;
+}
+async function manage_hooks() {
+	const active_hooks = await get_all_hooks();
+	const disabled = await read_disabled_hooks();
+	const items = [];
+	for (let i = 0; i < active_hooks.length; i++) {
+		const h = active_hooks[i];
+		items.push({
+			id: `active:${i}`,
+			active_entry: h,
+			label: format_hook(h),
+			hint: format_source(h)
+		});
+	}
+	for (let i = 0; i < disabled.length; i++) {
+		const d = disabled[i];
+		const detail = d.original_handler.command || d.original_handler.url || d.original_handler.prompt || "(unknown)";
+		const truncated = detail.length > 50 ? detail.substring(0, 47) + "..." : detail;
+		items.push({
+			id: `disabled:${i}`,
+			disabled_index: i,
+			label: `${d.event} → ${d.original_handler.type}: ${truncated}`,
+			hint: `${d.plugin_key} (disabled)`
+		});
+	}
+	if (items.length === 0) {
+		note("No hooks found (settings or plugins).");
+		return;
+	}
+	const currently_enabled = items.filter((item) => item.active_entry).map((item) => item.id);
+	const selected = await multiselect({
+		message: "Toggle hooks on/off:",
+		options: items.map((item) => ({
+			value: item.id,
+			label: item.label,
+			hint: item.hint
+		})),
+		initialValues: currently_enabled,
+		required: false
+	});
+	if (isCancel(selected)) return;
+	const selected_set = new Set(selected);
+	let changes = 0;
+	for (const item of items) {
+		if (!item.active_entry) continue;
+		if (selected_set.has(item.id)) continue;
+		if (item.active_entry.source === "plugin") {
+			await disable_plugin_hook(item.active_entry);
+			changes++;
+		}
+	}
+	for (const item of items) {
+		if (item.disabled_index === void 0) continue;
+		if (!selected_set.has(item.id)) continue;
+		await enable_plugin_hook(disabled[item.disabled_index]);
+		changes++;
+	}
+	if (changes > 0) {
+		log.success(`${changes} hook(s) updated.`);
+		log.info("Restart Claude Code for changes to take effect.");
+	} else log.info("No changes.");
+}
+//#endregion
+//#region src/commands/manage-marketplace.ts
+/**
+* Browse all available plugins across all marketplaces.
+* Shows a multiselect with installed plugins pre-selected — toggle to install/uninstall.
+*/
+async function handle_browse() {
+	const known = await read_known_marketplaces();
+	const marketplace_names = Object.keys(known);
+	if (marketplace_names.length === 0) {
+		note("No marketplaces configured.\nAdd one first to browse plugins.");
+		return;
+	}
+	const all_available = [];
+	for (const mkt_name of marketplace_names) {
+		const manifest = await read_marketplace_manifest(mkt_name);
+		if (!manifest?.plugins?.length) continue;
+		for (const p of manifest.plugins) all_available.push({
+			key: `${p.name}@${mkt_name}`,
+			name: p.name,
+			marketplace: mkt_name,
+			description: p.description
+		});
+	}
+	if (all_available.length === 0) {
+		note("No plugins found in any marketplace.");
+		return;
+	}
+	const installed = get_all_plugins(await read_claude_settings());
+	const installed_keys = new Set(installed.map((p) => `${p.name}@${p.marketplace}`));
+	const selected = await multiselect({
+		message: `Available plugins (${all_available.length}) — toggle to install/uninstall:`,
+		options: all_available.map((p) => ({
+			value: p.key,
+			label: p.name,
+			hint: `${p.marketplace}${p.description ? ` · ${p.description}` : ""}`
+		})),
+		initialValues: all_available.filter((p) => installed_keys.has(p.key)).map((p) => p.key),
+		required: false
+	});
+	if (isCancel(selected)) return;
+	const selected_set = new Set(selected);
+	const to_install = all_available.filter((p) => selected_set.has(p.key) && !installed_keys.has(p.key));
+	const to_uninstall = all_available.filter((p) => !selected_set.has(p.key) && installed_keys.has(p.key));
+	if (to_install.length === 0 && to_uninstall.length === 0) {
+		log.info("No changes.");
+		return;
+	}
+	for (const p of to_install) {
+		log.info(`Installing ${p.key}...`);
+		const result = await install_plugin_via_cli(p.key);
+		if (result.success) log.success(`Installed: ${p.key}`);
+		else log.error(`Failed: ${p.key} - ${result.error}`);
+	}
+	for (const p of to_uninstall) {
+		log.info(`Uninstalling ${p.key}...`);
+		const result = await uninstall_plugin_via_cli(p.key);
+		if (result.success) log.success(`Uninstalled: ${p.key}`);
+		else log.error(`Failed: ${p.key} - ${result.error}`);
+	}
+	const parts = [];
+	if (to_install.length > 0) parts.push(`${to_install.length} installed`);
+	if (to_uninstall.length > 0) parts.push(`${to_uninstall.length} uninstalled`);
+	note(parts.join(", "), "Plugins updated");
+}
+async function handle_add() {
+	const source = await text({
+		message: "Marketplace source:",
+		placeholder: "e.g. owner/repo or https://github.com/owner/repo",
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "Marketplace source is required";
+		}
+	});
+	if (isCancel(source)) return;
+	log.info(`Adding marketplace: ${source}`);
+	const result = await marketplace_add_via_cli(source);
+	if (!result.success) {
+		log.error(result.error || "Unknown error");
+		return;
+	}
+	log.success(`Marketplace added: ${source}`);
+	const marketplace_name = derive_marketplace_name(source);
+	const manifest = marketplace_name ? await read_marketplace_manifest(marketplace_name) : null;
+	if (!manifest?.plugins?.length) {
+		log.info("Install plugins with: mcpick plugins install <name>@<marketplace>");
+		return;
+	}
+	const should_install = await confirm({ message: `${manifest.plugins.length} plugins available. Install now?` });
+	if (isCancel(should_install) || !should_install) return;
+	const to_install = await multiselect({
+		message: "Select plugins to install:",
+		options: manifest.plugins.map((p) => ({
+			value: `${p.name}@${marketplace_name}`,
+			label: p.name,
+			hint: p.description
+		})),
+		required: false
+	});
+	if (isCancel(to_install) || to_install.length === 0) return;
+	for (const key of to_install) {
+		log.info(`Installing ${key}...`);
+		const install_result = await install_plugin_via_cli(key);
+		if (install_result.success) log.success(`Installed: ${key}`);
+		else log.error(`Failed: ${key} - ${install_result.error}`);
+	}
+}
+function derive_marketplace_name(source) {
+	const match = source.match(/([^/]+?)(?:\.git)?$/);
+	return match ? match[1].toLowerCase() : null;
+}
+async function handle_remove() {
+	const known = await read_known_marketplaces();
+	const names = Object.keys(known);
+	if (names.length === 0) {
+		note("No marketplaces configured.");
+		return;
+	}
+	const name = await select({
+		message: "Select marketplace to remove:",
+		options: names.map((n) => ({
+			value: n,
+			label: n,
+			hint: known[n].source.repo || known[n].source.url
+		}))
+	});
+	if (isCancel(name)) return;
+	const should_remove = await confirm({ message: `Remove marketplace '${name}'? Its plugins will also be removed.` });
+	if (isCancel(should_remove) || !should_remove) return;
+	const remove_result = await marketplace_remove_via_cli(name);
+	if (remove_result.success) log.success(`Marketplace removed: ${name}`);
+	else log.error(remove_result.error || "Unknown error");
+}
+async function handle_update() {
+	const known = await read_known_marketplaces();
+	const names = Object.keys(known);
+	if (names.length === 0) {
+		note("No marketplaces configured.");
+		return;
+	}
+	const choice = await select({
+		message: "What to update:",
+		options: [{
+			value: "__all__",
+			label: "All marketplaces"
+		}, ...names.map((n) => ({
+			value: n,
+			label: n,
+			hint: known[n].source.repo || known[n].source.url
+		}))]
+	});
+	if (isCancel(choice)) return;
+	if (choice === "__all__") {
+		log.info("Updating all marketplaces...");
+		const result = await marketplace_update_via_cli();
+		if (result.success) log.success("All marketplaces updated.");
+		else log.error(result.error || "Unknown error");
+	} else {
+		log.info(`Updating ${choice}...`);
+		const result = await marketplace_update_via_cli(choice);
+		if (result.success) log.success(`Marketplace updated: ${choice}`);
+		else log.error(result.error || "Unknown error");
+	}
+	const restored = await check_restored_hooks();
+	if (restored.length > 0) {
+		log.warn(`${restored.length} disabled hook(s) were restored by the update.`);
+		const should_redisable = await confirm({ message: "Re-disable these hooks?" });
+		if (!isCancel(should_redisable) && should_redisable) {
+			const redisable_result = await redisable_restored_hooks(restored);
+			if (redisable_result.success > 0) log.success(`Re-disabled ${redisable_result.success} hook(s).`);
+			if (redisable_result.failed > 0) log.error(`Failed to re-disable ${redisable_result.failed} hook(s).`);
+		}
+	}
+}
+async function manage_marketplace() {
+	while (true) {
+		const action = await select({
+			message: "Marketplace & plugins:",
+			options: [
+				{
+					value: "browse",
+					label: "Browse & install plugins",
+					hint: "Toggle plugins on/off across all marketplaces"
+				},
+				{
+					value: "add",
+					label: "Add marketplace",
+					hint: "Add a plugin catalog, then install plugins from it"
+				},
+				{
+					value: "remove",
+					label: "Remove marketplace",
+					hint: "Remove a marketplace and its plugins"
+				},
+				{
+					value: "update",
+					label: "Update marketplace(s)",
+					hint: "Pull latest from source"
+				},
+				{
+					value: "back",
+					label: "Back",
+					hint: "Return to main menu"
+				}
+			]
+		});
+		if (isCancel(action) || action === "back") return;
+		try {
+			switch (action) {
+				case "browse":
+					await handle_browse();
+					break;
+				case "add":
+					await handle_add();
+					break;
+				case "remove":
+					await handle_remove();
+					break;
+				case "update":
+					await handle_update();
+					break;
+			}
+		} catch (err) {
+			log.error(err instanceof Error ? err.message : "Unknown error");
+		}
+	}
+}
+//#endregion
+//#region src/commands/restore.ts
+async function restore_config() {
+	try {
+		const restore_type = await select({
+			message: "What would you like to restore?",
+			options: [{
+				value: "mcp",
+				label: "MCP servers",
+				hint: "Restore server configuration"
+			}, {
+				value: "plugins",
+				label: "Plugins",
+				hint: "Restore plugin enabled/disabled state"
+			}]
+		});
+		if (isCancel(restore_type)) return;
+		if (restore_type === "mcp") await restore_mcp();
+		else await restore_plugins();
+	} catch (error) {
+		throw new Error(`Failed to restore configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function restore_mcp() {
+	const backups = await list_backups();
+	if (backups.length === 0) {
+		note("No MCP server backups found.");
+		return;
+	}
+	const selected_backup_path = await select({
+		message: "Select backup to restore:",
+		options: backups.map((backup) => ({
+			value: backup.path,
+			label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+			hint: format_time_ago(backup.timestamp)
+		}))
+	});
+	if (isCancel(selected_backup_path)) return;
+	const should_restore = await confirm({ message: "This will replace your current MCP servers configuration. Continue?" });
+	if (isCancel(should_restore) || !should_restore) return;
+	const backup_content = await readFile(selected_backup_path, "utf-8");
+	const backup_data = JSON.parse(backup_content);
+	await write_claude_config({
+		...await read_claude_config(),
+		mcpServers: backup_data.mcpServers || {}
+	});
+	const server_count = Object.keys(backup_data.mcpServers || {}).length;
+	log.success(`MCP servers restored (${server_count} servers)`);
+}
+async function restore_plugins() {
+	const backups = await list_plugin_backups();
+	if (backups.length === 0) {
+		note("No plugin backups found.");
+		return;
+	}
+	const selected_backup_path = await select({
+		message: "Select plugin backup to restore:",
+		options: backups.map((backup) => ({
+			value: backup.path,
+			label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+			hint: format_time_ago(backup.timestamp)
+		}))
+	});
+	if (isCancel(selected_backup_path)) return;
+	const should_restore = await confirm({ message: "This will replace your current plugin configuration. Continue?" });
+	if (isCancel(should_restore) || !should_restore) return;
+	const backup_content = await readFile(selected_backup_path, "utf-8");
+	const backup_data = JSON.parse(backup_content);
+	await write_claude_settings({ enabledPlugins: backup_data.enabledPlugins || {} });
+	const plugin_count = Object.keys(backup_data.enabledPlugins || {}).length;
+	log.success(`Plugins restored (${plugin_count} plugins)`);
+}
+function format_time_ago(date) {
+	const diff = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+	const minutes = Math.floor(diff / 6e4);
+	const hours = Math.floor(minutes / 60);
+	const days = Math.floor(hours / 24);
+	if (days > 0) return `${days} day${days > 1 ? "s" : ""} ago`;
+	else if (hours > 0) return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+	else if (minutes > 0) return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+	else return "just now";
+}
+//#endregion
+//#region src/index.ts
 function parse_args() {
-    const args = process.argv.slice(2);
-    const result = {};
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--profile' || args[i] === '-p') {
-            result.profile = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--save-profile' || args[i] === '-s') {
-            result.saveProfile = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--list-profiles' || args[i] === '-l') {
-            result.listProfiles = true;
-        }
-    }
-    return result;
+	const args = process.argv.slice(2);
+	const result = {};
+	for (let i = 0; i < args.length; i++) if (args[i] === "--profile" || args[i] === "-p") {
+		result.profile = args[i + 1];
+		i++;
+	} else if (args[i] === "--save-profile" || args[i] === "-s") {
+		result.saveProfile = args[i + 1];
+		i++;
+	} else if (args[i] === "--list-profiles" || args[i] === "-l") result.listProfiles = true;
+	return result;
 }
 async function apply_profile(name) {
-    intro(`MCPick - Loading profile: ${name}`);
-    try {
-        const profile = await load_profile(name);
-        await write_claude_config(profile.config);
-        const server_count = Object.keys(profile.config.mcpServers || {}).length;
-        const parts = [`${server_count} servers`];
-        if (profile.enabledPlugins) {
-            await write_claude_settings({
-                enabledPlugins: profile.enabledPlugins,
-            });
-            parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
-        }
-        log.success(`Profile '${name}' applied (${parts.join(', ')})`);
-        outro('Done!');
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            cancel(error.message);
-        }
-        else {
-            cancel('Failed to load profile');
-        }
-        process.exit(1);
-    }
+	intro(`MCPick - Loading profile: ${name}`);
+	try {
+		const profile = await load_profile(name);
+		await write_claude_config(profile.config);
+		const parts = [`${Object.keys(profile.config.mcpServers || {}).length} servers`];
+		if (profile.enabledPlugins) {
+			await write_claude_settings({ enabledPlugins: profile.enabledPlugins });
+			parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
+		}
+		log.success(`Profile '${name}' applied (${parts.join(", ")})`);
+		outro("Done!");
+	} catch (error) {
+		if (error instanceof Error) cancel(error.message);
+		else cancel("Failed to load profile");
+		process.exit(1);
+	}
 }
 async function show_profiles() {
-    intro('MCPick - Available Profiles');
-    const profiles = await list_profiles();
-    if (profiles.length === 0) {
-        log.warn('No profiles found in ~/.claude/mcpick/profiles/');
-        log.info('Create .json files there to use profiles');
-    }
-    else {
-        for (const p of profiles) {
-            log.info(`${p.name} (${p.serverCount} servers)`);
-        }
-    }
-    outro('');
+	intro("MCPick - Available Profiles");
+	const profiles = await list_profiles();
+	if (profiles.length === 0) {
+		log.warn("No profiles found in ~/.claude/mcpick/profiles/");
+		log.info("Create .json files there to use profiles");
+	} else for (const p of profiles) log.info(`${p.name} (${p.serverCount} servers)`);
+	outro("");
 }
 async function create_profile(name) {
-    intro(`MCPick - Saving profile: ${name}`);
-    try {
-        const counts = await save_profile(name);
-        const parts = [`${counts.serverCount} servers`];
-        if (counts.pluginCount > 0) {
-            parts.push(`${counts.pluginCount} plugins`);
-        }
-        log.success(`Profile '${name}' saved (${parts.join(', ')})`);
-        outro('Done!');
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            cancel(error.message);
-        }
-        else {
-            cancel('Failed to save profile');
-        }
-        process.exit(1);
-    }
+	intro(`MCPick - Saving profile: ${name}`);
+	try {
+		const counts = await save_profile(name);
+		const parts = [`${counts.serverCount} servers`];
+		if (counts.pluginCount > 0) parts.push(`${counts.pluginCount} plugins`);
+		log.success(`Profile '${name}' saved (${parts.join(", ")})`);
+		outro("Done!");
+	} catch (error) {
+		if (error instanceof Error) cancel(error.message);
+		else cancel("Failed to save profile");
+		process.exit(1);
+	}
 }
 async function handle_load_profile() {
-    const profiles = await list_profiles();
-    if (profiles.length === 0) {
-        log.warn('No profiles found');
-        log.info('Save a profile first or create one in ~/.claude/mcpick/profiles/');
-        return;
-    }
-    const profile_name = await select({
-        message: 'Select a profile to load:',
-        options: profiles.map((p) => {
-            const parts = [`${p.serverCount} servers`];
-            if (p.pluginCount > 0) {
-                parts.push(`${p.pluginCount} plugins`);
-            }
-            return {
-                value: p.name,
-                label: p.name,
-                hint: parts.join(', '),
-            };
-        }),
-    });
-    if (isCancel(profile_name))
-        return;
-    const profile = await load_profile(profile_name);
-    await write_claude_config(profile.config);
-    const server_count = Object.keys(profile.config.mcpServers || {}).length;
-    const parts = [`${server_count} servers`];
-    if (profile.enabledPlugins) {
-        await write_claude_settings({
-            enabledPlugins: profile.enabledPlugins,
-        });
-        parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
-    }
-    log.success(`Profile '${profile_name}' applied (${parts.join(', ')})`);
+	const profiles = await list_profiles();
+	if (profiles.length === 0) {
+		log.warn("No profiles found");
+		log.info("Save a profile first or create one in ~/.claude/mcpick/profiles/");
+		return;
+	}
+	const profile_name = await select({
+		message: "Select a profile to load:",
+		options: profiles.map((p) => {
+			const parts = [`${p.serverCount} servers`];
+			if (p.pluginCount > 0) parts.push(`${p.pluginCount} plugins`);
+			return {
+				value: p.name,
+				label: p.name,
+				hint: parts.join(", ")
+			};
+		})
+	});
+	if (isCancel(profile_name)) return;
+	const profile = await load_profile(profile_name);
+	await write_claude_config(profile.config);
+	const parts = [`${Object.keys(profile.config.mcpServers || {}).length} servers`];
+	if (profile.enabledPlugins) {
+		await write_claude_settings({ enabledPlugins: profile.enabledPlugins });
+		parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
+	}
+	log.success(`Profile '${profile_name}' applied (${parts.join(", ")})`);
 }
 async function handle_save_profile() {
-    const name = await text({
-        message: 'Profile name:',
-        placeholder: 'e.g. database, web-dev, minimal',
-        validate: (value) => {
-            if (!value || value.trim().length === 0) {
-                return 'Profile name is required';
-            }
-            if (!/^[\w-]+$/.test(value)) {
-                return 'Use only letters, numbers, underscores, hyphens';
-            }
-        },
-    });
-    if (isCancel(name))
-        return;
-    const counts = await save_profile(name);
-    const parts = [`${counts.serverCount} servers`];
-    if (counts.pluginCount > 0) {
-        parts.push(`${counts.pluginCount} plugins`);
-    }
-    log.success(`Profile '${name}' saved (${parts.join(', ')})`);
+	const name = await text({
+		message: "Profile name:",
+		placeholder: "e.g. database, web-dev, minimal",
+		validate: (value) => {
+			if (!value || value.trim().length === 0) return "Profile name is required";
+			if (!/^[\w-]+$/.test(value)) return "Use only letters, numbers, underscores, hyphens";
+		}
+	});
+	if (isCancel(name)) return;
+	const counts = await save_profile(name);
+	const parts = [`${counts.serverCount} servers`];
+	if (counts.pluginCount > 0) parts.push(`${counts.pluginCount} plugins`);
+	log.success(`Profile '${name}' saved (${parts.join(", ")})`);
 }
 async function main() {
-    const args = parse_args();
-    // Handle --list-profiles
-    if (args.listProfiles) {
-        await show_profiles();
-        return;
-    }
-    // Handle --save-profile <name>
-    if (args.saveProfile) {
-        await create_profile(args.saveProfile);
-        return;
-    }
-    // Handle --profile <name>
-    if (args.profile) {
-        await apply_profile(args.profile);
-        return;
-    }
-    intro('MCPick - MCP Server Configuration Manager');
-    while (true) {
-        try {
-            const action = await select({
-                message: 'What would you like to do?',
-                options: [
-                    {
-                        value: 'edit-config',
-                        label: 'Enable / Disable MCP servers',
-                        hint: 'Toggle MCP servers on/off',
-                    },
-                    {
-                        value: 'edit-plugins',
-                        label: 'Manage plugins',
-                        hint: 'Toggle, install, uninstall, or update plugins',
-                    },
-                    {
-                        value: 'manage-marketplace',
-                        label: 'Manage marketplaces',
-                        hint: 'Add, remove, or update plugin marketplaces',
-                    },
-                    {
-                        value: 'manage-hooks',
-                        label: 'Manage hooks',
-                        hint: 'List, add, or remove event hooks',
-                    },
-                    {
-                        value: 'manage-cache',
-                        label: 'Manage plugin cache',
-                        hint: 'View, clear, or refresh plugin caches',
-                    },
-                    {
-                        value: 'backup',
-                        label: 'Backup config',
-                        hint: 'Create a timestamped backup',
-                    },
-                    {
-                        value: 'add-server',
-                        label: 'Add MCP server',
-                        hint: 'Register a new MCP server',
-                    },
-                    {
-                        value: 'restore',
-                        label: 'Restore from backup',
-                        hint: 'Restore from a previous backup',
-                    },
-                    {
-                        value: 'load-profile',
-                        label: 'Load profile',
-                        hint: 'Apply a saved profile',
-                    },
-                    {
-                        value: 'save-profile',
-                        label: 'Save profile',
-                        hint: 'Save current config as profile',
-                    },
-                    {
-                        value: 'exit',
-                        label: 'Exit',
-                        hint: 'Quit MCPick (Esc)',
-                    },
-                ],
-            });
-            if (isCancel(action)) {
-                cancel('Operation cancelled');
-                break;
-            }
-            switch (action) {
-                case 'edit-config':
-                    await edit_config();
-                    break;
-                case 'edit-plugins':
-                    await edit_plugins();
-                    break;
-                case 'manage-marketplace':
-                    await manage_marketplace();
-                    break;
-                case 'manage-hooks':
-                    await manage_hooks();
-                    break;
-                case 'manage-cache':
-                    await manage_cache();
-                    break;
-                case 'backup':
-                    await backup_config();
-                    break;
-                case 'add-server':
-                    await add_server();
-                    break;
-                case 'restore':
-                    await restore_config();
-                    break;
-                case 'load-profile':
-                    await handle_load_profile();
-                    break;
-                case 'save-profile':
-                    await handle_save_profile();
-                    break;
-                case 'exit':
-                    outro('Goodbye!');
-                    process.exit(0);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                cancel(error.message);
-            }
-            else {
-                cancel('An unexpected error occurred');
-            }
-            const should_continue = await select({
-                message: 'Would you like to continue?',
-                options: [
-                    { value: true, label: 'Yes, return to main menu' },
-                    { value: false, label: 'No, exit' },
-                ],
-            });
-            if (isCancel(should_continue) || !should_continue) {
-                outro('Goodbye!');
-                break;
-            }
-        }
-    }
+	const args = parse_args();
+	if (args.listProfiles) {
+		await show_profiles();
+		return;
+	}
+	if (args.saveProfile) {
+		await create_profile(args.saveProfile);
+		return;
+	}
+	if (args.profile) {
+		await apply_profile(args.profile);
+		return;
+	}
+	intro("MCPick - Claude Code Extension Manager (MCP servers, plugins, skills, marketplaces)");
+	log.info("CLI: mcpick --help | Commands: list, add, enable, disable, plugins, marketplace, hooks, profile, backup, restore");
+	while (true) try {
+		const action = await select({
+			message: "What would you like to do?",
+			options: [
+				{
+					value: "edit-config",
+					label: "Enable / Disable MCP servers",
+					hint: "Toggle MCP servers on/off"
+				},
+				{
+					value: "edit-plugins",
+					label: "Manage plugins",
+					hint: "Toggle, install, uninstall, or update plugins"
+				},
+				{
+					value: "manage-marketplace",
+					label: "Manage marketplaces",
+					hint: "Add, remove, or update plugin marketplaces"
+				},
+				{
+					value: "manage-hooks",
+					label: "Manage hooks",
+					hint: "List, add, or remove event hooks"
+				},
+				{
+					value: "manage-cache",
+					label: "Manage plugin cache",
+					hint: "View, clear, or refresh plugin caches"
+				},
+				{
+					value: "backup",
+					label: "Backup config",
+					hint: "Create a timestamped backup"
+				},
+				{
+					value: "add-server",
+					label: "Add MCP server",
+					hint: "Register a new MCP server"
+				},
+				{
+					value: "restore",
+					label: "Restore from backup",
+					hint: "Restore from a previous backup"
+				},
+				{
+					value: "load-profile",
+					label: "Load profile",
+					hint: "Apply a saved profile"
+				},
+				{
+					value: "save-profile",
+					label: "Save profile",
+					hint: "Save current config as profile"
+				},
+				{
+					value: "exit",
+					label: "Exit",
+					hint: "Quit MCPick (Esc)"
+				}
+			]
+		});
+		if (isCancel(action)) {
+			cancel("Operation cancelled");
+			break;
+		}
+		switch (action) {
+			case "edit-config":
+				await edit_config();
+				break;
+			case "edit-plugins":
+				await edit_plugins();
+				break;
+			case "manage-marketplace":
+				await manage_marketplace();
+				break;
+			case "manage-hooks":
+				await manage_hooks();
+				break;
+			case "manage-cache":
+				await manage_cache();
+				break;
+			case "backup":
+				await backup_config();
+				break;
+			case "add-server":
+				await add_server();
+				break;
+			case "restore":
+				await restore_config();
+				break;
+			case "load-profile":
+				await handle_load_profile();
+				break;
+			case "save-profile":
+				await handle_save_profile();
+				break;
+			case "exit":
+				outro("Goodbye!");
+				process.exit(0);
+		}
+	} catch (error) {
+		if (error instanceof Error) cancel(error.message);
+		else cancel("An unexpected error occurred");
+		const should_continue = await select({
+			message: "Would you like to continue?",
+			options: [{
+				value: true,
+				label: "Yes, return to main menu"
+			}, {
+				value: false,
+				label: "No, exit"
+			}]
+		});
+		if (isCancel(should_continue) || !should_continue) {
+			outro("Goodbye!");
+			break;
+		}
+	}
 }
 const SUBCOMMANDS = new Set([
-    'list',
-    'enable',
-    'disable',
-    'remove',
-    'add',
-    'add-json',
-    'get',
-    'reset-project-choices',
-    'hooks',
-    'backup',
-    'restore',
-    'profile',
-    'plugins',
-    'cache',
-    'dev',
-    'marketplace',
-    'reload',
+	"list",
+	"enable",
+	"disable",
+	"remove",
+	"add",
+	"add-json",
+	"clone",
+	"get",
+	"reset-project-choices",
+	"hooks",
+	"backup",
+	"restore",
+	"profile",
+	"plugins",
+	"cache",
+	"dev",
+	"marketplace",
+	"reload"
 ]);
 const arg = process.argv[2];
-if ((arg && SUBCOMMANDS.has(arg)) ||
-    arg === '--help' ||
-    arg === '-h') {
-    import('./cli/index.js').then((m) => m.run());
-}
-else {
-    main().catch((error) => {
-        console.error('Fatal error:', error);
-        process.exit(1);
-    });
-}
+if (arg && SUBCOMMANDS.has(arg) || arg === "--help" || arg === "-h") import("./cli-DNNZjJYL.js").then((m) => m.run());
+else main().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});
+//#endregion
+export {};
+
 //# sourceMappingURL=index.js.map