mcpick 0.0.21 → 0.0.23

package/dist/index.js

@@ -1,216 +1,309 @@
 #!/usr/bin/env node
-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-DnmBJrjg.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 { _ as get_profiles_dir, a as get_claude_settings_path, c as get_disabled_hooks_path, f as get_marketplaces_dir, g as get_profile_path, i as get_claude_config_path, m as get_plugin_backup_filename, n as get_backup_filename, 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, t as validate_claude_config } from "./validation-xMlbgGCF.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-DzMmTJYL.js";
+import { a as redact_url, i as redact_text } from "./redact-wBMtzbno.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-BSgB42wa.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() {
+import { access, mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/utils/safe-apply.ts
+async function file_exists$1(path) {
 	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() }
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function backup_name(path) {
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+	const hash = createHash("sha256").update(path).digest("hex").slice(0, 10);
+	return `config-${basename(path).replace(/[^A-Za-z0-9._-]/g, "_")}-${stamp}-${hash}.json`;
+}
+async function create_backup(path, content) {
+	const backups_dir = get_backups_dir();
+	await ensure_directory_exists(backups_dir);
+	const backup_path = join(backups_dir, backup_name(path));
+	await writeFile(backup_path, content, "utf-8");
+	await writeFile(`${backup_path}.meta.json`, JSON.stringify({
+		original_path: path,
+		created_at: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2), "utf-8");
+	return backup_path;
+}
+/**
+* Safely replace a JSON file: backup existing content, write via temp+rename,
+* verify the result parses, and restore the original content on failure.
+*/
+async function safe_json_write(path, data, indent = 2) {
+	await mkdir(dirname(path), { recursive: true });
+	const original_content = await file_exists$1(path) ? await readFile(path, "utf-8") : void 0;
+	const backup_path = original_content !== void 0 ? await create_backup(path, original_content) : void 0;
+	const tmp_path = join(dirname(path), `.${basename(path)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+	const next_content = JSON.stringify(data, null, indent);
+	try {
+		await writeFile(tmp_path, next_content, "utf-8");
+		await rename(tmp_path, path);
+		const written = await readFile(path, "utf-8");
+		JSON.parse(written);
+		return {
+			path,
+			...backup_path ? { backup_path } : {}
 		};
-		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();
+	} catch (error) {
+		await rm(tmp_path, { force: true }).catch(() => void 0);
+		if (original_content !== void 0) await writeFile(path, original_content, "utf-8");
+		else await rm(path, { force: true }).catch(() => void 0);
+		throw error;
+	}
+}
+async function list_config_backups() {
+	const backups_dir = get_backups_dir();
+	try {
+		const files = await readdir(backups_dir);
+		const backups = [];
+		for (const file of files) {
+			if (!file.startsWith("config-") || !file.endsWith(".json")) continue;
+			if (file.endsWith(".meta.json")) continue;
+			const backup_path = join(backups_dir, file);
+			try {
+				const meta = JSON.parse(await readFile(`${backup_path}.meta.json`, "utf-8"));
+				if (typeof meta.original_path !== "string" || typeof meta.created_at !== "string") continue;
+				backups.push({
+					path: backup_path,
+					original_path: meta.original_path,
+					created_at: meta.created_at
 				});
-				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"
+			} catch {}
+		}
+		return backups.sort((a, b) => b.created_at.localeCompare(a.created_at));
+	} catch {
+		return [];
+	}
+}
+async function restore_config_backup(backup_path) {
+	const backup = (await list_config_backups()).find((candidate) => candidate.path === backup_path || basename(candidate.path) === backup_path);
+	if (!backup) throw new Error(`Config backup '${backup_path}' not found.`);
+	const content = await readFile(backup.path, "utf-8");
+	const parsed = JSON.parse(content);
+	await safe_json_write(backup.original_path, parsed);
+	return backup;
+}
+//#endregion
+//#region src/utils/atomic-write.ts
+/**
+* Atomically write a JSON file with fresh-read merging.
+*
+* 1. Re-reads the file right before writing to pick up concurrent changes
+* 2. Applies the merge function to the freshest data
+* 3. Writes to a temp file, then renames (atomic on same filesystem)
+*/
+async function atomic_json_write(file_path, merge) {
+	let existing = {};
+	try {
+		const content = await readFile(file_path, "utf-8");
+		existing = JSON.parse(content);
+	} catch {}
+	await safe_json_write(file_path, merge(existing), 2);
+}
+//#endregion
+//#region src/core/settings.ts
+async function read_claude_settings() {
+	const settings_path = get_claude_settings_path();
+	try {
+		await access(settings_path);
+		const content = await readFile(settings_path, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+async function write_claude_settings(updates) {
+	await atomic_json_write(get_claude_settings_path(), (existing) => {
+		for (const [key, value] of Object.entries(updates)) existing[key] = value;
+		return existing;
+	});
+}
+/**
+* Parse enabledPlugins into structured list.
+* Keys are in format "plugin-name@marketplace-name"
+*/
+function get_all_plugins(settings) {
+	const enabled_plugins = settings.enabledPlugins || {};
+	return Object.entries(enabled_plugins).map(([key, enabled]) => {
+		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",
+			enabled
+		};
+	});
+}
+/**
+* Build the enabledPlugins record from a list of PluginInfo
+*/
+function build_enabled_plugins(plugins) {
+	const result = {};
+	for (const plugin of plugins) {
+		const key = `${plugin.name}@${plugin.marketplace}`;
+		result[key] = plugin.enabled;
+	}
+	return result;
+}
+async function read_settings_file(path) {
+	try {
+		await access(path);
+		const content = await readFile(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+function get_settings_paths() {
+	return [
+		{
+			scope: "user",
+			path: resolve(process.env.HOME || process.env.USERPROFILE || "", ".claude", "settings.json")
+		},
+		{
+			scope: "project",
+			path: resolve(process.cwd(), ".claude", "settings.json")
+		},
+		{
+			scope: "project-local",
+			path: resolve(process.cwd(), ".claude", "settings.local.json")
+		}
+	];
+}
+/**
+* Read all hooks across all scopes (settings + plugins), flattened for display.
+*/
+async function get_all_hooks() {
+	const entries = [];
+	for (const { scope, path } of get_settings_paths()) {
+		const hooks = (await read_settings_file(path)).hooks;
+		if (!hooks) continue;
+		for (const [event, matchers] of Object.entries(hooks)) {
+			if (!Array.isArray(matchers)) continue;
+			for (let mi = 0; mi < matchers.length; mi++) {
+				const m = matchers[mi];
+				if (!m.hooks?.length) continue;
+				for (let hi = 0; hi < m.hooks.length; hi++) entries.push({
+					event,
+					matcher: m.matcher,
+					handler: m.hooks[hi],
+					scope,
+					source: scope,
+					matcher_index: mi,
+					hook_index: hi
 				});
-				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"}`);
 	}
+	const plugin_hooks = await get_all_plugin_hooks();
+	entries.push(...plugin_hooks);
+	return entries;
 }
-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}}`;
+/**
+* Scan all installed plugins for hooks.json and return flattened hook entries.
+* Checks both cache and marketplace source paths since Claude Code reads from both.
+*/
+async function get_all_plugin_hooks() {
+	const { read_installed_plugins } = await import("./plugin-cache-BSgB42wa.js").then((n) => n.s);
+	const { get_marketplaces_dir } = await import("./paths-BPISiJi4.js").then((n) => n.b);
+	const installed = await read_installed_plugins();
+	const entries = [];
+	const seen_hooks = /* @__PURE__ */ new Set();
+	for (const [plugin_key, installs] of Object.entries(installed.plugins)) {
+		if (!installs?.length) continue;
+		const install = installs[0];
+		const at_index = plugin_key.lastIndexOf("@");
+		const plugin_name = at_index > 0 ? plugin_key.substring(0, at_index) : plugin_key;
+		const marketplace_name = at_index > 0 ? plugin_key.substring(at_index + 1) : "";
+		const hooks_paths = [join(install.installPath, "hooks", "hooks.json")];
+		if (marketplace_name) hooks_paths.push(join(get_marketplaces_dir(), marketplace_name, "plugins", plugin_name, "hooks", "hooks.json"));
+		for (const hooks_path of hooks_paths) {
+			let hooks_data;
 			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";
+				const content = await readFile(hooks_path, "utf-8");
+				hooks_data = JSON.parse(content);
 			} catch {
-				return "Invalid JSON format";
+				continue;
+			}
+			const hooks = hooks_data.hooks || hooks_data;
+			for (const [event, matchers] of Object.entries(hooks)) {
+				if (!Array.isArray(matchers)) continue;
+				for (let mi = 0; mi < matchers.length; mi++) {
+					const m = matchers[mi];
+					if (!m.hooks?.length) continue;
+					for (let hi = 0; hi < m.hooks.length; hi++) {
+						const h = m.hooks[hi];
+						const dedup_key = `${plugin_key}:${event}:${h.type}:${h.command || h.url || h.prompt}`;
+						if (seen_hooks.has(dedup_key)) continue;
+						seen_hooks.add(dedup_key);
+						entries.push({
+							event,
+							matcher: m.matcher,
+							handler: h,
+							scope: "user",
+							source: "plugin",
+							matcher_index: mi,
+							hook_index: hi,
+							plugin_key,
+							hooks_json_path: hooks_path
+						});
+					}
+				}
 			}
 		}
+	}
+	return entries;
+}
+/**
+* Remove a specific hook entry by scope/event/indices.
+*/
+async function remove_hook(entry) {
+	const scope_path = get_settings_paths().find((s) => s.scope === entry.scope);
+	if (!scope_path) throw new Error(`Unknown scope: ${entry.scope}`);
+	await atomic_json_write(scope_path.path, (existing) => {
+		const hooks = existing.hooks;
+		if (!hooks) return existing;
+		const matchers = hooks[entry.event];
+		if (!matchers?.[entry.matcher_index]) return existing;
+		const matcher = matchers[entry.matcher_index];
+		matcher.hooks.splice(entry.hook_index, 1);
+		if (matcher.hooks.length === 0) matchers.splice(entry.matcher_index, 1);
+		if (matchers.length === 0) delete hooks[entry.event];
+		if (Object.keys(hooks).length === 0) delete existing.hooks;
+		return existing;
 	});
-	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;
+}
+/**
+* Add a hook to a specific scope.
+*/
+async function add_hook(scope, event, matcher, handler) {
+	const scope_path = get_settings_paths().find((s) => s.scope === scope);
+	if (!scope_path) throw new Error(`Unknown scope: ${scope}`);
+	await atomic_json_write(scope_path.path, (existing) => {
+		if (!existing.hooks) existing.hooks = {};
+		const hooks = existing.hooks;
+		if (!hooks[event]) hooks[event] = [];
+		const matchers = hooks[event];
+		const existing_matcher = matchers.find((m) => (m.matcher || void 0) === matcher);
+		if (existing_matcher) existing_matcher.hooks.push(handler);
+		else {
+			const new_matcher = { hooks: [handler] };
+			if (matcher) new_matcher.matcher = matcher;
+			matchers.push(new_matcher);
 		}
-		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"}`);
-	}
+		return existing;
+	});
 }
 //#endregion
 //#region src/commands/backup.ts
