mcpick 0.0.18 → 0.0.19

package/dist/config-DijVdEFn.js

@@ -0,0 +1,176 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { i as get_claude_config_path, o as get_current_project_path, v as get_project_mcp_json_path } from "./paths-BPISiJi4.js";
+import { t as validate_claude_config } from "./validation-xMlbgGCF.js";
+import { t as atomic_json_write } from "./atomic-write-BqEykHp9.js";
+import { access, readFile } from "node:fs/promises";
+//#region src/core/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	create_config_from_servers: () => create_config_from_servers,
+	detect_server_scope: () => detect_server_scope,
+	find_server_in_scope: () => find_server_in_scope,
+	get_enabled_servers: () => get_enabled_servers,
+	get_enabled_servers_for_scope: () => get_enabled_servers_for_scope,
+	read_claude_config: () => read_claude_config,
+	write_claude_config: () => write_claude_config
+});
+async function read_claude_config() {
+	const config_path = get_claude_config_path();
+	try {
+		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;
+	}
+}
+async function write_claude_config(config) {
+	await atomic_json_write(get_claude_config_path(), (existing) => {
+		existing.mcpServers = config.mcpServers;
+		return existing;
+	});
+}
+function get_enabled_servers(config) {
+	if (!config.mcpServers) return [];
+	return Object.entries(config.mcpServers).map(([name, server]) => ({
+		...server,
+		name
+	}));
+}
+function create_config_from_servers(selected_servers) {
+	const mcp_servers = {};
+	selected_servers.forEach((server) => {
+		const { name, ...server_config } = server;
+		mcp_servers[name] = server_config;
+	});
+	return { mcpServers: mcp_servers };
+}
+/**
+* Find a server's full config in a specific scope.
+*/
+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;
+}
+/**
+* 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 {
+		await access(config_path);
+		const config_content = await readFile(config_path, "utf-8");
+		return JSON.parse(config_content);
+	} catch {
+		return {
+			mcpServers: {},
+			projects: {}
+		};
+	}
+}
+/**
+* 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 [];
+}
+/**
+* Read MCP servers from ~/.claude.json -> mcpServers (user scope)
+*/
+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
+export { get_enabled_servers as a, write_claude_config as c, find_server_in_scope as i, create_config_from_servers as n, get_enabled_servers_for_scope as o, detect_server_scope as r, read_claude_config as s, config_exports as t };
+
+//# sourceMappingURL=config-DijVdEFn.js.map

package/dist/dev-DRJRNp7y.js

