mcpick 0.0.25 → 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 { n as validate_mcp_server, r as validate_server_registry, t as validate_claude_config } from "./validation-CfPAjPJ5.js";
-import { i as get_enabled_servers, o as read_claude_config, s as write_claude_config } from "./config-Bzh374VP.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-Dw1I2YuO.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-Dw1I2YuO.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();
@@ -537,8 +642,24 @@ function portable_to_json(server, mode) {
 	if (typeof server.disabled === "boolean") set_server_enabled(result, !server.disabled, mode);
 	return result;
 }
-function portable_server_map(servers, mode) {
-	return Object.fromEntries(servers.map((server) => [server.name, portable_to_json(server, mode)]));
+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 {
@@ -565,7 +686,7 @@ function create_json_adapter(options) {
 		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");
+			servers[server.name] = (options.serialize ?? portable_to_json)(server, options.disabledMode ?? "disabled");
 			data[options.serverKey] = servers;
 			return write_json_file(location.path, data);
 		},
@@ -585,7 +706,7 @@ function create_json_adapter(options) {
 		},
 		async write_servers(location, servers) {
 			const data = await read_json_file(location.path) ?? {};
-			data[options.serverKey] = portable_server_map(servers, options.disabledMode ?? "disabled");
+			data[options.serverKey] = portable_server_map(servers, options.disabledMode ?? "disabled", options.serialize);
 			return write_json_file(location.path, data);
 		}
 	};
@@ -702,6 +823,7 @@ const client_adapters = [
 		label: "OpenCode",
 		serverKey: "mcp",
 		disabledMode: "enabled",
+		serialize: opencode_to_json,
 		locations: () => [{
 			scope: "project",
 			path: project_path("opencode.json"),
@@ -883,7 +1005,6 @@ async function add_server_to_registry(server) {
 	await write_server_registry(registry);
 }
 async function get_all_available_servers() {
-	const { get_enabled_servers, read_claude_config } = await import("./config-Bzh374VP.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]));
@@ -929,6 +1050,91 @@ 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 {
@@ -1719,171 +1925,6 @@ async function edit_plugins() {
 	}
 }
 //#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-cache.ts
 function format_status_line(p) {
 	const markers = [];
@@ -3074,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-sOeHH4CK.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 { read_server_registry as A, build_enabled_plugins as B, uninstall_plugin_via_cli as C, get_all_available_servers as D, add_server_to_registry as E, list_client_locations as F, write_claude_settings as G, get_all_plugins as H, remove_client_server as I, restore_config_backup as J, atomic_json_write as K, resolve_client_location as L, add_client_server as M, add_client_server_config as N, list_backups as O, get_client_adapter as P, set_client_server_enabled as R, remove_mcp_via_cli as S, validate_plugin_via_cli as T, read_claude_settings as U, get_all_hooks as V, remove_hook as W, marketplace_remove_via_cli as _, save_profile_for_client as a, mcp_get_via_cli as b, check_restored_hooks as c, read_disabled_hooks as d, redisable_restored_hooks as f, marketplace_list_via_cli as g, marketplace_add_via_cli as h, save_current_claude_profile as i, write_server_registry as j, list_plugin_backups as k, disable_plugin_hook as l, install_plugin_via_cli as m, apply_profile_to_client as n, run_skills_cli as o, add_mcp_via_cli as p, list_config_backups as q, list_profiles as r, split_cli_list as s, apply_profile_to_claude as t, enable_plugin_hook as u, marketplace_update_via_cli as v, update_plugin_via_cli as w, mcp_reset_project_choices_via_cli as x, mcp_add_json_via_cli as y, add_hook 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