mcpick 0.0.17 → 0.0.19

package/dist/settings-DEcWtzLE.js

@@ -0,0 +1,201 @@
+import { a as get_claude_settings_path } from "./paths-BPISiJi4.js";
+import { t as atomic_json_write } from "./atomic-write-BqEykHp9.js";
+import { access, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+//#region src/core/settings.ts
+async function read_claude_settings() {
+	const settings_path = get_claude_settings_path();
+	try {
+		await access(settings_path);
+		const content = await readFile(settings_path, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+		throw error;
+	}
+}
+async function write_claude_settings(updates) {
+	await atomic_json_write(get_claude_settings_path(), (existing) => {
+		for (const [key, value] of Object.entries(updates)) existing[key] = value;
+		return existing;
+	});
+}
+/**
+* Parse enabledPlugins into structured list.
+* Keys are in format "plugin-name@marketplace-name"
+*/
+function get_all_plugins(settings) {
+	const enabled_plugins = settings.enabledPlugins || {};
+	return Object.entries(enabled_plugins).map(([key, enabled]) => {
+		const at_index = key.lastIndexOf("@");
+		return {
+			name: at_index > 0 ? key.substring(0, at_index) : key,
+			marketplace: at_index > 0 ? key.substring(at_index + 1) : "unknown",
+			enabled
+		};
+	});
+}
+/**
+* Build the enabledPlugins record from a list of PluginInfo
+*/
+function build_enabled_plugins(plugins) {
+	const result = {};
+	for (const plugin of plugins) {
+		const key = `${plugin.name}@${plugin.marketplace}`;
+		result[key] = plugin.enabled;
+	}
+	return result;
+}
+async function read_settings_file(path) {
+	try {
+		await access(path);
+		const content = await readFile(path, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+function get_settings_paths() {
+	return [
+		{
+			scope: "user",
+			path: resolve(process.env.HOME || process.env.USERPROFILE || "", ".claude", "settings.json")
+		},
+		{
+			scope: "project",
+			path: resolve(process.cwd(), ".claude", "settings.json")
+		},
+		{
+			scope: "project-local",
+			path: resolve(process.cwd(), ".claude", "settings.local.json")
+		}
+	];
+}
+/**
+* Read all hooks across all scopes (settings + plugins), flattened for display.
+*/
+async function get_all_hooks() {
+	const entries = [];
+	for (const { scope, path } of get_settings_paths()) {
+		const hooks = (await read_settings_file(path)).hooks;
+		if (!hooks) continue;
+		for (const [event, matchers] of Object.entries(hooks)) {
+			if (!Array.isArray(matchers)) continue;
+			for (let mi = 0; mi < matchers.length; mi++) {
+				const m = matchers[mi];
+				if (!m.hooks?.length) continue;
+				for (let hi = 0; hi < m.hooks.length; hi++) entries.push({
+					event,
+					matcher: m.matcher,
+					handler: m.hooks[hi],
+					scope,
+					source: scope,
+					matcher_index: mi,
+					hook_index: hi
+				});
+			}
+		}
+	}
+	const plugin_hooks = await get_all_plugin_hooks();
+	entries.push(...plugin_hooks);
+	return entries;
+}
+/**
+* Scan all installed plugins for hooks.json and return flattened hook entries.
+* Checks both cache and marketplace source paths since Claude Code reads from both.
+*/
+async function get_all_plugin_hooks() {
+	const { read_installed_plugins } = await import("./plugin-cache-Bby9Dxm9.js").then((n) => n.s);
+	const { get_marketplaces_dir } = await import("./paths-BPISiJi4.js").then((n) => n.b);
+	const installed = await read_installed_plugins();
+	const entries = [];
+	const seen_hooks = /* @__PURE__ */ new Set();
+	for (const [plugin_key, installs] of Object.entries(installed.plugins)) {
+		if (!installs?.length) continue;
+		const install = installs[0];
+		const at_index = plugin_key.lastIndexOf("@");
+		const plugin_name = at_index > 0 ? plugin_key.substring(0, at_index) : plugin_key;
+		const marketplace_name = at_index > 0 ? plugin_key.substring(at_index + 1) : "";
+		const hooks_paths = [join(install.installPath, "hooks", "hooks.json")];
+		if (marketplace_name) hooks_paths.push(join(get_marketplaces_dir(), marketplace_name, "plugins", plugin_name, "hooks", "hooks.json"));
+		for (const hooks_path of hooks_paths) {
+			let hooks_data;
+			try {
+				const content = await readFile(hooks_path, "utf-8");
+				hooks_data = JSON.parse(content);
+			} catch {
+				continue;
+			}
+			const hooks = hooks_data.hooks || hooks_data;
+			for (const [event, matchers] of Object.entries(hooks)) {
+				if (!Array.isArray(matchers)) continue;
+				for (let mi = 0; mi < matchers.length; mi++) {
+					const m = matchers[mi];
+					if (!m.hooks?.length) continue;
+					for (let hi = 0; hi < m.hooks.length; hi++) {
+						const h = m.hooks[hi];
+						const dedup_key = `${plugin_key}:${event}:${h.type}:${h.command || h.url || h.prompt}`;
+						if (seen_hooks.has(dedup_key)) continue;
+						seen_hooks.add(dedup_key);
+						entries.push({
+							event,
+							matcher: m.matcher,
+							handler: h,
+							scope: "user",
+							source: "plugin",
+							matcher_index: mi,
+							hook_index: hi,
+							plugin_key,
+							hooks_json_path: hooks_path
+						});
+					}
+				}
+			}
+		}
+	}
+	return entries;
+}
+/**
+* Remove a specific hook entry by scope/event/indices.
+*/
+async function remove_hook(entry) {
+	const scope_path = get_settings_paths().find((s) => s.scope === entry.scope);
+	if (!scope_path) throw new Error(`Unknown scope: ${entry.scope}`);
+	await atomic_json_write(scope_path.path, (existing) => {
+		const hooks = existing.hooks;
+		if (!hooks) return existing;
+		const matchers = hooks[entry.event];
+		if (!matchers?.[entry.matcher_index]) return existing;
+		const matcher = matchers[entry.matcher_index];
+		matcher.hooks.splice(entry.hook_index, 1);
+		if (matcher.hooks.length === 0) matchers.splice(entry.matcher_index, 1);
+		if (matchers.length === 0) delete hooks[entry.event];
+		if (Object.keys(hooks).length === 0) delete existing.hooks;
+		return existing;
+	});
+}
+/**
+* Add a hook to a specific scope.
+*/
+async function add_hook(scope, event, matcher, handler) {
+	const scope_path = get_settings_paths().find((s) => s.scope === scope);
+	if (!scope_path) throw new Error(`Unknown scope: ${scope}`);
+	await atomic_json_write(scope_path.path, (existing) => {
+		if (!existing.hooks) existing.hooks = {};
+		const hooks = existing.hooks;
+		if (!hooks[event]) hooks[event] = [];
+		const matchers = hooks[event];
+		const existing_matcher = matchers.find((m) => (m.matcher || void 0) === matcher);
+		if (existing_matcher) existing_matcher.hooks.push(handler);
+		else {
+			const new_matcher = { hooks: [handler] };
+			if (matcher) new_matcher.matcher = matcher;
+			matchers.push(new_matcher);
+		}
+		return existing;
+	});
+}
+//#endregion
+export { read_claude_settings as a, get_all_plugins as i, build_enabled_plugins as n, remove_hook as o, get_all_hooks as r, write_claude_settings as s, add_hook as t };
+
+//# sourceMappingURL=settings-DEcWtzLE.js.map

package/dist/validation-xMlbgGCF.js

@@ -0,0 +1,44 @@
+import * as v from "valibot";
+//#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 server_registry_schema = v.object({ servers: v.array(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
+export { validate_mcp_server as n, validate_server_registry as r, validate_claude_config as t };
+
+//# sourceMappingURL=validation-xMlbgGCF.js.map

package/package.json

@@ -1,24 +1,21 @@
 {
   "name": "mcpick",
-  "version": "0.0.17",
-  "description": "Dynamic MCP server and plugin configuration manager for Claude Code",
-  "type": "module",
-  "main": "./dist/index.js",
-  "bin": {
-    "mcpick": "./dist/index.js"
-  },
-  "engines": {
-    "node": ">=22.0.0"
-  },
+  "version": "0.0.19",
+  "description": "Claude Code extension manager — MCP servers, plugins (skills, hooks, agents), and marketplaces",
   "keywords": [
     "claude",
-    "mcp",
+    "claude-code",
     "cli",
     "configuration",
-    "claude-code"
+    "mcp"
   ],
-  "author": "",
   "license": "MIT",
+  "author": "",
+  "bin": {
+    "mcpick": "./dist/index.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
   "dependencies": {
     "@clack/prompts": "^1.1.0",
     "citty": "^0.2.1",
@@ -27,15 +24,19 @@
   "devDependencies": {
     "@changesets/cli": "^2.30.0",
     "@types/node": "^25.5.0",
-    "prettier": "^3.8.1",
-    "typescript": "^5.9.3"
+    "vite-plus": "^0.1.15",
+    "vitest": "^4.1.2"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "vp pack",
+    "dev": "vp pack --watch",
     "start": "node ./dist/index.js",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "check": "vp check",
+    "format": "vp check --fix",
+    "test": "vp test",
     "changeset": "changeset",
     "version": "changeset version",
     "release": "pnpm run build && changeset publish"

package/dist/cli/commands/add-json.js

@@ -1,60 +0,0 @@
-import { defineCommand } from 'citty';
-import { mcp_add_json_via_cli } from '../../utils/claude-cli.js';
-import { error, output } from '../output.js';
-export default defineCommand({
-    meta: {
-        name: 'add-json',
-        description: 'Add an MCP server from a JSON configuration string',
-    },
-    args: {
-        name: {
-            type: 'positional',
-            description: 'Server name',
-            required: true,
-        },
-        config: {
-            type: 'positional',
-            description: 'JSON configuration string',
-            required: true,
-        },
-        scope: {
-            type: 'string',
-            description: 'Scope: local, project, or user (default: local)',
-            default: 'local',
-        },
-        json: {
-            type: 'boolean',
-            description: 'Output as JSON',
-            default: false,
-        },
-    },
-    async run({ args }) {
-        const scope = args.scope;
-        if (!['local', 'project', 'user'].includes(scope)) {
-            error(`Invalid scope: ${scope}. Use local, project, or user.`);
-        }
-        // Validate the JSON is parseable
-        try {
-            JSON.parse(args.config);
-        }
-        catch {
-            error('Invalid JSON configuration. Provide a valid JSON string.');
-        }
-        const result = await mcp_add_json_via_cli(args.name, args.config, scope);
-        if (args.json) {
-            output({
-                added: args.name,
-                scope,
-                success: result.success,
-                error: result.error,
-            }, true);
-        }
-        else if (result.success) {
-            console.log(`Added '${args.name}' from JSON (scope: ${scope})`);
-        }
-        else {
-            error(result.error || 'Unknown error');
-        }
-    },
-});
-//# sourceMappingURL=add-json.js.map

package/dist/cli/commands/add.js

@@ -1,135 +0,0 @@
-import { defineCommand } from 'citty';
-import { add_server_to_registry } from '../../core/registry.js';
-import { validate_mcp_server } from '../../core/validation.js';
-import { add_mcp_via_cli } from '../../utils/claude-cli.js';
-import { error, output } from '../output.js';
-export default defineCommand({
-    meta: {
-        name: 'add',
-        description: 'Add a new MCP server to the registry and enable it',
-    },
-    args: {
-        name: {
-            type: 'string',
-            description: 'Server name',
-            required: true,
-        },
-        command: {
-            type: 'string',
-            description: 'Command to run (for stdio transport)',
-        },
-        args: {
-            type: 'string',
-            description: 'Comma-separated arguments (e.g. "npx,-y,mcp-sqlite")',
-        },
-        url: {
-            type: 'string',
-            description: 'URL (for sse or http transport)',
-        },
-        type: {
-            type: 'string',
-            description: 'Transport type: stdio, sse, or http (default: stdio)',
-            default: 'stdio',
-        },
-        env: {
-            type: 'string',
-            description: 'Environment variables as KEY=val,KEY=val',
-        },
-        headers: {
-            type: 'string',
-            description: 'HTTP headers as KEY=val,KEY=val',
-        },
-        description: {
-            type: 'string',
-            description: 'Server description',
-        },
-        scope: {
-            type: 'string',
-            description: 'Scope: local, project, or user (default: local)',
-            default: 'local',
-        },
-        json: {
-            type: 'boolean',
-            description: 'Output as JSON',
-            default: false,
-        },
-    },
-    async run({ args }) {
-        const scope = args.scope;
-        if (!['local', 'project', 'user'].includes(scope)) {
-            error(`Invalid scope: ${scope}. Use local, project, or user.`);
-        }
-        const transport = args.type;
-        if (!['stdio', 'sse', 'http'].includes(transport)) {
-            error(`Invalid type: ${transport}. Use stdio, sse, or http.`);
-        }
-        // Build server object
-        const server_data = {
-            name: args.name,
-        };
-        if (transport === 'stdio') {
-            if (!args.command) {
-                error('--command is required for stdio transport');
-            }
-            server_data.command = args.command;
-            if (args.args) {
-                server_data.args = args.args.split(',');
-            }
-        }
-        else {
-            if (!args.url) {
-                error(`--url is required for ${transport} transport`);
-            }
-            server_data.type = transport;
-            server_data.url = args.url;
-            if (args.headers) {
-                server_data.headers = parse_key_value_pairs(args.headers);
-            }
-        }
-        if (args.env) {
-            server_data.env = parse_key_value_pairs(args.env);
-        }
-        if (args.description) {
-            server_data.description = args.description;
-        }
-        // Validate
-        let server;
-        try {
-            server = validate_mcp_server(server_data);
-        }
-        catch (err) {
-            error(`Invalid server config: ${err instanceof Error ? err.message : 'validation failed'}`);
-        }
-        // Add to registry
-        await add_server_to_registry(server);
-        // Enable via CLI
-        const result = await add_mcp_via_cli(server, scope);
-        if (args.json) {
-            output({
-                added: server.name,
-                scope,
-                cli: result.success,
-                error: result.error,
-            }, true);
-        }
-        else {
-            if (result.success) {
-                console.log(`Added '${server.name}' and enabled (scope: ${scope})`);
-            }
-            else {
-                console.log(`Added '${server.name}' to registry but CLI failed: ${result.error}`);
-            }
-        }
-    },
-});
-function parse_key_value_pairs(input) {
-    const result = {};
-    for (const pair of input.split(',')) {
-        const eq = pair.indexOf('=');
-        if (eq > 0) {
-            result[pair.substring(0, eq)] = pair.substring(eq + 1);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=add.js.map

package/dist/cli/commands/backup.js

@@ -1,83 +0,0 @@
-import { defineCommand } from 'citty';
-import { readdir, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { read_claude_config } from '../../core/config.js';
-import { read_claude_settings } from '../../core/settings.js';
-import { ensure_directory_exists, get_backup_filename, get_backups_dir, get_plugin_backup_filename, } from '../../utils/paths.js';
-import { output } from '../output.js';
-const MAX_BACKUPS = 10;
-async function cleanup_old_backups(prefix) {
-    try {
-        const backups_dir = get_backups_dir();
-        const files = await readdir(backups_dir);
-        const backup_files = files
-            .filter((f) => f.startsWith(prefix) && f.endsWith('.json'))
-            .sort()
-            .reverse();
-        if (backup_files.length > MAX_BACKUPS) {
-            for (const file of backup_files.slice(MAX_BACKUPS)) {
-                await unlink(join(backups_dir, file));
-            }
-        }
-    }
-    catch {
-        // Cleanup is best-effort
-    }
-}
-export default defineCommand({
-    meta: {
-        name: 'backup',
-        description: 'Create a timestamped backup of MCP servers and plugins',
-    },
-    args: {
-        json: {
-            type: 'boolean',
-            description: 'Output as JSON',
-            default: false,
-        },
-    },
-    async run({ args }) {
-        const current_config = await read_claude_config();
-        const current_settings = await read_claude_settings();
-        const backups_dir = get_backups_dir();
-        await ensure_directory_exists(backups_dir);
-        // Backup MCP servers
-        const mcp_filename = get_backup_filename();
-        const mcp_path = join(backups_dir, mcp_filename);
-        const mcp_backup = {
-            mcpServers: current_config.mcpServers || {},
-        };
-        await writeFile(mcp_path, JSON.stringify(mcp_backup, null, 2), 'utf-8');
-        // Backup plugins
-        const plugins = current_settings.enabledPlugins || {};
-        const plugin_count = Object.keys(plugins).length;
-        let plugin_path = null;
-        if (plugin_count > 0) {
-            const plugin_filename = get_plugin_backup_filename();
-            plugin_path = join(backups_dir, plugin_filename);
-            const plugin_backup = { enabledPlugins: plugins };
-            await writeFile(plugin_path, JSON.stringify(plugin_backup, null, 2), 'utf-8');
-        }
-        await cleanup_old_backups('mcp-servers-');
-        await cleanup_old_backups('plugins-');
-        const server_count = Object.keys(current_config.mcpServers || {}).length;
-        if (args.json) {
-            output({
-                mcp: { path: mcp_path, servers: server_count },
-                plugins: plugin_path
-                    ? {
-                        path: plugin_path,
-                        plugins: plugin_count,
-                    }
-                    : null,
-            }, true);
-        }
-        else {
-            console.log(`Backup created: ${mcp_path} (${server_count} servers)`);
-            if (plugin_path) {
-                console.log(`Plugin backup: ${plugin_path} (${plugin_count} plugins)`);
-            }
-        }
-    },
-});
-//# sourceMappingURL=backup.js.map