@@ -0,0 +1,265 @@
+import { i as get_claude_config_path, o as get_current_project_path, s as get_dev_overrides_path, v as get_project_mcp_json_path } from "./paths-BPISiJi4.js";
+import { t as atomic_json_write } from "./atomic-write-BqEykHp9.js";
+import { i as find_server_in_scope, r as detect_server_scope } from "./config-DijVdEFn.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { n as redact_server_base } from "./redact-O35tjnRD.js";
+import { readFile } from "node:fs/promises";
+import { defineCommand } from "citty";
+//#region src/core/dev-override.ts
+const EMPTY_OVERRIDES = {
+	version: 1,
+	overrides: {}
+};
+async function read_dev_overrides() {
+	try {
+		const content = await readFile(get_dev_overrides_path(), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {
+			...EMPTY_OVERRIDES,
+			overrides: {}
+		};
+	}
+}
+async function write_dev_overrides(data) {
+	await atomic_json_write(get_dev_overrides_path(), () => data);
+}
+/**
+* Write a server config into the appropriate scope config file.
+*/
+async function write_server_to_scope(name, server, scope) {
+	if (scope === "user") await atomic_json_write(get_claude_config_path(), (existing) => {
+		if (!existing.mcpServers) existing.mcpServers = {};
+		existing.mcpServers[name] = server;
+		return existing;
+	});
+	else if (scope === "local") {
+		const cwd = get_current_project_path();
+		await atomic_json_write(get_claude_config_path(), (existing) => {
+			if (!existing.projects) existing.projects = {};
+			const projects = existing.projects;
+			if (!projects[cwd]) projects[cwd] = {};
+			if (!projects[cwd].mcpServers) projects[cwd].mcpServers = {};
+			projects[cwd].mcpServers[name] = server;
+			return existing;
+		});
+	} else if (scope === "project") await atomic_json_write(get_project_mcp_json_path(), (existing) => {
+		if (!existing.mcpServers) existing.mcpServers = {};
+		existing.mcpServers[name] = server;
+		return existing;
+	});
+}
+/**
+* Apply a dev override: store original config, swap in local dev command.
+*/
+async function apply_dev_override(name, command, args, scope) {
+	let found;
+	if (scope) found = await find_server_in_scope(name, scope);
+	else found = await detect_server_scope(name);
+	if (!found) return {
+		success: false,
+		scope: scope || "local",
+		error: `Server '${name}' not found${scope ? ` in ${scope} scope` : " in any scope"}`
+	};
+	const overrides = await read_dev_overrides();
+	if (overrides.overrides[name]) return {
+		success: false,
+		scope: found.scope,
+		error: `Server '${name}' already has a dev override. Run 'mcpick dev --restore ${name}' first.`
+	};
+	const dev_server = {
+		command,
+		...args.length > 0 ? { args } : {}
+	};
+	overrides.overrides[name] = {
+		original: found.server,
+		dev: dev_server,
+		scope: found.scope,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await write_dev_overrides(overrides);
+	await write_server_to_scope(name, dev_server, found.scope);
+	return {
+		success: true,
+		scope: found.scope
+	};
+}
+/**
+* Restore original server config from dev override.
+*/
+async function restore_dev_override(name) {
+	const overrides = await read_dev_overrides();
+	const entry = overrides.overrides[name];
+	if (!entry) return {
+		success: false,
+		error: `No dev override found for '${name}'`
+	};
+	await write_server_to_scope(name, entry.original, entry.scope);
+	delete overrides.overrides[name];
+	await write_dev_overrides(overrides);
+	return { success: true };
+}
+/**
+* Restore all dev overrides.
+*/
+async function restore_all_dev_overrides() {
+	const overrides = await read_dev_overrides();
+	const restored = [];
+	const errors = [];
+	for (const name of Object.keys(overrides.overrides)) {
+		const result = await restore_dev_override(name);
+		if (result.success) restored.push(name);
+		else errors.push(`${name}: ${result.error}`);
+	}
+	return {
+		restored,
+		errors
+	};
+}
+/**
+* List all active dev overrides.
+*/
+async function list_dev_overrides() {
+	const overrides = await read_dev_overrides();
+	return Object.entries(overrides.overrides).map(([name, entry]) => ({
+		name,
+		...entry
+	}));
+}
+var dev_default = defineCommand({
+	meta: {
+		name: "dev",
+		description: "MCP server local development workflow"
+	},
+	subCommands: {
+		apply: defineCommand({
+			meta: {
+				name: "apply",
+				description: "Override an MCP server with a local dev command"
+			},
+			args: {
+				name: {
+					type: "positional",
+					description: "Server name to override",
+					required: true
+				},
+				command: {
+					type: "string",
+					description: "Local command to run",
+					required: true
+				},
+				args: {
+					type: "string",
+					description: "Comma-separated arguments"
+				},
+				scope: {
+					type: "string",
+					description: "Scope to search: local, project, or user (default: auto-detect)"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const scope = args.scope;
+				if (scope && ![
+					"local",
+					"project",
+					"user"
+				].includes(scope)) error(`Invalid scope: ${scope}. Use local, project, or user.`);
+				const cmd_args = args.args ? args.args.split(",") : [];
+				const result = await apply_dev_override(args.name, args.command, cmd_args, scope);
+				if (args.json) output(result, true);
+				else if (result.success) {
+					console.log(`Dev override applied for '${args.name}' (scope: ${result.scope})`);
+					console.log(`  command: ${args.command}${cmd_args.length > 0 ? ` ${cmd_args.join(" ")}` : ""}`);
+					console.log("\nRestart Claude Code or run /reload-plugins to pick up changes.");
+				} else error(result.error || "Unknown error");
+			}
+		}),
+		restore: defineCommand({
+			meta: {
+				name: "restore",
+				description: "Restore original server config from dev override"
+			},
+			args: {
+				name: {
+					type: "positional",
+					description: "Server name to restore (omit with --all to restore all)",
+					required: false
+				},
+				all: {
+					type: "boolean",
+					description: "Restore all dev overrides",
+					default: false
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				if (args.all) {
+					const result = await restore_all_dev_overrides();
+					if (args.json) output(result, true);
+					else if (result.restored.length === 0 && result.errors.length === 0) console.log("No dev overrides to restore.");
+					else {
+						for (const name of result.restored) console.log(`Restored: ${name}`);
+						for (const err of result.errors) console.error(`Error: ${err}`);
+					}
+					return;
+				}
+				if (!args.name) error("Specify a server name or use --all. Run \"mcpick dev list\" to see active overrides.");
+				const result = await restore_dev_override(args.name);
+				if (args.json) output(result, true);
+				else if (result.success) {
+					console.log(`Restored original config for '${args.name}'`);
+					console.log("\nRestart Claude Code or run /reload-plugins to pick up changes.");
+				} else error(result.error || "Unknown error");
+			}
+		}),
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List active dev overrides"
+			},
+			args: { json: {
+				type: "boolean",
+				description: "Output as JSON",
+				default: false
+			} },
+			async run({ args }) {
+				const overrides = await list_dev_overrides();
+				if (args.json) {
+					output(overrides.map((o) => ({
+						...o,
+						original: redact_server_base(o.original),
+						dev: redact_server_base(o.dev)
+					})), true);
+					return;
+				}
+				if (overrides.length === 0) {
+					console.log("No active dev overrides.");
+					return;
+				}
+				for (const o of overrides) {
+					const orig = o.original;
+					const dev = o.dev;
+					const original_cmd = "command" in orig ? `${orig.command}${"args" in orig && orig.args ? " " + orig.args.join(" ") : ""}` : "url" in orig ? orig.url : "?";
+					const dev_cmd = "command" in dev ? `${dev.command}${"args" in dev && dev.args ? " " + dev.args.join(" ") : ""}` : "url" in dev ? dev.url : "?";
+					console.log(`${o.name}  (scope: ${o.scope})`);
+					console.log(`  original: ${original_cmd}`);
+					console.log(`  dev:      ${dev_cmd}`);
+					console.log(`  since:    ${o.createdAt}`);
+				}
+			}
+		})
+	}
+});
+//#endregion
+export { dev_default as default };
+
+//# sourceMappingURL=dev-DRJRNp7y.js.map

package/dist/disable-BA8tXPJN.js

@@ -0,0 +1,39 @@
+import { n as get_all_available_servers } from "./registry-CfUKT7_C.js";
+import { p as remove_mcp_via_cli } from "./claude-cli-BeA-bmoW.js";
+import { t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/disable.ts
+var disable_default = defineCommand({
+	meta: {
+		name: "disable",
+		description: "Disable an MCP server"
+	},
+	args: {
+		server: {
+			type: "positional",
+			description: "Server name to disable",
+			required: true
+		},
+		scope: {
+			type: "string",
+			description: "Scope: local, project, or user (default: local)",
+			default: "local"
+		}
+	},
+	async run({ args }) {
+		const scope = args.scope;
+		if (![
+			"local",
+			"project",
+			"user"
+		].includes(scope)) error(`Invalid scope: ${scope}. Use local, project, or user.`);
+		await get_all_available_servers();
+		const result = await remove_mcp_via_cli(args.server);
+		if (!result.success) error(result.error || "Failed to disable server");
+		console.log(`Disabled '${args.server}' (scope: ${scope})`);
+	}
+});
+//#endregion
+export { disable_default as default };
+
+//# sourceMappingURL=disable-BA8tXPJN.js.map

package/dist/enable-Bdnnn_Cq.js

@@ -0,0 +1,40 @@
+import { n as get_all_available_servers } from "./registry-CfUKT7_C.js";
+import { t as add_mcp_via_cli } from "./claude-cli-BeA-bmoW.js";
+import { t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/enable.ts
+var enable_default = defineCommand({
+	meta: {
+		name: "enable",
+		description: "Enable an MCP server"
+	},
+	args: {
+		server: {
+			type: "positional",
+			description: "Server name to enable",
+			required: true
+		},
+		scope: {
+			type: "string",
+			description: "Scope: local, project, or user (default: local)",
+			default: "local"
+		}
+	},
+	async run({ args }) {
+		const scope = args.scope;
+		if (![
+			"local",
+			"project",
+			"user"
+		].includes(scope)) error(`Invalid scope: ${scope}. Use local, project, or user.`);
+		const server = (await get_all_available_servers()).find((s) => s.name === args.server);
+		if (!server) error(`Server '${args.server}' not found in registry. Run 'mcpick list' to see available servers.`);
+		const result = await add_mcp_via_cli(server, scope);
+		if (!result.success) error(result.error || "Failed to enable server");
+		console.log(`Enabled '${server.name}' (scope: ${scope})`);
+	}
+});
+//#endregion
+export { enable_default as default };
+
+//# sourceMappingURL=enable-Bdnnn_Cq.js.map

package/dist/get-BPjMXTMc.js

@@ -0,0 +1,41 @@
+import { d as mcp_get_via_cli } from "./claude-cli-BeA-bmoW.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+//#region src/cli/commands/get.ts
+var get_default = defineCommand({
+	meta: {
+		name: "get",
+		description: "Get details about an MCP server"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "Server name",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const result = await mcp_get_via_cli(args.name);
+		if (args.json) try {
+			output(JSON.parse(result.stdout || "{}"), true);
+		} catch {
+			output({
+				name: args.name,
+				success: result.success,
+				output: result.stdout,
+				error: result.error
+			}, true);
+		}
+		else if (result.success) console.log(result.stdout || "No details available.");
+		else error(result.error || "Unknown error");
+	}
+});
+//#endregion
+export { get_default as default };
+
+//# sourceMappingURL=get-BPjMXTMc.js.map