mcpick 0.0.24 → 0.0.26

package/dist/index.js

@@ -1,115 +1,222 @@
 #!/usr/bin/env node
-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-DE58Fik_.js";
-import { a as redact_url, i as redact_text, o as redact_value } 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-DmLbh89d.js";
+import { S as get_server_registry_path, _ as get_plugin_backup_filename, a as get_backup_filename, b as get_profiles_dir, c as get_claude_settings_path, g as get_mcpick_dir, h as get_marketplaces_dir, i as ensure_directory_exists, l as get_current_project_path, o as get_backups_dir, r as safe_json_write, s as get_claude_config_path, x as get_project_mcp_json_path, y as get_profile_path } from "./safe-apply-B5flt8QC.js";
+import { t as atomic_json_write } from "./atomic-write-9pfXia-x.js";
+import { _ as redisable_restored_hooks, c as read_known_marketplaces, g as read_disabled_hooks, h as enable_plugin_hook, l as read_marketplace_manifest, m as disable_plugin_hook, n as clear_plugin_caches, p as check_restored_hooks, r as get_cached_plugins_info, s as read_installed_plugins, t as clean_orphaned_versions, u as refresh_all_marketplaces } from "./plugin-cache-Dj-lS1mA.js";
 import { cancel, confirm, intro, isCancel, log, multiselect, note, outro, select, text } from "@clack/prompts";
-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 { access, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { homedir } from "node:os";
+import * as v from "valibot";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-//#region src/utils/safe-apply.ts
-async function file_exists$1(path) {
+//#region src/core/validation.ts
+const mcp_server_schema_stdio = v.object({
+	type: v.optional(v.literal("stdio")),
+	command: v.pipe(v.string(), v.minLength(1)),
+	args: v.optional(v.array(v.string())),
+	env: v.optional(v.record(v.string(), v.string())),
+	description: v.optional(v.string())
+});
+const mcp_server_schema_sse = v.object({
+	type: v.literal("sse"),
+	env: v.optional(v.record(v.string(), v.string())),
+	url: v.pipe(v.string(), v.minLength(1)),
+	headers: v.optional(v.record(v.string(), v.string())),
+	description: v.optional(v.string())
+});
+const mcp_server_schema_http = v.object({
+	type: v.literal("http"),
+	env: v.optional(v.record(v.string(), v.string())),
+	url: v.pipe(v.string(), v.minLength(1)),
+	headers: v.optional(v.record(v.string(), v.string())),
+	description: v.optional(v.string())
+});
+const mcp_server_schema_base = v.union([
+	mcp_server_schema_stdio,
+	mcp_server_schema_sse,
+	mcp_server_schema_http
+]);
+const mcp_server_schema = v.intersect([v.object({ name: v.pipe(v.string(), v.minLength(1)) }), mcp_server_schema_base]);
+const claude_config_schema = v.object({ mcpServers: v.optional(v.record(v.string(), mcp_server_schema_base)) });
+const portable_mcp_server_schema = v.object({
+	name: v.pipe(v.string(), v.minLength(1)),
+	transport: v.union([
+		v.literal("stdio"),
+		v.literal("http"),
+		v.literal("sse")
+	]),
+	command: v.optional(v.string()),
+	args: v.optional(v.array(v.string())),
+	url: v.optional(v.string()),
+	env: v.optional(v.record(v.string(), v.string())),
+	headers: v.optional(v.record(v.string(), v.string())),
+	description: v.optional(v.string()),
+	disabled: v.optional(v.boolean()),
+	client_options: v.optional(v.record(v.string(), v.unknown()))
+});
+const server_registry_schema = v.object({
+	version: v.literal(3),
+	servers: v.array(portable_mcp_server_schema)
+});
+function validate_mcp_server(data) {
+	return v.parse(mcp_server_schema, data);
+}
+function validate_claude_config(data) {
+	return v.parse(claude_config_schema, data);
+}
+function validate_server_registry(data) {
+	return v.parse(server_registry_schema, data);
+}
+//#endregion
+//#region src/core/config.ts
+async function read_claude_config() {
+	const config_path = get_claude_config_path();
 	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
+		await access(config_path);
+		const config_content = await readFile(config_path, "utf-8");
+		return validate_claude_config(JSON.parse(config_content));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return { mcpServers: {} };
+		throw error;
 	}
 }
-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 write_claude_config(config) {
+	await atomic_json_write(get_claude_config_path(), (existing) => {
+		existing.mcpServers = config.mcpServers;
+		return existing;
+	});
 }
-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;
+function get_enabled_servers(config) {
+	if (!config.mcpServers) return [];
+	return Object.entries(config.mcpServers).map(([name, server]) => ({
+		...server,
+		name
+	}));
 }
 /**
-* Safely replace a JSON file: backup existing content, write via temp+rename,
-* verify the result parses, and restore the original content on failure.
+* Find a server's full config in a specific scope.
 */
-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 } : {}
-		};
-	} 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 find_server_in_scope(name, scope) {
+	if (scope === "user" || scope === "local") {
+		const config_path = get_claude_config_path();
+		try {
+			await access(config_path);
+			const content = await readFile(config_path, "utf-8");
+			const parsed = JSON.parse(content);
+			if (scope === "user") {
+				const server = parsed.mcpServers?.[name];
+				if (server) return {
+					server,
+					scope: "user"
+				};
+			} else {
+				const cwd = get_current_project_path();
+				const server = parsed.projects?.[cwd]?.mcpServers?.[name];
+				if (server) return {
+					server,
+					scope: "local"
+				};
+			}
+		} catch {}
+	} else if (scope === "project") {
+		const mcp_path = get_project_mcp_json_path();
+		try {
+			await access(mcp_path);
+			const content = await readFile(mcp_path, "utf-8");
+			const server = JSON.parse(content).mcpServers?.[name];
+			if (server) return {
+				server,
+				scope: "project"
+			};
+		} catch {}
 	}
+	return null;
 }