@@ -251,79 +344,1193 @@ async function cleanup_old_backups(prefix) {
 	} catch {}
 }
 //#endregion
+//#region src/core/client-config.ts
+const client_options_to_skip = new Set([
+	"name",
+	"type",
+	"command",
+	"args",
+	"url",
+	"httpUrl",
+	"serverUrl",
+	"env",
+	"headers",
+	"description",
+	"disabled",
+	"enabled",
+	"environment"
+]);
+async function file_exists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function read_json_file(path) {
+	try {
+		return parse_json_or_jsonc(await readFile(path, "utf-8"));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function write_json_file(path, data) {
+	await safe_json_write(path, data, 2);
+}
+function parse_json_or_jsonc(content) {
+	try {
+		return JSON.parse(content);
+	} catch {
+		return JSON.parse(remove_jsonc_syntax(content));
+	}
+}
+function remove_jsonc_syntax(content) {
+	let result = "";
+	let in_string = false;
+	let quote = "";
+	let escaped = false;
+	let in_line_comment = false;
+	let in_block_comment = false;
+	for (let index = 0; index < content.length; index++) {
+		const char = content[index];
+		const next = content[index + 1];
+		if (in_line_comment) {
+			if (char === "\n" || char === "\r") {
+				in_line_comment = false;
+				result += char;
+			}
+			continue;
+		}
+		if (in_block_comment) {
+			if (char === "*" && next === "/") {
+				in_block_comment = false;
+				index++;
+			}
+			continue;
+		}
+		if (in_string) {
+			result += char;
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) in_string = false;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			in_string = true;
+			quote = char;
+			result += char;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			in_line_comment = true;
+			index++;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			in_block_comment = true;
+			index++;
+			continue;
+		}
+		result += char;
+	}
+	return remove_trailing_commas(result);
+}
+function remove_trailing_commas(content) {
+	let result = "";
+	let in_string = false;
+	let quote = "";
+	let escaped = false;
+	for (let index = 0; index < content.length; index++) {
+		const char = content[index];
+		if (in_string) {
+			result += char;
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) in_string = false;
+			continue;
+		}
+		if (char === "\"") {
+			in_string = true;
+			quote = char;
+			result += char;
+			continue;
+		}
+		if (char === ",") {
+			let cursor = index + 1;
+			while (/\s/.test(content[cursor] ?? "")) cursor++;
+			if (content[cursor] === "}" || content[cursor] === "]") continue;
+		}
+		result += char;
+	}
+	return result;
+}
+function string_record(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) if (typeof item === "string") result[key] = item;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function string_array(value) {
+	if (!Array.isArray(value)) return void 0;
+	const values = value.filter((item) => typeof item === "string");
+	return values.length > 0 ? values : void 0;
+}
+function infer_transport(config) {
+	if (config.type === "http" || config.type === "remote" || config.httpUrl || config.serverUrl) return "http";
+	if (config.type === "sse") return "sse";
+	if (config.url && !config.command) return "http";
+	return "stdio";
+}
+function normalize_mcp_server(name, config) {
+	const transport = infer_transport(config);
+	const url = typeof config.httpUrl === "string" ? config.httpUrl : typeof config.serverUrl === "string" ? config.serverUrl : typeof config.url === "string" ? config.url : void 0;
+	const client_options = {};
+	for (const [key, value] of Object.entries(config)) if (!client_options_to_skip.has(key)) client_options[key] = value;
+	const command_array = string_array(config.command);
+	const command = typeof config.command === "string" ? config.command : command_array?.[0];
+	const args = string_array(config.args) ?? command_array?.slice(1);
+	const env = string_record(config.env) ?? string_record(config.environment);
+	const disabled = typeof config.disabled === "boolean" ? config.disabled : typeof config.enabled === "boolean" ? !config.enabled : void 0;
+	return {
+		name,
+		transport,
+		...command ? { command } : {},
+		...args && args.length > 0 ? { args } : {},
+		...url ? { url } : {},
+		...env ? { env } : {},
+		...string_record(config.headers) ? { headers: string_record(config.headers) } : {},
+		...typeof config.description === "string" ? { description: config.description } : {},
+		...typeof disabled === "boolean" ? { disabled } : {},
+		...Object.keys(client_options).length > 0 ? { client_options } : {}
+	};
+}
+function get_server_record(data, key) {
+	const servers = data?.[key];
+	if (!servers || typeof servers !== "object" || Array.isArray(servers)) return {};
+	return Object.fromEntries(Object.entries(servers).filter((entry) => {
+		const [, value] = entry;
+		return !!value && typeof value === "object" && !Array.isArray(value);
+	}));
+}
+function read_server_map(data, key) {
+	return Object.entries(get_server_record(data, key)).map(([name, config]) => normalize_mcp_server(name, config));
+}
+function set_server_enabled(config, enabled, mode) {
+	if (mode === "enabled" || "enabled" in config) {
+		config.enabled = enabled;
+		delete config.disabled;
+		return;
+	}
+	config.disabled = !enabled;
+}
+function portable_to_json(server, mode) {
+	const result = { ...server.client_options };
+	if (server.transport !== "stdio") result.type = server.transport;
+	if (server.command) result.command = server.command;
+	if (server.args && server.args.length > 0) result.args = server.args;
+	if (server.url) result.url = server.url;
+	if (server.env) result.env = server.env;
+	if (server.headers) result.headers = server.headers;
+	if (server.description) result.description = server.description;
+	if (typeof server.disabled === "boolean") set_server_enabled(result, !server.disabled, mode);
+	return result;
+}
+function create_json_adapter(options) {
+	return {
+		id: options.id,
+		label: options.label,
+		locations: options.locations,
+		async read(scope) {
+			const locations = scope ? options.locations().filter((location) => location.scope === scope) : options.locations();
+			const result = [];
+			for (const location of locations) for (const server of await this.readLocation(location)) result.push(server);
+			return result;
+		},
+		async readLocation(location) {
+			return read_server_map(await read_json_file(location.path), options.serverKey);
+		},
+		async writeEnabled(location, enabled_names) {
+			const data = await read_json_file(location.path) ?? {};
+			const servers = get_server_record(data, options.serverKey);
+			const enabled = new Set(enabled_names);
+			for (const [name, config] of Object.entries(servers)) set_server_enabled(config, enabled.has(name), options.disabledMode ?? "disabled");
+			data[options.serverKey] = servers;
+			await write_json_file(location.path, data);
+		},
+		async write_server(location, server) {
+			const data = await read_json_file(location.path) ?? {};
+			const servers = get_server_record(data, options.serverKey);
+			servers[server.name] = portable_to_json(server, options.disabledMode ?? "disabled");
+			data[options.serverKey] = servers;
+			await write_json_file(location.path, data);
+		},
+		async write_server_config(location, name, config) {
+			const data = await read_json_file(location.path) ?? {};
+			const servers = get_server_record(data, options.serverKey);
+			servers[name] = config;
+			data[options.serverKey] = servers;
+			await write_json_file(location.path, data);
+		},
+		async remove_server(location, name) {
+			const data = await read_json_file(location.path) ?? {};
+			const servers = get_server_record(data, options.serverKey);
+			delete servers[name];
+			data[options.serverKey] = servers;
+			await write_json_file(location.path, data);
+		}
+	};
+}
+function project_path(path) {
+	return join(process.cwd(), path);
+}
+const client_adapters = [
+	{
+		id: "claude-code",
+		label: "Claude Code",
+		locations: () => [
+			{
+				scope: "local",
+				path: get_claude_config_path(),
+				description: "~/.claude.json projects[cwd].mcpServers"
+			},
+			{
+				scope: "project",
+				path: project_path(".mcp.json"),
+				description: ".mcp.json mcpServers"
+			},
+			{
+				scope: "user",
+				path: get_claude_config_path(),
+				description: "~/.claude.json mcpServers"
+			}
+		],
+		async read(scope) {
+			const locations = scope ? this.locations().filter((location) => location.scope === scope) : this.locations();
+			const result = [];
+			for (const location of locations) result.push(...await this.readLocation(location));
+			return result;
+		},
+		async readLocation(location) {
+			if (location.scope === "project") return read_server_map(await read_json_file(location.path), "mcpServers");
+			const data = await read_json_file(get_claude_config_path());
+			if (location.scope === "user") return read_server_map(data, "mcpServers");
+			const projects = data?.projects;
+			if (!projects || typeof projects !== "object" || Array.isArray(projects)) return [];
+			const project_config = projects[process.cwd()];
+			if (!project_config || typeof project_config !== "object" || Array.isArray(project_config)) return [];
+			return read_server_map(project_config, "mcpServers");
+		}
+	},
+	create_json_adapter({
+		id: "gemini-cli",
+		label: "Gemini CLI",
+		serverKey: "mcpServers",
+		locations: () => [{
+			scope: "project",
+			path: project_path(".gemini/settings.json"),
+			description: ".gemini/settings.json mcpServers"
+		}, {
+			scope: "user",
+			path: join(homedir(), ".gemini/settings.json"),
+			description: "~/.gemini/settings.json mcpServers"
+		}]
+	}),
+	create_json_adapter({
+		id: "vscode",
+		label: "VS Code / GitHub Copilot",
+		serverKey: "servers",
+		locations: () => [{
+			scope: "project",
+			path: project_path(".vscode/mcp.json"),
+			description: ".vscode/mcp.json servers"
+		}]
+	}),
+	create_json_adapter({
+		id: "cursor",
+		label: "Cursor",
+		serverKey: "mcpServers",
+		locations: () => [{
+			scope: "project",
+			path: project_path(".cursor/mcp.json"),
+			description: ".cursor/mcp.json mcpServers"
+		}, {
+			scope: "user",
+			path: join(homedir(), ".cursor/mcp.json"),
+			description: "~/.cursor/mcp.json mcpServers"
+		}]
+	}),
+	create_json_adapter({
+		id: "windsurf",
+		label: "Windsurf",
+		serverKey: "mcpServers",
+		locations: () => [{
+			scope: "user",
+			path: join(homedir(), ".codeium/windsurf/mcp_config.json"),
+			description: "~/.codeium/windsurf/mcp_config.json mcpServers"
+		}]
+	}),
+	create_json_adapter({
+		id: "opencode",
+		label: "OpenCode",
+		serverKey: "mcp",
+		disabledMode: "enabled",
+		locations: () => [{
+			scope: "project",
+			path: project_path("opencode.json"),
+			description: "opencode.json mcp"
+		}, {
+			scope: "user",
+			path: join(homedir(), ".config/opencode/opencode.json"),
+			description: "~/.config/opencode/opencode.json mcp"
+		}]
+	}),
+	create_json_adapter({
+		id: "pi",
+		label: "Pi MCP Adapter",
+		serverKey: "mcpServers",
+		locations: () => [
+			{
+				scope: "user",
+				path: join(homedir(), ".config/mcp/mcp.json"),
+				description: "~/.config/mcp/mcp.json shared MCP config"
+			},
+			{
+				scope: "user",
+				path: join(homedir(), ".pi/agent/mcp.json"),
+				description: "~/.pi/agent/mcp.json Pi global override"
+			},
+			{
+				scope: "project",
+				path: project_path(".mcp.json"),
+				description: ".mcp.json shared project MCP config"
+			},
+			{
+				scope: "project",
+				path: project_path(".pi/mcp.json"),
+				description: ".pi/mcp.json Pi project override"
+			}
+		]
+	})
+];
+function get_client_adapter(id) {
+	return client_adapters.find((adapter) => adapter.id === id) ?? null;
+}
+function resolve_client_location(adapter, scope, path) {
+	let locations = adapter.locations();
+	if (path) locations = locations.filter((location) => location.path === path);
+	else if (scope) locations = locations.filter((location) => location.scope === scope);
+	if (locations.length === 1) return locations[0];
+	if (locations.length === 0) throw new Error(`No ${adapter.label} config location matches${scope ? ` scope '${scope}'` : ""}${path ? ` path '${path}'` : ""}.`);
+	throw new Error(`${adapter.label} has multiple matching config locations. Pass --location with one of: ${locations.map((location) => location.path).join(", ")}`);
+}
+async function add_client_server(adapter, location, server) {
+	if (!adapter.write_server) throw new Error(`${adapter.label} support cannot add servers yet.`);
+	await adapter.write_server(location, server);
+}
+async function add_client_server_config(adapter, location, name, config) {
+	if (!adapter.write_server_config) throw new Error(`${adapter.label} support cannot add servers yet.`);
+	await adapter.write_server_config(location, name, config);
+}
+async function remove_client_server(adapter, location, server_name) {
+	if (!adapter.remove_server) throw new Error(`${adapter.label} support cannot remove servers yet.`);
+	await adapter.remove_server(location, server_name);
+}
+async function set_client_server_enabled(adapter, location, server_name, enabled) {
+	if (!adapter.writeEnabled) throw new Error(`${adapter.label} support is read-only.`);
+	const servers = await adapter.readLocation(location);
+	const server = servers.find((candidate) => candidate.name === server_name);
+	if (!server) throw new Error(`Server '${server_name}' not found at ${location.path}.`);
+	const enabled_names = new Set(servers.filter((candidate) => candidate.disabled !== true).map((candidate) => candidate.name));
+	if (enabled) enabled_names.add(server.name);
+	else enabled_names.delete(server.name);
+	await adapter.writeEnabled(location, [...enabled_names]);
+	return enabled_names.size;
+}
+async function list_client_locations() {
+	return await Promise.all(client_adapters.flatMap((adapter) => adapter.locations().map(async (location) => ({
+		client: adapter.id,
+		label: adapter.label,
+		...location,
+		exists: await file_exists(location.path)
+	}))));
+}
+//#endregion
+//#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 atomic_json_write(registry_path, () => registry);
+}
+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-DzMmTJYL.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
+//#region src/utils/claude-cli.ts
+const exec_file_async$1 = promisify(execFile);
+/**
+* Check if Claude CLI is available
+*/
+async function check_claude_cli() {
+	try {
+		await exec_file_async$1("claude", ["--version"]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Validate environment variable key.
+* Must start with letter or underscore, contain only alphanumeric and underscores.
+*/
+function is_valid_env_key(key) {
+	return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+/**
+* Build args array for claude mcp add command.
+* Returns raw args — no shell escaping needed since we use execFile.
+*/
+function build_add_args(server, scope) {
+	const args = ["mcp", "add"];
+	args.push(server.name);
+	const transport = server.type || "stdio";
+	if (transport !== "stdio") args.push("--transport", transport);
+	args.push("--scope", scope);
+	if (transport === "stdio") {
+		if (server.env) {
+			for (const [key, value] of Object.entries(server.env)) if (is_valid_env_key(key)) args.push("-e", `${key}=${value}`);
+		}
+		if ("command" in server && server.command) {
+			args.push("--");
+			args.push(server.command);
+			if (server.args && server.args.length > 0) args.push(...server.args);
+		}
+	} else {
+		if ("url" in server && server.url) args.push(server.url);
+		if ("headers" in server && server.headers) for (const [key, value] of Object.entries(server.headers)) args.push("-H", `${key}: ${value}`);
+	}
+	return args;
+}
+/**
+* Run a claude CLI command using execFile (no shell).
+* This avoids all shell escaping issues on every platform.
+*/
+async function run_claude(args) {
+	const result = await exec_file_async$1("claude", args);
+	return {
+		stdout: redact_text(result.stdout),
+		stderr: redact_text(result.stderr)
+	};
+}
+function get_redacted_error_message(error) {
+	return redact_text(error instanceof Error ? error.message : "Unknown error");
+}
+/**
+* Add an MCP server using Claude CLI
+*/
+async function add_mcp_via_cli(server, scope) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude(build_add_args(server, scope));
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to add server via CLI: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Remove an MCP server using Claude CLI
+*/
+function build_remove_args(name, scope) {
+	return scope ? [
+		"mcp",
+		"remove",
+		name,
+		"--scope",
+		scope
+	] : [
+		"mcp",
+		"remove",
+		name
+	];
+}
+async function remove_mcp_via_cli(name, scope) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude(build_remove_args(name, scope));
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to remove server via CLI: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Install a plugin via Claude CLI
+*/
+async function install_plugin_via_cli(key, scope = "user") {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude([
+			"plugin",
+			"install",
+			key,
+			"--scope",
+			scope
+		]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to install plugin: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Uninstall a plugin via Claude CLI
+*/
+async function uninstall_plugin_via_cli(key, scope = "user") {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude([
+			"plugin",
+			"uninstall",
+			key,
+			"--scope",
+			scope
+		]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to uninstall plugin: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Update a plugin via Claude CLI
+*/
+async function update_plugin_via_cli(key, scope = "user") {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude([
+			"plugin",
+			"update",
+			key,
+			"--scope",
+			scope
+		]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to update plugin: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+const GITHUB_OWNER_PATTERN = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?";
+const GITHUB_REPO_PATTERN = "[A-Za-z0-9._-]+";
+/**
+* Extract GitHub owner/repo from various source formats.
+* Returns null if not a recognizable GitHub reference.
+*/
+function parse_github_repo(source) {
+	const trimmed = source.trim();
+	try {
+		const url = new URL(trimmed);
+		if (url.hostname !== "github.com") return null;
+		const [owner, raw_repo, ...rest] = url.pathname.split("/").filter(Boolean);
+		if (!owner || !raw_repo || rest.length > 0) return null;
+		const repo = raw_repo.replace(/\.git$/, "");
+		if (!is_valid_github_repo(owner, repo)) return null;
+		return {
+			owner,
+			repo,
+			kind: "https"
+		};
+	} catch {}
+	const ssh_match = trimmed.match(new RegExp(`^git@github\\.com:(${GITHUB_OWNER_PATTERN})/(${GITHUB_REPO_PATTERN})(?:\\.git)?$`));
+	if (ssh_match) return {
+		owner: ssh_match[1],
+		repo: ssh_match[2].replace(/\.git$/, ""),
+		kind: "ssh"
+	};
+	const shorthand_match = trimmed.match(new RegExp(`^(${GITHUB_OWNER_PATTERN})/(${GITHUB_REPO_PATTERN})$`));
+	if (shorthand_match) return {
+		owner: shorthand_match[1],
+		repo: shorthand_match[2],
+		kind: "shorthand"
+	};
+	return null;
+}
+function is_valid_github_repo(owner, repo) {
+	return new RegExp(`^${GITHUB_OWNER_PATTERN}$`).test(owner) && new RegExp(`^${GITHUB_REPO_PATTERN}$`).test(repo);
+}
+function build_marketplace_add_args(source) {
+	return [
+		"plugin",
+		"marketplace",
+		"add",
+		source
+	];
+}
+function get_github_repo_id(ref) {
+	return `${ref.owner}/${ref.repo}`;
+}
+function get_github_clone_urls(ref) {
+	const repo_id = get_github_repo_id(ref);
+	const https_url = `https://github.com/${repo_id}.git`;
+	const ssh_url = `git@github.com:${repo_id}.git`;
+	if (ref.kind === "https") return [https_url];
+	if (ref.kind === "ssh") return [ssh_url];
+	return [https_url, ssh_url];
+}
+function get_process_error_output(error) {
+	const process_error = error;
+	return redact_text([
+		process_error.message,
+		process_error.stderr?.toString(),
+		process_error.stdout?.toString()
+	].filter(Boolean).join("\n"));
+}
+async function can_access_with_git(url) {
+	try {
+		await exec_file_async$1("git", [
+			"ls-remote",
+			"--exit-code",
+			url,
+			"HEAD"
+		], {
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0",
+				GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
+			},
+			timeout: 15e3
+		});
+		return null;
+	} catch (error) {
+		return get_process_error_output(error);
+	}
+}
+async function can_view_with_gh(repo_id) {
+	try {
+		await exec_file_async$1("gh", [
+			"repo",
+			"view",
+			repo_id,
+			"--json",
+			"nameWithOwner"
+		], { timeout: 15e3 });
+		return true;
+	} catch (error) {
+		const message = get_process_error_output(error).toLowerCase();
+		if (message.includes("could not resolve") || message.includes("not found") || message.includes("repository not found")) return false;
+		return null;
+	}
+}
+async function get_github_api_status(repo_id) {
+	try {
+		return (await fetch(`https://api.github.com/repos/${repo_id}`, {
+			method: "GET",
+			headers: { Accept: "application/vnd.github.v3+json" }
+		})).status;
+	} catch {
+		return null;
+	}
+}
+/**
+* Validate that a GitHub repository can be accessed by git without cloning it.
+* Returns an error message if validation fails, null if OK.
+*/
+async function validate_github_repo(ref) {
+	const repo_id = get_github_repo_id(ref);
+	const git_errors = [];
+	for (const url of get_github_clone_urls(ref)) {
+		const git_error = await can_access_with_git(url);
+		if (!git_error) return null;
+		git_errors.push(git_error);
+	}
+	const gh_visible = await can_view_with_gh(repo_id);
+	if (gh_visible === false) return `Repository '${repo_id}' not found or not accessible with your GitHub account.`;
+	const api_status = await get_github_api_status(repo_id);
+	if (api_status === 404 && gh_visible !== true) return `Repository '${repo_id}' not found or private/inaccessible. Check the name, sign in with 'gh auth login', or use an SSH URL with access.`;
+	if (api_status === 403 && gh_visible !== true) return `Unable to validate '${repo_id}' because GitHub API access was denied or rate-limited. Git access also failed; check your credentials.`;
+	return format_git_access_error(ref, git_errors.join("\n"));
+}
+function format_git_access_error(ref, message) {
+	const repo_id = get_github_repo_id(ref);
+	const lower = message.toLowerCase();
+	if (ref.kind === "shorthand" && (lower.includes("could not read username") || lower.includes("authentication failed")) && (lower.includes("permission denied (publickey)") || lower.includes("ssh authentication"))) return `Repository '${repo_id}' exists, but Git cannot access it over HTTPS or SSH. Run 'gh auth login' and 'gh auth setup-git', or configure an SSH key with GitHub.`;
+	if (ref.kind === "https" || lower.includes("https authentication failed") || lower.includes("could not read username") || lower.includes("authentication failed")) return `Repository '${repo_id}' exists, but HTTPS Git authentication failed. Run 'gh auth login' and 'gh auth setup-git', configure a Git credential helper, or use git@github.com:${repo_id}.git.`;
+	if (ref.kind === "ssh" || lower.includes("permission denied (publickey)") || lower.includes("ssh authentication")) return `SSH authentication failed for '${repo_id}'. Configure an SSH key with GitHub or use https://github.com/${repo_id}.git with a configured Git credential helper.`;
+	return `Unable to access GitHub repository '${repo_id}' with git. Check that the repository exists and that your HTTPS or SSH credentials can clone it.`;
+}
+async function marketplace_add_via_cli(source) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	const gh = parse_github_repo(source);
+	if (gh) {
+		const validation_error = await validate_github_repo(gh);
+		if (validation_error) return {
+			success: false,
+			error: validation_error
+		};
+	}
+	try {
+		await run_claude(build_marketplace_add_args(source));
+		return { success: true };
+	} catch (error) {
+		const message = get_redacted_error_message(error);
+		const lower_message = message.toLowerCase();
+		if (gh) {
+			if (lower_message.includes("https authentication failed") || lower_message.includes("could not read username") || lower_message.includes("authentication failed")) return {
+				success: false,
+				error: format_git_access_error(gh, message)
+			};
+			if (message.includes("SSH") || message.includes("Permission denied (publickey)")) return {
+				success: false,
+				error: format_git_access_error(gh, message)
+			};
+		}
+		if (lower_message.includes("not found") || lower_message.includes("does not exist")) return {
+			success: false,
+			error: gh ? `Repository '${get_github_repo_id(gh)}' not found or not accessible with your GitHub account.` : `Repository '${source}' not found. Check the name and your access permissions.`
+		};
+		return {
+			success: false,
+			error: `Failed to add marketplace: ${message}`
+		};
+	}
+}
+/**
+* Remove a marketplace via Claude CLI
+*/
+async function marketplace_remove_via_cli(name) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude([
+			"plugin",
+			"marketplace",
+			"remove",
+			name
+		]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to remove marketplace: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Update marketplace(s) via Claude CLI
+*/
+async function marketplace_update_via_cli(name) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		const args = [
+			"plugin",
+			"marketplace",
+			"update"
+		];
+		if (name) args.push(name);
+		await run_claude(args);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to update marketplace: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* List marketplaces via Claude CLI
+*/
+async function marketplace_list_via_cli() {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		const { stdout } = await run_claude([
+			"plugin",
+			"marketplace",
+			"list"
+		]);
+		return {
+			success: true,
+			stdout: stdout.trim()
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to list marketplaces: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Get the scope description for display
+*/
+function get_scope_description(scope) {
+	switch (scope) {
+		case "local": return "This project only (default)";
+		case "project": return "Shared via .mcp.json (version controlled)";
+		case "user": return "Global - all projects";
+	}
+}
+/**
+* Validate a plugin or marketplace manifest via Claude CLI
+*/
+async function validate_plugin_via_cli(path) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		const { stdout } = await run_claude([
+			"plugin",
+			"validate",
+			path
+		]);
+		return {
+			success: true,
+			stdout: stdout.trim()
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: `Validation failed: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Get details about an MCP server via Claude CLI
+*/
+async function mcp_get_via_cli(name) {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		const { stdout } = await run_claude([
+			"mcp",
+			"get",
+			name
+		]);
+		return {
+			success: true,
+			stdout: stdout.trim()
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to get server details: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Add an MCP server from raw JSON via Claude CLI
+*/
+async function mcp_add_json_via_cli(name, json, scope = "local") {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude([
+			"mcp",
+			"add-json",
+			name,
+			json,
+			"--scope",
+			scope
+		]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to add server from JSON: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Reset project-scoped MCP server choices via Claude CLI
+*/
+async function mcp_reset_project_choices_via_cli() {
+	if (!await check_claude_cli()) return {
+		success: false,
+		error: "Claude CLI not found. Please install Claude Code CLI."
+	};
+	try {
+		await run_claude(["mcp", "reset-project-choices"]);
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: `Failed to reset project choices: ${get_redacted_error_message(error)}`
+		};
+	}
+}
+/**
+* Get scope options for select prompt
+*/
+function get_scope_options() {
+	return [
+		{
+			value: "local",
+			label: "Local",
+			hint: "This project only (default)"
+		},
+		{
+			value: "project",
+			label: "Project",
+			hint: "Shared via .mcp.json (git)"
+		},
+		{
+			value: "user",
+			label: "User (Global)",
+			hint: "Available in all projects"
+		}
+	];
+}
+//#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"
+		const client_id = await select({
+			message: "Which MCP client do you want to edit?",
+			options: client_adapters.map((adapter) => ({
+				value: adapter.id,
+				label: adapter.label
+			})),
+			initialValue: "claude-code"
 		});
-		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.");
+		if (typeof client_id === "symbol") return;
+		const adapter = client_adapters.find((candidate) => candidate.id === client_id);
+		if (!adapter) return;
+		if (adapter.id === "claude-code") {
+			await edit_claude_config();
 			return;
 		}
-		const currently_enabled = await get_enabled_servers_for_scope(scope);
-		const server_choices = all_servers.map((server) => ({
+		await edit_client_config(adapter);
+	} catch (error) {
+		throw new Error(`Failed to edit configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function edit_client_config(adapter) {
+	if (!adapter.writeEnabled) {
+		note(`${adapter.label} support is read-only for now.`);
+		return;
+	}
+	const location = await select_config_location(adapter);
+	if (!location) return;
+	const servers = await adapter.readLocation(location);
+	if (servers.length === 0) {
+		note(`No MCP servers found at ${location.path}.`);
+		return;
+	}
+	const selected_names = await multiselect({
+		message: `Toggle MCP servers for ${adapter.label}:`,
+		options: servers.map((server) => ({
+			value: server.name,
+			label: server.name,
+			hint: server_hint(server)
+		})),
+		initialValues: servers.filter((server) => server.disabled !== true).map((server) => server.name),
+		required: false
+	});
+	if (typeof selected_names === "symbol") return;
+	await adapter.writeEnabled(location, selected_names);
+	note(`Configuration updated!\nClient: ${adapter.label}\nConfig: ${location.path}\nEnabled servers: ${selected_names.length}`);
+}
+async function select_config_location(adapter) {
+	const locations = adapter.locations();
+	if (locations.length === 1) return locations[0];
+	const location_path = await select({
+		message: `Which ${adapter.label} configuration do you want to edit?`,
+		options: locations.map((location) => ({
+			value: location.path,
+			label: `${location.scope} — ${location.description}`,
+			hint: location.path
+		}))
+	});
+	if (typeof location_path === "symbol") return null;
+	return locations.find((location) => location.path === location_path) ?? null;
+}
+function server_hint(server) {
+	return [
+		server.disabled === true ? "off" : "on",
+		server.command ? [server.command, ...server.args ?? []].join(" ") : server.url ? redact_url(server.url) : server.transport,
+		server.description
+	].filter(Boolean).join(" · ");
+}
+async function edit_claude_config() {
+	const cli_available = await check_claude_cli();
+	const scope = await select({
+		message: "Which Claude Code 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 with the CLI first.");
+		return;
+	}
+	const currently_enabled = await get_enabled_servers_for_scope(scope);
+	const selected_server_names = await multiselect({
+		message: `Select MCP servers for ${get_scope_description(scope)}:`,
+		options: 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 {
+		})),
+		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 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) {
 					error_count++;
-					log.warn(`Failed to remove ${name}: ${result.error}`);
+					log.warn(`Failed to add ${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"}`);
+		for (const name of servers_to_remove) {
+			const result = await remove_mcp_via_cli(name, scope);
+			if (!result.success) {
+				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}`);
 	}
 }
 //#endregion
@@ -604,6 +1811,171 @@ async function manage_cache() {
 	}
 }
 //#endregion
+//#region src/core/hook-state.ts
+async function read_disabled_hooks() {
+	try {
+		const content = await readFile(get_disabled_hooks_path(), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return [];
+	}
+}
+async function write_disabled_hooks(entries) {
+	await ensure_directory_exists(get_mcpick_dir());
+	await safe_json_write(get_disabled_hooks_path(), entries, "	");
+}
+/**
+* Remove a specific hook handler from a hooks.json file by matching the handler.
+* Returns true if the hook was found and removed.
+*/
+async function remove_hook_from_file(hooks_path, event, handler) {
+	let content;
+	try {
+		content = await readFile(hooks_path, "utf-8");
+	} catch {
+		return false;
+	}
+	const hooks_data = JSON.parse(content);
+	const hooks_obj = hooks_data.hooks || hooks_data;
+	const matchers = hooks_obj[event];
+	if (!matchers) return false;
+	let removed = false;
+	for (const m of matchers) {
+		const idx = m.hooks?.findIndex((h) => h.type === handler.type && h.command === handler.command && h.url === handler.url && h.prompt === handler.prompt);
+		if (idx !== void 0 && idx >= 0) {
+			m.hooks.splice(idx, 1);
+			removed = true;
+			if (m.hooks.length === 0) matchers.splice(matchers.indexOf(m), 1);
+			break;
+		}
+	}
+	if (!removed) return false;
+	if (matchers.length === 0) delete hooks_obj[event];
+	await safe_json_write(hooks_path, hooks_data, "	");
+	return true;
+}
+/**
+* Get all hooks.json paths for a plugin (cache + marketplace source).
+*/
+function get_all_hooks_paths(plugin_key, primary_path) {
+	const paths = [primary_path];
+	const at_index = plugin_key.lastIndexOf("@");
+	if (at_index > 0) {
+		const plugin_name = plugin_key.substring(0, at_index);
+		const marketplace_name = plugin_key.substring(at_index + 1);
+		paths.push(join(get_marketplaces_dir(), marketplace_name, "plugins", plugin_name, "hooks", "hooks.json"));
+	}
+	return [...new Set(paths)];
+}
+/**
+* Disable a specific hook from a plugin.
+* Removes from both cache and marketplace source hooks.json files.
+*/
+async function disable_plugin_hook(entry) {
+	if (!entry.hooks_json_path || !entry.plugin_key) throw new Error("Not a plugin hook");
+	const disabled = await read_disabled_hooks();
+	disabled.push({
+		plugin_key: entry.plugin_key,
+		hooks_json_path: entry.hooks_json_path,
+		event: entry.event,
+		matcher: entry.matcher,
+		matcher_index: entry.matcher_index,
+		hook_index: entry.hook_index,
+		original_handler: entry.handler,
+		disabled_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await write_disabled_hooks(disabled);
+	const all_paths = get_all_hooks_paths(entry.plugin_key, entry.hooks_json_path);
+	for (const hooks_path of all_paths) await remove_hook_from_file(hooks_path, entry.event, entry.handler);
+}
+/**
+* Add a hook handler back into a hooks.json file.
+*/
+async function add_hook_to_file(hooks_path, event, matcher_pattern, handler) {
+	let hooks_data;
+	try {
+		const content = await readFile(hooks_path, "utf-8");
+		hooks_data = JSON.parse(content);
+	} catch {
+		hooks_data = { hooks: {} };
+	}
+	const hooks_obj = hooks_data.hooks || (hooks_data.hooks = {});
+	if (!hooks_obj[event]) hooks_obj[event] = [];
+	const matchers = hooks_obj[event];
+	let matcher = matchers.find((m) => (m.matcher || void 0) === matcher_pattern);
+	if (!matcher) {
+		matcher = { hooks: [] };
+		if (matcher_pattern) matcher.matcher = matcher_pattern;
+		matchers.push(matcher);
+	}
+	if (matcher.hooks.some((h) => h.type === handler.type && h.command === handler.command && h.url === handler.url && h.prompt === handler.prompt)) return;
+	matcher.hooks.push(handler);
+	await safe_json_write(hooks_path, hooks_data, "	");
+}
+/**
+* Re-enable a previously disabled plugin hook.
+* Restores to both cache and marketplace source hooks.json files.
+*/
+async function enable_plugin_hook(disabled_entry) {
+	const all_paths = get_all_hooks_paths(disabled_entry.plugin_key, disabled_entry.hooks_json_path);
+	for (const hooks_path of all_paths) await add_hook_to_file(hooks_path, disabled_entry.event, disabled_entry.matcher, disabled_entry.original_handler);
+	await write_disabled_hooks((await read_disabled_hooks()).filter((d) => !(d.plugin_key === disabled_entry.plugin_key && d.event === disabled_entry.event && d.disabled_at === disabled_entry.disabled_at)));
+}
+/**
+* Check if any previously disabled hooks have been restored (e.g. by marketplace update).
+* Returns entries that were re-added and need to be re-disabled.
+*/
+async function check_restored_hooks() {
+	const disabled = await read_disabled_hooks();
+	if (disabled.length === 0) return [];
+	const restored = [];
+	for (const entry of disabled) {
+		const all_paths = get_all_hooks_paths(entry.plugin_key, entry.hooks_json_path);
+		let found = false;
+		for (const hooks_path of all_paths) {
+			let hooks_data;
+			try {
+				const content = await readFile(hooks_path, "utf-8");
+				hooks_data = JSON.parse(content);
+			} catch {
+				continue;
+			}
+			const matchers = (hooks_data.hooks || hooks_data)[entry.event];
+			if (!matchers) continue;
+			for (const m of matchers) {
+				if ((m.matcher || void 0) !== entry.matcher) continue;
+				if (m.hooks?.some((h) => h.type === entry.original_handler.type && (h.command === entry.original_handler.command || h.url === entry.original_handler.url || h.prompt === entry.original_handler.prompt))) {
+					found = true;
+					break;
+				}
+			}
+			if (found) break;
+		}
+		if (found) restored.push(entry);
+	}
+	return restored;
+}
+/**
+* Re-disable hooks that were restored by a marketplace update.
+*/
+async function redisable_restored_hooks(restored) {
+	let success = 0;
+	let failed = 0;
+	for (const entry of restored) try {
+		const all_paths = get_all_hooks_paths(entry.plugin_key, entry.hooks_json_path);
+		let any_removed = false;
+		for (const hooks_path of all_paths) if (await remove_hook_from_file(hooks_path, entry.event, entry.original_handler)) any_removed = true;
+		if (any_removed) success++;
+		else failed++;
+	} catch {
+		failed++;
+	}
+	return {
+		success,
+		failed
+	};
+}
+//#endregion
 //#region src/commands/manage-hooks.ts
 function format_hook(entry) {
 	const detail = entry.handler.command || entry.handler.url || entry.handler.prompt || "(unknown)";
@@ -902,6 +2274,166 @@ async function manage_marketplace() {
 	}
 }
 //#endregion
+//#region src/utils/skills-cli.ts
+const exec_file_async = promisify(execFile);
+function split_cli_list(value) {
+	return (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function run_skills_cli(args) {
+	try {
+		const result = await exec_file_async("npx", [
+			"-y",
+			"skills@latest",
+			...args
+		], { env: {
+			...process.env,
+			CI: "1",
+			NO_COLOR: "1",
+			FORCE_COLOR: "0",
+			TERM: "dumb"
+		} });
+		return {
+			success: true,
+			stdout: redact_text(result.stdout.trim()),
+			stderr: redact_text(result.stderr.trim())
+		};
+	} catch (error) {
+		const err = error;
+		return {
+			success: false,
+			stdout: err.stdout ? redact_text(err.stdout.trim()) : void 0,
+			stderr: err.stderr ? redact_text(err.stderr.trim()) : void 0,
+			error: redact_text(err.message)
+		};
+	}
+}
+//#endregion
+//#region src/commands/manage-skills.ts
+const SKILL_AGENTS = [
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "pi",
+		label: "Pi"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	}
+];
+async function manage_skills() {
+	const action = await select({
+		message: "Portable skills",
+		options: [
+			{
+				value: "list",
+				label: "List installed skills"
+			},
+			{
+				value: "available",
+				label: "List skills available from source"
+			},
+			{
+				value: "install",
+				label: "Install skills"
+			},
+			{
+				value: "update",
+				label: "Update skills"
+			},
+			{
+				value: "back",
+				label: "Back"
+			}
+		]
+	});
+	if (typeof action === "symbol" || action === "back") return;
+	if (action === "list") {
+		const agent = await select_agent();
+		if (!agent) return;
+		await show_result(await run_skills_cli([
+			"list",
+			"--agent",
+			agent
+		]));
+		return;
+	}
+	if (action === "available") {
+		const source = await prompt_source();
+		if (!source) return;
+		await show_result(await run_skills_cli([
+			"add",
+			source,
+			"--list"
+		]));
+		return;
+	}
+	if (action === "install") {
+		const source = await prompt_source();
+		if (!source) return;
+		const agent = await select_agent();
+		if (!agent) return;
+		const skill = await text({
+			message: "Skill name or * for all skills:",
+			placeholder: "svelte-runes",
+			defaultValue: "*"
+		});
+		if (typeof skill === "symbol") return;
+		await show_result(await run_skills_cli([
+			"add",
+			source,
+			"--agent",
+			agent,
+			"--skill",
+			skill,
+			"--yes"
+		]));
+		return;
+	}
+	if (action === "update") await show_result(await run_skills_cli(["update", "--yes"]));
+}
+async function select_agent() {
+	const agent = await select({
+		message: "Which agent/client?",
+		options: [...SKILL_AGENTS, {
+			value: "*",
+			label: "All supported agents"
+		}],
+		initialValue: "pi"
+	});
+	return typeof agent === "symbol" ? null : agent;
+}
+async function prompt_source() {
+	const source = await text({
+		message: "Skills source:",
+		placeholder: "spences10/skills",
+		defaultValue: "spences10/skills"
+	});
+	return typeof source === "symbol" ? null : source;
+}
+async function show_result(result) {
+	if (result.success) {
+		if (result.stdout) log.info(result.stdout);
+		note("Done.");
+		return;
+	}
+	log.error(result.stderr || result.error || "skills CLI failed");
+}
+//#endregion
 //#region src/commands/restore.ts
 async function restore_config() {
 	try {
@@ -984,6 +2516,68 @@ function format_time_ago(date) {
 	else return "just now";
 }
 //#endregion
+//#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 safe_json_write(get_profile_path(name), profile_data, 2);
+	return {
+		serverCount: server_count,
+		pluginCount: plugin_count
+	};
+}
+//#endregion
 //#region src/index.ts
 function parse_args() {
 	const args = process.argv.slice(2);
@@ -1082,6 +2676,65 @@ async function handle_save_profile() {
 	if (counts.pluginCount > 0) parts.push(`${counts.pluginCount} plugins`);
 	log.success(`Profile '${name}' saved (${parts.join(", ")})`);
 }
+async function handle_client_tools() {
+	const client_id = await select({
+		message: "Which client?",
+		options: client_adapters.map((adapter) => ({
+			value: adapter.id,
+			label: adapter.label
+		})),
+		initialValue: "claude-code"
+	});
+	if (isCancel(client_id)) return;
+	if (client_id !== "claude-code") {
+		note(`${client_adapters.find((adapter) => adapter.id === client_id)?.label ?? client_id} currently has MCP server toggling only.\nUse “Enable / Disable MCP servers” from the main menu.`);
+		return;
+	}
+	const action = await select({
+		message: "Claude Code tools",
+		options: [
+			{
+				value: "plugins",
+				label: "Plugins",
+				hint: "Claude Code plugin enable/install/update"
+			},
+			{
+				value: "marketplaces",
+				label: "Marketplaces",
+				hint: "Claude Code plugin marketplaces"
+			},
+			{
+				value: "hooks",
+				label: "Hooks",
+				hint: "Claude Code settings/plugin hooks"
+			},
+			{
+				value: "cache",
+				label: "Plugin cache",
+				hint: "Claude Code plugin cache maintenance"
+			},
+			{
+				value: "back",
+				label: "Back"
+			}
+		]
+	});
+	if (isCancel(action) || action === "back") return;
+	switch (action) {
+		case "plugins":
+			await edit_plugins();
+			break;
+		case "marketplaces":
+			await manage_marketplace();
+			break;
+		case "hooks":
+			await manage_hooks();
+			break;
+		case "cache":
+			await manage_cache();
+			break;
+	}
+}
 async function main() {
 	const args = parse_args();
 	if (args.listProfiles) {
@@ -1096,8 +2749,8 @@ async function main() {
 		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");
+	intro("MCPick - MCP Configuration Manager");
+	log.info("Primary flow: choose a client, then toggle its MCP servers. Use CLI commands for adding/editing server definitions.");
 	while (true) try {
 		const action = await select({
 			message: "What would you like to do?",
@@ -1105,32 +2758,17 @@ async function main() {
 				{
 					value: "edit-config",
 					label: "Enable / Disable MCP servers",
-					hint: "Toggle MCP servers on/off"
-				},
-				{
-					value: "add-server",
-					label: "Add MCP server",
-					hint: "Register a new MCP server"
+					hint: "Choose client, then toggle servers"
 				},
 				{
-					value: "manage-marketplace",
-					label: "Manage marketplaces",
-					hint: "Add a marketplace, then install plugins from it"
+					value: "skills",
+					label: "Skills",
+					hint: "Install/list portable SKILL.md packs via skills CLI"
 				},
 				{
-					value: "edit-plugins",
-					label: "Manage plugins",
-					hint: "Toggle, install, uninstall, or update plugins"
-				},
-				{
-					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: "client-tools",
+					label: "Client-specific tools",
+					hint: "Plugins, hooks, marketplaces, cache where supported"
 				},
 				{
 					value: "load-profile",
@@ -1167,24 +2805,15 @@ async function main() {
 			case "edit-config":
 				await edit_config();
 				break;
-			case "edit-plugins":
-				await edit_plugins();
+			case "skills":
+				await manage_skills();
 				break;
-			case "manage-marketplace":
-				await manage_marketplace();
-				break;
-			case "manage-hooks":
-				await manage_hooks();
-				break;
-			case "manage-cache":
-				await manage_cache();
+			case "client-tools":
+				await handle_client_tools();
 				break;
 			case "backup":
 				await backup_config();
 				break;
-			case "add-server":
-				await add_server();
-				break;
 			case "restore":
 				await restore_config();
 				break;
@@ -1218,6 +2847,7 @@ async function main() {
 	}
 }
 const SUBCOMMANDS = new Set([
+	"clients",
 	"list",
 	"enable",
 	"disable",
@@ -1231,21 +2861,23 @@ const SUBCOMMANDS = new Set([
 	"backup",
 	"restore",
 	"profile",
+	"skills",
 	"plugins",
 	"cache",
 	"dev",
 	"marketplace",
-	"reload"
+	"reload",
+	"rollback"
 ]);
 const arg = process.argv[2];
 if (arg && SUBCOMMANDS.has(arg) || arg === "--help" || arg === "-h" || !process.stdout.isTTY) {
 	if (!arg && !process.stdout.isTTY) process.argv.push("--help");
-	import("./cli-CsFfnWBo.js").then((m) => m.run());
+	import("./cli-By-0nYNQ.js").then((m) => m.run());
 } else main().catch((error) => {
 	console.error("Fatal error:", error);
 	process.exit(1);
 });
 //#endregion
-export {};
+export { add_client_server as A, get_all_plugins as B, validate_plugin_via_cli as C, list_plugin_backups as D, list_backups as E, resolve_client_location as F, list_config_backups as G, remove_hook as H, set_client_server_enabled as I, restore_config_backup as K, add_hook as L, get_client_adapter as M, list_client_locations as N, read_server_registry as O, remove_client_server as P, build_enabled_plugins as R, update_plugin_via_cli as S, get_all_available_servers as T, write_claude_settings as U, read_claude_settings as V, atomic_json_write as W, mcp_add_json_via_cli as _, split_cli_list as a, remove_mcp_via_cli as b, enable_plugin_hook as c, add_mcp_via_cli as d, install_plugin_via_cli as f, marketplace_update_via_cli as g, marketplace_remove_via_cli as h, run_skills_cli as i, add_client_server_config as j, write_server_registry as k, read_disabled_hooks as l, marketplace_list_via_cli as m, load_profile as n, check_restored_hooks as o, marketplace_add_via_cli as p, save_profile as r, disable_plugin_hook as s, list_profiles as t, redisable_restored_hooks as u, mcp_get_via_cli as v, add_server_to_registry as w, uninstall_plugin_via_cli as x, mcp_reset_project_choices_via_cli as y, get_all_hooks as z };
 
 //# sourceMappingURL=index.js.map