-async function list_config_backups() {
-	const backups_dir = get_backups_dir();
+/**
+* Auto-detect which scope a server lives in.
+* Searches local → project → user.
+*/
+async function detect_server_scope(name) {
+	for (const scope of [
+		"local",
+		"project",
+		"user"
+	]) {
+		const result = await find_server_in_scope(name, scope);
+		if (result) return result;
+	}
+	return null;
+}
+/**
+* Read full Claude config including projects section
+*/
+async function read_claude_config_full() {
+	const config_path = get_claude_config_path();
 	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
-				});
-			} catch {}
-		}
-		return backups.sort((a, b) => b.created_at.localeCompare(a.created_at));
+		await access(config_path);
+		const config_content = await readFile(config_path, "utf-8");
+		return JSON.parse(config_content);
 	} catch {
-		return [];
+		return {
+			mcpServers: {},
+			projects: {}
+		};
 	}
 }
-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;
+/**
+* Read MCP servers for local scope (current project)
+* Stored in ~/.claude.json -> projects[cwd].mcpServers
+* Also searches parent directories since Claude CLI may store config at parent level
+*/
+async function read_local_mcp_servers() {
+	const { dirname } = await import("node:path");
+	const { homedir } = await import("node:os");
+	const full_config = await read_claude_config_full();
+	const home = homedir();
+	let current_dir = get_current_project_path();
+	while (current_dir && current_dir !== "/" && current_dir.length >= home.length) {
+		const project_config = full_config.projects?.[current_dir];
+		if (project_config?.mcpServers && Object.keys(project_config.mcpServers).length > 0) return Object.keys(project_config.mcpServers);
+		current_dir = dirname(current_dir);
+	}
+	return [];
 }
-//#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)
+* Read MCP servers from ~/.claude.json -> mcpServers (user scope)
 */
-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);
+async function read_user_mcp_servers() {
+	const config = await read_claude_config();
+	return Object.keys(config.mcpServers || {});
+}
+/**
+* Read MCP servers from .mcp.json files (project scope)
+* Searches current directory and parents for .mcp.json
+*/
+async function find_and_read_project_mcp_json() {
+	const { dirname } = await import("node:path");
+	let current_dir = get_current_project_path();
+	const home = (await import("node:os")).homedir();
+	while (current_dir && current_dir !== "/" && current_dir.length >= home.length) {
+		const mcp_path = `${current_dir}/.mcp.json`;
+		try {
+			await access(mcp_path);
+			const content = await readFile(mcp_path, "utf-8");
+			const servers = JSON.parse(content).mcpServers || {};
+			return Object.keys(servers);
+		} catch {}
+		current_dir = dirname(current_dir);
+	}
+	return [];
+}
+/**
+* Get currently enabled server names for a specific scope
+*/
+async function get_enabled_servers_for_scope(scope) {
+	switch (scope) {
+		case "local": return read_local_mcp_servers();
+		case "project": return find_and_read_project_mcp_json();
+		case "user": return read_user_mcp_servers();
+	}
 }
 //#endregion
 //#region src/core/settings.ts
@@ -215,8 +322,6 @@ async function get_all_hooks() {
 * 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-DmLbh89d.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();
@@ -344,43 +449,6 @@ async function cleanup_old_backups(prefix) {
 	} catch {}
 }
 //#endregion
-//#region src/utils/config-preview.ts
-function build_json_change_preview(input) {
-	const before = redact_value(input.before);
-	const after = redact_value(input.after);
-	return {
-		dryRun: true,
-		operation: input.operation,
-		client: input.client,
-		scope: input.scope,
-		location: input.location,
-		before,
-		after,
-		diff: create_json_diff(before, after)
-	};
-}
-function build_command_preview(input) {
-	return {
-		dryRun: true,
-		operation: input.operation,
-		client: input.client,
-		scope: input.scope,
-		location: input.location,
-		command: input.command.map((part) => redact_text(part))
-	};
-}
-function create_json_diff(before, after) {
-	const before_lines = JSON.stringify(before, null, 2).split("\n");
-	const after_lines = JSON.stringify(after, null, 2).split("\n");
-	if (before_lines.join("\n") === after_lines.join("\n")) return "";
-	return [
-		"--- before",
-		"+++ after",
-		...before_lines.map((line) => `- ${line}`),
-		...after_lines.map((line) => `+ ${line}`)
-	].join("\n");
-}
-//#endregion
 //#region src/core/client-config.ts
 const client_options_to_skip = new Set([
 	"name",
@@ -414,7 +482,7 @@ async function read_json_file(path) {
 	}
 }
 async function write_json_file(path, data) {
-	await safe_json_write(path, data, 2);
+	return safe_json_write(path, data, 2);
 }
 function parse_json_or_jsonc(content) {
 	try {
@@ -503,13 +571,13 @@ function remove_trailing_commas(content) {
 	}
 	return result;
 }
-function string_record(value) {
+function string_record$1(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) {
+function string_array$1(value) {
 	if (!Array.isArray(value)) return void 0;
 	const values = value.filter((item) => typeof item === "string");
 	return values.length > 0 ? values : void 0;
@@ -525,10 +593,10 @@ function normalize_mcp_server(name, 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_array = string_array$1(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 args = string_array$1(config.args) ?? command_array?.slice(1);
+	const env = string_record$1(config.env) ?? string_record$1(config.environment);
 	const disabled = typeof config.disabled === "boolean" ? config.disabled : typeof config.enabled === "boolean" ? !config.enabled : void 0;
 	return {
 		name,
@@ -537,7 +605,7 @@ function normalize_mcp_server(name, config) {
 		...args && args.length > 0 ? { args } : {},
 		...url ? { url } : {},
 		...env ? { env } : {},
-		...string_record(config.headers) ? { headers: string_record(config.headers) } : {},
+		...string_record$1(config.headers) ? { headers: string_record$1(config.headers) } : {},
 		...typeof config.description === "string" ? { description: config.description } : {},
 		...typeof disabled === "boolean" ? { disabled } : {},
 		...Object.keys(client_options).length > 0 ? { client_options } : {}
@@ -574,20 +642,26 @@ function portable_to_json(server, mode) {
 	if (typeof server.disabled === "boolean") set_server_enabled(result, !server.disabled, mode);
 	return result;
 }
-function create_json_adapter(options) {
-	async function read_data(location) {
-		return await read_json_file(location.path) ?? {};
-	}
-	function preview(location, operation, before, after) {
-		return build_json_change_preview({
-			operation,
-			client: options.id,
-			scope: location.scope,
-			location: location.path,
-			before,
-			after
-		});
+function opencode_to_json(server) {
+	const result = {};
+	const allowed_options = server.transport === "stdio" ? new Set(["cwd", "timeout"]) : new Set(["oauth", "timeout"]);
+	for (const [key, value] of Object.entries(server.client_options ?? {})) if (allowed_options.has(key)) result[key] = value;
+	if (server.transport === "stdio") {
+		result.type = "local";
+		if (server.command) result.command = [server.command, ...server.args ?? []];
+		if (server.env) result.environment = server.env;
+	} else {
+		result.type = "remote";
+		if (server.url) result.url = server.url;
+		if (server.headers) result.headers = server.headers;
 	}
+	if (typeof server.disabled === "boolean") result.enabled = !server.disabled;
+	return result;
+}
+function portable_server_map(servers, mode, serialize = portable_to_json) {
+	return Object.fromEntries(servers.map((server) => [server.name, serialize(server, mode)]));
+}
+function create_json_adapter(options) {
 	return {
 		id: options.id,
 		label: options.label,
@@ -602,66 +676,38 @@ function create_json_adapter(options) {
 			return read_server_map(await read_json_file(location.path), options.serverKey);
 		},
 		async writeEnabled(location, enabled_names) {
-			const data = await read_data(location);
+			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 previewEnabled(location, enabled_names) {
-			const before = await read_data(location);
-			const after = structuredClone(before);
-			const servers = get_server_record(after, 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");
-			after[options.serverKey] = servers;
-			return preview(location, "set-enabled", before, after);
+			return write_json_file(location.path, data);
 		},
 		async write_server(location, server) {
-			const data = await read_data(location);
+			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");
+			servers[server.name] = (options.serialize ?? portable_to_json)(server, options.disabledMode ?? "disabled");
 			data[options.serverKey] = servers;
-			await write_json_file(location.path, data);
-		},
-		async preview_write_server(location, server) {
-			const before = await read_data(location);
-			const after = structuredClone(before);
-			const servers = get_server_record(after, options.serverKey);
-			servers[server.name] = portable_to_json(server, options.disabledMode ?? "disabled");
-			after[options.serverKey] = servers;
-			return preview(location, "add-server", before, after);
+			return write_json_file(location.path, data);
 		},
 		async write_server_config(location, name, config) {
-			const data = await read_data(location);
+			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 preview_write_server_config(location, name, config) {
-			const before = await read_data(location);
-			const after = structuredClone(before);
-			const servers = get_server_record(after, options.serverKey);
-			servers[name] = config;
-			after[options.serverKey] = servers;
-			return preview(location, "add-json", before, after);
+			return write_json_file(location.path, data);
 		},
 		async remove_server(location, name) {
-			const data = await read_data(location);
+			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);
+			return write_json_file(location.path, data);
 		},
-		async preview_remove_server(location, name) {
-			const before = await read_data(location);
-			const after = structuredClone(before);
-			const servers = get_server_record(after, options.serverKey);
-			delete servers[name];
-			after[options.serverKey] = servers;
-			return preview(location, "remove-server", before, after);
+		async write_servers(location, servers) {
+			const data = await read_json_file(location.path) ?? {};
+			data[options.serverKey] = portable_server_map(servers, options.disabledMode ?? "disabled", options.serialize);
+			return write_json_file(location.path, data);
 		}
 	};
 }
@@ -704,6 +750,24 @@ const client_adapters = [
 			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");
+		},
+		async write_servers(location, servers) {
+			const data = await read_json_file(location.path) ?? (location.scope === "project" ? {} : { projects: {} });
+			const mcp_servers = portable_server_map(servers, "disabled");
+			if (location.scope === "project") {
+				data.mcpServers = mcp_servers;
+				return write_json_file(location.path, data);
+			}
+			if (location.scope === "user") {
+				data.mcpServers = mcp_servers;
+				return write_json_file(get_claude_config_path(), data);
+			}
+			const projects = data.projects && typeof data.projects === "object" && !Array.isArray(data.projects) ? data.projects : {};
+			const project_config = projects[process.cwd()] && typeof projects[process.cwd()] === "object" && !Array.isArray(projects[process.cwd()]) ? projects[process.cwd()] : {};
+			project_config.mcpServers = mcp_servers;
+			projects[process.cwd()] = project_config;
+			data.projects = projects;
+			return write_json_file(get_claude_config_path(), data);
 		}
 	},
 	create_json_adapter({
@@ -759,6 +823,7 @@ const client_adapters = [
 		label: "OpenCode",
 		serverKey: "mcp",
 		disabledMode: "enabled",
+		serialize: opencode_to_json,
 		locations: () => [{
 			scope: "project",
 			path: project_path("opencode.json"),
@@ -800,6 +865,17 @@ const client_adapters = [
 function get_client_adapter(id) {
 	return client_adapters.find((adapter) => adapter.id === id) ?? null;
 }
+function mutation_result(adapter, location, operation, servers, write_result, enabledCount) {
+	return {
+		operation,
+		client: adapter.id,
+		scope: location.scope,
+		location: write_result.path,
+		servers,
+		...enabledCount !== void 0 ? { enabledCount } : {},
+		...write_result.backup_path ? { backup_path: write_result.backup_path } : {}
+	};
+}
 function resolve_client_location(adapter, scope, path) {
 	let locations = adapter.locations();
 	if (path) locations = locations.filter((location) => location.path === path);
@@ -810,43 +886,31 @@ function resolve_client_location(adapter, scope, path) {
 }
 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 preview_add_client_server(adapter, location, server) {
-	if (!adapter.preview_write_server) throw new Error(`${adapter.label} support cannot preview server additions yet.`);
-	return adapter.preview_write_server(location, server);
+	const write_result = await adapter.write_server(location, server);
+	return mutation_result(adapter, location, "add", [server.name], write_result);
 }
 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 preview_add_client_server_config(adapter, location, name, config) {
-	if (!adapter.preview_write_server_config) throw new Error(`${adapter.label} support cannot preview server additions yet.`);
-	return adapter.preview_write_server_config(location, name, config);
+	const write_result = await adapter.write_server_config(location, name, config);
+	return mutation_result(adapter, location, "add", [name], write_result);
 }
 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 preview_remove_client_server(adapter, location, server_name) {
-	if (!adapter.preview_remove_server) throw new Error(`${adapter.label} support cannot preview server removals yet.`);
-	return adapter.preview_remove_server(location, server_name);
+	const write_result = await adapter.remove_server(location, server_name);
+	return mutation_result(adapter, location, "remove", [server_name], write_result);
 }
-function assert_enabled_server_names(location, servers, enabled_names) {
+async function set_client_enabled_servers(adapter, location, enabled_names) {
+	if (!adapter.writeEnabled) throw new Error(`${adapter.label} support is read-only.`);
+	const servers = await adapter.readLocation(location);
 	const known_names = new Set(servers.map((server) => server.name));
 	const unknown_names = enabled_names.filter((name) => !known_names.has(name));
 	if (unknown_names.length > 0) throw new Error(`Server '${unknown_names[0]}' not found at ${location.path}.`);
+	return mutation_result(adapter, location, "set-enabled", enabled_names, await adapter.writeEnabled(location, enabled_names), enabled_names.length);
 }
-async function set_client_enabled_servers(adapter, location, enabled_names) {
-	if (!adapter.writeEnabled) throw new Error(`${adapter.label} support is read-only.`);
-	assert_enabled_server_names(location, await adapter.readLocation(location), enabled_names);
-	await adapter.writeEnabled(location, enabled_names);
-	return enabled_names.length;
-}
-async function preview_set_client_enabled_servers(adapter, location, enabled_names) {
-	if (!adapter.previewEnabled) throw new Error(`${adapter.label} support cannot preview toggles yet.`);
-	assert_enabled_server_names(location, await adapter.readLocation(location), enabled_names);
-	return adapter.previewEnabled(location, enabled_names);
+async function replace_client_servers(adapter, location, servers) {
+	if (!adapter.write_servers) throw new Error(`${adapter.label} support cannot replace server profiles yet.`);
+	const write_result = await adapter.write_servers(location, servers);
+	return mutation_result(adapter, location, "replace", servers.map((server) => server.name), write_result, servers.filter((server) => server.disabled !== true).length);
 }
 async function set_client_server_enabled(adapter, location, server_name, enabled) {
 	const servers = await adapter.readLocation(location);
@@ -855,7 +919,11 @@ async function set_client_server_enabled(adapter, location, server_name, enabled
 	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);
-	return set_client_enabled_servers(adapter, location, [...enabled_names]);
+	return {
+		...await set_client_enabled_servers(adapter, location, [...enabled_names]),
+		operation: enabled ? "enable" : "disable",
+		servers: [server_name]
+	};
 }
 async function list_client_locations() {
 	return await Promise.all(client_adapters.flatMap((adapter) => adapter.locations().map(async (location) => ({
@@ -867,16 +935,56 @@ async function list_client_locations() {
 }
 //#endregion
 //#region src/core/registry.ts
+function is_object$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function portable_to_mcp_server(server) {
+	return validate_mcp_server({
+		name: server.name,
+		...server.transport !== "stdio" ? { type: server.transport } : {},
+		...server.command ? { command: server.command } : {},
+		...server.args ? { args: server.args } : {},
+		...server.url ? { url: server.url } : {},
+		...server.env ? { env: server.env } : {},
+		...server.headers ? { headers: server.headers } : {},
+		...server.description ? { description: server.description } : {}
+	});
+}
+function mcp_server_to_portable(server) {
+	const { name, ...config } = server;
+	return normalize_mcp_server(name, config);
+}
+function parse_portable_registry(data) {
+	if (!is_object$1(data) || !Array.isArray(data.servers)) throw new Error("Invalid server registry: expected servers array");
+	if (data.version === 3) return validate_server_registry(data);
+	return validate_server_registry({
+		version: 3,
+		servers: data.servers.map((server) => {
+			if (!is_object$1(server)) throw new Error("Invalid server registry entry");
+			if (typeof server.transport === "string") {
+				if (typeof server.name !== "string") throw new Error("Invalid server registry entry");
+				return normalize_mcp_server(server.name, server);
+			}
+			return mcp_server_to_portable(validate_mcp_server(server));
+		})
+	});
+}
 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));
+		const parsed_registry = JSON.parse(registry_content);
+		const registry = parse_portable_registry(parsed_registry);
+		if (parsed_registry.version !== 3) await write_server_registry(registry);
+		return registry;
 	} catch (error) {
 		if (error instanceof Error && "code" in error && error.code === "ENOENT") {
 			await ensure_directory_exists(get_mcpick_dir());
-			const default_registry = { servers: [] };
+			const default_registry = {
+				version: 3,
+				servers: []
+			};
 			await write_server_registry(default_registry);
 			return default_registry;
 		}
@@ -890,13 +998,13 @@ async function write_server_registry(registry) {
 }
 async function add_server_to_registry(server) {
 	const registry = await read_server_registry();
+	const portable = mcp_server_to_portable(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);
+	if (existing_index >= 0) registry.servers[existing_index] = portable;
+	else registry.servers.push(portable);
 	await write_server_registry(registry);
 }
 async function get_all_available_servers() {
-	const { get_enabled_servers, read_claude_config } = await import("./config-DE58Fik_.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]));
@@ -907,25 +1015,16 @@ async function get_all_available_servers() {
 		known_names.add(name);
 		const config_server = config_by_name.get(name);
 		if (config_server) {
-			registry.servers[i] = config_server;
+			registry.servers[i] = mcp_server_to_portable(config_server);
 			registry_updated = true;
 		}
 	}
 	for (const server of config_servers) if (!known_names.has(server.name)) {
-		registry.servers.push(server);
+		registry.servers.push(mcp_server_to_portable(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);
+	return registry.servers.map(portable_to_mcp_server);
 }
 function parse_backups(prefix, pattern) {
 	return async () => {
@@ -951,6 +1050,195 @@ function parse_backups(prefix, pattern) {
 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/redact.ts
+const SENSITIVE_KEY_PATTERN = /(api[_-]?key|token|secret|password|passwd|authorization|client[_-]?secret|access[_-]?token|refresh[_-]?token|private[_-]?key)/i;
+const ANSI_PATTERN = new RegExp(String.raw`[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))`, "g");
+const TEXT_REDACTIONS = [
+	[/AKIA[A-Z0-9]{16}/g, "[REDACTED:AWS_ACCESS_KEY]"],
+	[/\bAIza[0-9A-Za-z_-]{35}\b/g, "[REDACTED:GOOGLE_API_KEY]"],
+	[/\bya29\.[0-9A-Za-z_-]{20,}\b/g, "[REDACTED:GOOGLE_OAUTH_TOKEN]"],
+	[/\bsk-(?:live|test)?_?[a-zA-Z0-9._-]{20,}\b/g, "[REDACTED:API_KEY]"],
+	[/\b(?:pk|rk)_(?:live|test)_[a-zA-Z0-9]{20,}\b/g, "[REDACTED:API_KEY]"],
+	[/\bBearer\s+[a-zA-Z0-9._~+/-]+=*/gi, "Bearer [REDACTED]"],
+	[/(:\/\/[^:\s/@]+):([^@\s]+)@/g, "$1:[REDACTED]@"],
+	[/([?&][^=&#\s]*(?:token|key|secret|password|passwd)[^=&#\s]*=)[^&#\s]*/gi, "$1[REDACTED]"],
+	[/\b(Authorization\s*:\s*)(?:Bearer\s+)?[^\s,}\]]+/gi, "$1[REDACTED]"],
+	[/\b((?:api[_-]?key|token|secret|password|passwd|client[_-]?secret|access[_-]?token|refresh[_-]?token)\s*[:=]\s*["']?)[^"'\s,}\]]{8,}/gi, "$1[REDACTED]"],
+	[/\b((?:SecretAccessKey|aws_secret_access_key)\s*[:=]\s*)[A-Za-z0-9/+=]{20,}/gi, "$1[REDACTED]"],
+	[/-----BEGIN\s+[\w\s]*PRIVATE\s+KEY-----[\s\S]*?-----END\s+[\w\s]*PRIVATE\s+KEY-----/g, "[REDACTED:PRIVATE_KEY]"]
+];
+/**
+* Redact known secret patterns from arbitrary text. This is a safety net for
+* CLI stdout/stderr; structured MCP config redaction should happen first.
+*/
+function redact_text(text) {
+	let redacted = text;
+	for (const [pattern, replacement] of TEXT_REDACTIONS) redacted = redacted.replace(pattern, replacement);
+	return redacted.replace(ANSI_PATTERN, "");
+}
+function redact_value(value, key = "") {
+	if (typeof value === "string") return SENSITIVE_KEY_PATTERN.test(key) ? "***" : redact_text(value);
+	if (Array.isArray(value)) return value.map((item) => redact_value(item));
+	if (value && typeof value === "object") {
+		const redacted = {};
+		for (const [child_key, child_value] of Object.entries(value)) redacted[child_key] = child_key === "env" || child_key === "headers" ? redact_unknown_record(child_value) : SENSITIVE_KEY_PATTERN.test(child_key) ? "***" : redact_value(child_value, child_key);
+		return redacted;
+	}
+	return value;
+}
+/**
+* Redact sensitive values from a server config.
+* Shows env/header key names but replaces values with "***".
+*/
+function redact_server_base(server) {
+	const redacted = redact_value(server);
+	if ("env" in redacted && redacted.env) redacted.env = redact_record(redacted.env);
+	if ("headers" in redacted && redacted.headers) redacted.headers = redact_record(redacted.headers);
+	if ("url" in redacted && redacted.url) redacted.url = redact_url(redacted.url);
+	return redacted;
+}
+function redact_server(server) {
+	return {
+		...redact_server_base(server),
+		name: server.name
+	};
+}
+function redact_portable_server(server) {
+	return {
+		...redact_value(server),
+		...server.env ? { env: redact_record(server.env) } : {},
+		...server.headers ? { headers: redact_record(server.headers) } : {},
+		...server.url ? { url: redact_url(server.url) } : {}
+	};
+}
+function redact_url(url) {
+	try {
+		const parsed = new URL(url);
+		parsed.username = "";
+		parsed.password = "";
+		parsed.search = parsed.search ? "?redacted" : "";
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return redact_text(url.replace(/[?#].*$/, "?redacted"));
+	}
+}
+function redact_unknown_record(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return redact_value(value);
+	const redacted = {};
+	for (const key of Object.keys(value)) redacted[key] = "***";
+	return redacted;
+}
+function redact_record(record) {
+	const redacted = {};
+	for (const key of Object.keys(record)) redacted[key] = "***";
+	return redacted;
+}
+//#endregion
+//#region src/commands/edit-config.ts
+async function edit_config() {
+	try {
+		const sorted_adapters = [...client_adapters].sort((a, b) => b.label.localeCompare(a.label));
+		const client_id = await select({
+			message: "Which MCP client do you want to edit?",
+			options: sorted_adapters.map((adapter) => ({
+				value: adapter.id,
+				label: adapter.label
+			})),
+			initialValue: sorted_adapters[0]?.id
+		});
+		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(adapter);
+			return;
+		}
+		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;
+	const mutation = await set_client_enabled_servers(adapter, location, selected_names);
+	note(`Configuration updated!\nClient: ${adapter.label}\nConfig: ${mutation.location}\n` + (mutation.backup_path ? `Backup: ${mutation.backup_path}\n` : "") + `Enabled 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(adapter) {
+	const location = await select_config_location(adapter);
+	if (!location) return;
+	const registry_servers = (await get_all_available_servers()).map((server) => {
+		const { name, ...config } = server;
+		return normalize_mcp_server(name, config);
+	});
+	const current_servers = await adapter.readLocation(location);
+	const servers_by_name = /* @__PURE__ */ new Map();
+	for (const server of registry_servers) servers_by_name.set(server.name, server);
+	for (const server of current_servers) if (!servers_by_name.has(server.name)) servers_by_name.set(server.name, server);
+	const all_servers = [...servers_by_name.values()];
+	if (all_servers.length === 0) {
+		note("No MCP servers found in this Claude Code config or registry. Add servers with the CLI first.");
+		return;
+	}
+	const currently_enabled = current_servers.filter((server) => server.disabled !== true).map((server) => server.name);
+	const selected_server_names = await multiselect({
+		message: `Select MCP servers for ${location.description}:`,
+		options: all_servers.map((server) => ({
+			value: server.name,
+			label: server.name,
+			hint: server_hint(server)
+		})),
+		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 mutation = await replace_client_servers(adapter, location, selected_servers);
+	note(`Configuration updated!\nClient: ${adapter.label}\nConfig: ${mutation.location}\n` + (mutation.backup_path ? `Backup: ${mutation.backup_path}\n` : "") + `Enabled servers: ${selected_servers.length}`);
+}
+//#endregion
 //#region src/utils/claude-cli.ts
 const exec_file_async$1 = promisify(execFile);
 /**
@@ -1381,16 +1669,6 @@ async function marketplace_list_via_cli() {
 	}
 }
 /**
-* 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) {
@@ -1443,23 +1721,20 @@ async function mcp_get_via_cli(name) {
 /**
 * Add an MCP server from raw JSON via Claude CLI
 */
-function build_add_json_args(name, json, scope = "local") {
-	return [
-		"mcp",
-		"add-json",
-		name,
-		json,
-		"--scope",
-		scope
-	];
-}
 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(build_add_json_args(name, json, scope));
+		await run_claude([
+			"mcp",
+			"add-json",
+			name,
+			json,
+			"--scope",
+			scope
+		]);
 		return { success: true };
 	} catch (error) {
 		return {
@@ -1486,174 +1761,6 @@ async function mcp_reset_project_choices_via_cli() {
 		};
 	}
 }
-/**
-* 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 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 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;
-		}
-		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;
-	const preview = await preview_set_client_enabled_servers(adapter, location, selected_names);
-	if (preview.diff) {
-		note(preview.diff, "Preview");
-		const should_apply = await confirm({
-			message: "Apply these changes?",
-			initialValue: true
-		});
-		if (typeof should_apply === "symbol" || !should_apply) return;
-	}
-	await set_client_enabled_servers(adapter, 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 || ""
-		})),
-		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 add ${name}: ${result.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
 //#region src/commands/edit-plugins.ts
 async function handle_toggle() {
@@ -1858,6 +1965,7 @@ async function handle_clear() {
 	if (isCancel(should_clear) || !should_clear) return;
 	const result = await clear_plugin_caches(selected);
 	for (const key of result.cleared) log.success(`Cleared: ${key}`);
+	if (result.redisabledHooks?.success) log.success(`Re-disabled restored hooks: ${result.redisabledHooks.success}`);
 	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");
 }
@@ -1932,171 +2040,6 @@ 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)";
@@ -2638,56 +2581,144 @@ function format_time_ago(date) {
 }
 //#endregion
 //#region src/core/profile.ts
-async function load_profile(name) {
+function is_object(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function string_record(value) {
+	if (!is_object(value)) return void 0;
+	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 boolean_record(value) {
+	if (!is_object(value)) return void 0;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) if (typeof item === "boolean") result[key] = item;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function string_array(value) {
+	if (!Array.isArray(value)) return void 0;
+	const result = value.filter((item) => typeof item === "string");
+	return result.length > 0 ? result : void 0;
+}
+function parse_portable_server(value) {
+	if (!is_object(value) || typeof value.name !== "string") return null;
+	const transport = value.transport === "http" || value.transport === "sse" || value.transport === "stdio" ? value.transport : "stdio";
+	const client_options = is_object(value.client_options) ? value.client_options : void 0;
+	return {
+		name: value.name,
+		transport,
+		...typeof value.command === "string" ? { command: value.command } : {},
+		...string_array(value.args) ? { args: string_array(value.args) } : {},
+		...typeof value.url === "string" ? { url: value.url } : {},
+		...string_record(value.env) ? { env: string_record(value.env) } : {},
+		...string_record(value.headers) ? { headers: string_record(value.headers) } : {},
+		...typeof value.description === "string" ? { description: value.description } : {},
+		...typeof value.disabled === "boolean" ? { disabled: value.disabled } : {},
+		...client_options ? { client_options } : {}
+	};
+}
+async function read_profile_json(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
-		};
+		return JSON.parse(await readFile(profile_path, "utf-8"));
 	} catch (error) {
 		if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new Error(`Profile '${name}' not found at ${profile_path}`);
 		throw error;
 	}
 }
+function legacy_profile_to_claude_config(parsed) {
+	if (parsed.mcpServers) return validate_claude_config(parsed);
+	if (!parsed.enabledPlugins && !parsed.plugins) return validate_claude_config({ mcpServers: parsed });
+	return validate_claude_config({ mcpServers: parsed.mcpServers || {} });
+}
+function claude_config_to_portable(config) {
+	return Object.entries(config.mcpServers || {}).map(([name, server]) => normalize_mcp_server(name, server));
+}
+function portable_to_claude_config(servers) {
+	const mcpServers = {};
+	for (const server of servers) {
+		const config = {};
+		if (server.transport !== "stdio") config.type = server.transport;
+		if (server.command) config.command = server.command;
+		if (server.args) config.args = server.args;
+		if (server.url) config.url = server.url;
+		if (server.env) config.env = server.env;
+		if (server.headers) config.headers = server.headers;
+		if (server.description) config.description = server.description;
+		mcpServers[server.name] = config;
+	}
+	return validate_claude_config({ mcpServers });
+}
+async function load_portable_profile(name) {
+	const parsed = await read_profile_json(name);
+	const plugins = boolean_record(parsed.plugins) ?? boolean_record(parsed.enabledPlugins);
+	if (Array.isArray(parsed.servers)) return {
+		version: 2,
+		servers: parsed.servers.map(parse_portable_server).filter((server) => !!server),
+		...plugins ? { plugins } : {},
+		...is_object(parsed.client_overrides) ? { client_overrides: parsed.client_overrides } : {}
+	};
+	return {
+		version: 2,
+		servers: claude_config_to_portable(legacy_profile_to_claude_config(parsed)),
+		...plugins ? { plugins } : {}
+	};
+}
 async function apply_profile_to_claude(name) {
-	const profile = await load_profile(name);
-	await write_claude_config(profile.config);
-	const serverCount = Object.keys(profile.config.mcpServers || {}).length;
+	const profile = await load_portable_profile(name);
+	await write_claude_config(portable_to_claude_config(profile.servers));
 	let pluginCount = 0;
-	if (profile.enabledPlugins) {
-		await write_claude_settings({ enabledPlugins: profile.enabledPlugins });
-		pluginCount = Object.keys(profile.enabledPlugins).length;
+	if (profile.plugins) {
+		await write_claude_settings({ enabledPlugins: profile.plugins });
+		pluginCount = Object.keys(profile.plugins).length;
 	}
 	return {
 		profile: name,
-		serverCount,
-		pluginCount
+		serverCount: profile.servers.length,
+		pluginCount,
+		client: "claude-code",
+		scope: "user"
+	};
+}
+async function apply_profile_to_client(input) {
+	const adapter = get_client_adapter(input.client);
+	if (!adapter) throw new Error(`Invalid client: ${input.client}`);
+	const location = resolve_client_location(adapter, input.scope, input.location);
+	const profile = await load_portable_profile(input.name);
+	const mutation = await replace_client_servers(adapter, location, profile.servers);
+	let pluginCount = 0;
+	if (adapter.id === "claude-code" && profile.plugins) {
+		await write_claude_settings({ enabledPlugins: profile.plugins });
+		pluginCount = Object.keys(profile.plugins).length;
+	}
+	return {
+		profile: input.name,
+		serverCount: profile.servers.length,
+		pluginCount,
+		client: adapter.id,
+		scope: location.scope,
+		location: mutation.location,
+		...mutation.backup_path ? { backup_path: mutation.backup_path } : {}
 	};
 }
 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 files = (await readdir(profiles_dir)).filter((file) => file.endsWith(".json"));
 		const profiles = [];
-		for (const file of json_files) try {
+		for (const file of files) try {
+			const name = file.replace(/\.json$/, "");
 			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 || {};
+			const parsed = JSON.parse(await readFile(path, "utf-8"));
+			const servers = Array.isArray(parsed.servers) ? parsed.servers : parsed.mcpServers || parsed;
+			const plugins = parsed.plugins || parsed.enabledPlugins || {};
 			profiles.push({
-				name: file.replace(".json", ""),
+				name,
 				path,
-				serverCount: Object.keys(servers).length,
+				serverCount: Array.isArray(servers) ? servers.length : Object.keys(servers).length,
 				pluginCount: Object.keys(plugins).length
 			});
 		} catch {}
@@ -2696,21 +2727,43 @@ async function list_profiles() {
 		return [];
 	}
 }
+async function save_portable_profile(name, servers, plugins) {
+	await ensure_directory_exists(get_profiles_dir());
+	const profile_data = {
+		version: 2,
+		servers,
+		...plugins && Object.keys(plugins).length > 0 ? { plugins } : {}
+	};
+	await safe_json_write(get_profile_path(name), profile_data, 2);
+}
 async function save_profile(name) {
 	const config = await read_claude_config();
 	const settings = await read_claude_settings();
-	const servers = config.mcpServers || {};
+	const servers = get_enabled_servers(config).map((server) => normalize_mcp_server(server.name, server));
 	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);
+	if (servers.length === 0 && Object.keys(plugins).length === 0) throw new Error("No MCP servers or plugins configured to save");
+	await save_portable_profile(name, servers, plugins);
 	return {
-		serverCount: server_count,
-		pluginCount: plugin_count
+		serverCount: servers.length,
+		pluginCount: Object.keys(plugins).length
+	};
+}
+async function save_profile_for_client(input) {
+	const adapter = get_client_adapter(input.client);
+	if (!adapter) throw new Error(`Invalid client: ${input.client}`);
+	const location = resolve_client_location(adapter, input.scope, input.location);
+	const servers = await adapter.readLocation(location);
+	let plugins;
+	if (adapter.id === "claude-code") plugins = (await read_claude_settings()).enabledPlugins;
+	if (servers.length === 0 && !plugins) throw new Error("No MCP servers or plugins configured to save");
+	await save_portable_profile(input.name, servers, plugins);
+	return {
+		profile: input.name,
+		serverCount: servers.length,
+		pluginCount: Object.keys(plugins || {}).length,
+		client: adapter.id,
+		scope: location.scope,
+		location: location.path
 	};
 }
 async function save_current_claude_profile(name) {
@@ -2718,7 +2771,9 @@ async function save_current_claude_profile(name) {
 	return {
 		profile: name,
 		serverCount: counts.serverCount,
-		pluginCount: counts.pluginCount
+		pluginCount: counts.pluginCount,
+		client: "claude-code",
+		scope: "user"
 	};
 }
 //#endregion
@@ -2772,7 +2827,37 @@ async function create_claude_profile(name) {
 		process.exit(1);
 	}
 }
-async function handle_load_claude_profile() {
+function sorted_client_adapters() {
+	return [...client_adapters].sort((a, b) => b.label.localeCompare(a.label));
+}
+async function select_client_adapter() {
+	const adapters = sorted_client_adapters();
+	const client_id = await select({
+		message: "Which MCP client?",
+		options: adapters.map((adapter) => ({
+			value: adapter.id,
+			label: adapter.label
+		})),
+		initialValue: adapters[0]?.id
+	});
+	if (isCancel(client_id)) return null;
+	return client_adapters.find((adapter) => adapter.id === client_id) ?? null;
+}
+async function select_client_location(adapter) {
+	const locations = adapter.locations();
+	if (locations.length === 1) return locations[0];
+	const location_path = await select({
+		message: `Which ${adapter.label} configuration?`,
+		options: locations.map((location) => ({
+			value: location.path,
+			label: `${location.scope} — ${location.description}`,
+			hint: location.path
+		}))
+	});
+	if (isCancel(location_path)) return null;
+	return locations.find((location) => location.path === location_path) ?? null;
+}
+async function handle_load_profile() {
 	const profiles = await list_profiles();
 	if (profiles.length === 0) {
 		log.warn("No profiles found");
@@ -2792,12 +2877,23 @@ async function handle_load_claude_profile() {
 		})
 	});
 	if (isCancel(profile_name)) return;
-	const result = await apply_profile_to_claude(profile_name);
+	const adapter = await select_client_adapter();
+	if (!adapter) return;
+	const location = await select_client_location(adapter);
+	if (!location) return;
+	const result = await apply_profile_to_client({
+		name: profile_name,
+		client: adapter.id,
+		scope: location.scope,
+		location: location.path
+	});
 	const parts = [`${result.serverCount} servers`];
-	if (result.pluginCount > 0) parts.push(`${result.pluginCount} plugins`);
-	log.success(`Profile '${result.profile}' applied (${parts.join(", ")})`);
+	if (result.pluginCount > 0) parts.push(`${result.pluginCount} Claude plugins`);
+	log.success(`Profile '${result.profile}' applied to ${adapter.label}:${location.scope} (${parts.join(", ")})`);
+	if (result.location) log.info(`Config: ${result.location}`);
+	if (result.backup_path) log.info(`Backup: ${result.backup_path}`);
 }
-async function handle_save_claude_profile() {
+async function handle_save_profile() {
 	const name = await text({
 		message: "Profile name:",
 		placeholder: "e.g. database, web-dev, minimal",
@@ -2807,19 +2903,30 @@ async function handle_save_claude_profile() {
 		}
 	});
 	if (isCancel(name)) return;
-	const result = await save_current_claude_profile(name);
+	const adapter = await select_client_adapter();
+	if (!adapter) return;
+	const location = await select_client_location(adapter);
+	if (!location) return;
+	const result = await save_profile_for_client({
+		name,
+		client: adapter.id,
+		scope: location.scope,
+		location: location.path
+	});
 	const parts = [`${result.serverCount} servers`];
-	if (result.pluginCount > 0) parts.push(`${result.pluginCount} plugins`);
-	log.success(`Profile '${result.profile}' saved (${parts.join(", ")})`);
+	if (result.pluginCount > 0) parts.push(`${result.pluginCount} Claude plugins`);
+	log.success(`Profile '${result.profile}' saved from ${adapter.label}:${location.scope} (${parts.join(", ")})`);
+	if (result.location) log.info(`Config: ${result.location}`);
 }
 async function handle_client_tools() {
+	const adapters = sorted_client_adapters();
 	const client_id = await select({
 		message: "Which client?",
-		options: client_adapters.map((adapter) => ({
+		options: adapters.map((adapter) => ({
 			value: adapter.id,
 			label: adapter.label
 		})),
-		initialValue: "claude-code"
+		initialValue: adapters[0]?.id
 	});
 	if (isCancel(client_id)) return;
 	if (client_id !== "claude-code") {
@@ -2908,13 +3015,13 @@ async function main() {
 				},
 				{
 					value: "load-profile",
-					label: "Load Claude Code profile",
-					hint: "Apply a saved Claude Code profile"
+					label: "Load profile",
+					hint: "Apply a saved profile to a selected client"
 				},
 				{
 					value: "save-profile",
-					label: "Save Claude Code profile",
-					hint: "Save current Claude Code config as profile"
+					label: "Save profile",
+					hint: "Save selected client config as a portable profile"
 				},
 				{
 					value: "backup",
@@ -2954,10 +3061,10 @@ async function main() {
 				await restore_config();
 				break;
 			case "load-profile":
-				await handle_load_claude_profile();
+				await handle_load_profile();
 				break;
 			case "save-profile":
-				await handle_save_claude_profile();
+				await handle_save_profile();
 				break;
 			case "exit":
 				outro("Goodbye!");
@@ -3008,12 +3115,12 @@ const SUBCOMMANDS = new Set([
 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-CZOlaqoZ.js").then((m) => m.run());
+	import("./cli-Dfein2li.js").then((m) => m.run());
 } else main().catch((error) => {
 	console.error("Fatal error:", error);
 	process.exit(1);
 });
 //#endregion
-export { write_claude_settings as $, list_backups as A, preview_remove_client_server as B, mcp_reset_project_choices_via_cli as C, validate_plugin_via_cli as D, update_plugin_via_cli as E, add_client_server_config as F, build_command_preview as G, remove_client_server as H, get_client_adapter as I, build_enabled_plugins as J, build_json_change_preview as K, list_client_locations as L, read_server_registry as M, write_server_registry as N, add_server_to_registry as O, add_client_server as P, remove_hook as Q, preview_add_client_server as R, mcp_get_via_cli as S, uninstall_plugin_via_cli as T, resolve_client_location as U, preview_set_client_enabled_servers as V, set_client_server_enabled as W, get_all_plugins as X, get_all_hooks as Y, read_claude_settings as Z, marketplace_add_via_cli as _, run_skills_cli as a, marketplace_update_via_cli as b, disable_plugin_hook as c, redisable_restored_hooks as d, atomic_json_write as et, add_mcp_via_cli as f, install_plugin_via_cli as g, build_remove_args as h, save_current_claude_profile as i, list_plugin_backups as j, get_all_available_servers as k, enable_plugin_hook as l, build_add_json_args as m, list_profiles as n, restore_config_backup as nt, split_cli_list as o, build_add_args as p, add_hook as q, load_profile as r, check_restored_hooks as s, apply_profile_to_claude as t, list_config_backups as tt, read_disabled_hooks as u, marketplace_list_via_cli as v, remove_mcp_via_cli as w, mcp_add_json_via_cli as x, marketplace_remove_via_cli as y, preview_add_client_server_config as z };
+export { validate_mcp_server as $, list_plugin_backups as A, add_hook as B, redact_server_base as C, add_server_to_registry as D, redact_value as E, get_client_adapter as F, remove_hook as G, get_all_hooks as H, list_client_locations as I, find_server_in_scope as J, write_claude_settings as K, remove_client_server as L, write_server_registry as M, add_client_server as N, get_all_available_servers as O, add_client_server_config as P, validate_claude_config as Q, resolve_client_location as R, redact_server as S, redact_url as T, get_all_plugins as U, build_enabled_plugins as V, read_claude_settings as W, read_claude_config as X, get_enabled_servers_for_scope as Y, write_claude_config as Z, remove_mcp_via_cli as _, save_profile_for_client as a, validate_plugin_via_cli as b, add_mcp_via_cli as c, marketplace_list_via_cli as d, marketplace_remove_via_cli as f, mcp_reset_project_choices_via_cli as g, mcp_get_via_cli as h, save_current_claude_profile as i, read_server_registry as j, list_backups as k, install_plugin_via_cli as l, mcp_add_json_via_cli as m, apply_profile_to_client as n, run_skills_cli as o, marketplace_update_via_cli as p, detect_server_scope as q, list_profiles as r, split_cli_list as s, apply_profile_to_claude as t, marketplace_add_via_cli as u, uninstall_plugin_via_cli as v, redact_text as w, redact_portable_server as x, update_plugin_via_cli as y, set_client_server_enabled as z };
 
 //# sourceMappingURL=index.js.map