mcpick 0.0.17 → 0.0.19

package/dist/hook-state-Di8lUsPr.js

@@ -0,0 +1,171 @@
+import { c as get_disabled_hooks_path, f as get_marketplaces_dir, p as get_mcpick_dir, t as ensure_directory_exists } from "./paths-BPISiJi4.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#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 writeFile(get_disabled_hooks_path(), JSON.stringify(entries, null, "	"), "utf-8");
+}
+/**
+* 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 writeFile(hooks_path, JSON.stringify(hooks_data, null, "	"), "utf-8");
+	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 writeFile(hooks_path, JSON.stringify(hooks_data, null, "	"), "utf-8");
+}
+/**
+* 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
+export { redisable_restored_hooks as a, read_disabled_hooks as i, disable_plugin_hook as n, enable_plugin_hook as r, check_restored_hooks as t };
+
+//# sourceMappingURL=hook-state-Di8lUsPr.js.map

package/dist/hooks-Bmn7pUZa.js

@@ -0,0 +1,280 @@
+import { o as remove_hook, r as get_all_hooks, t as add_hook } from "./settings-DEcWtzLE.js";
+import { a as redisable_restored_hooks, i as read_disabled_hooks, n as disable_plugin_hook, r as enable_plugin_hook, t as check_restored_hooks } from "./hook-state-Di8lUsPr.js";
+import { n as output, t as error } from "./output-BchYq0mR.js";
+import { defineCommand } from "citty";
+var hooks_default = defineCommand({
+	meta: {
+		name: "hooks",
+		description: "Manage hooks (settings + plugin). Disable individual plugin hooks, add/remove settings hooks."
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List all configured hooks (settings + plugins + disabled)"
+			},
+			args: {
+				scope: {
+					type: "string",
+					description: "Filter by source: user, project, project-local, or plugin"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const hooks = await get_all_hooks();
+				const disabled = await read_disabled_hooks();
+				const filtered = args.scope ? hooks.filter((h) => h.source === args.scope || h.scope === args.scope) : hooks;
+				if (args.json) output({
+					active: filtered,
+					disabled
+				}, true);
+				else {
+					if (filtered.length === 0 && disabled.length === 0) {
+						console.log("No hooks configured.");
+						return;
+					}
+					if (filtered.length > 0) for (let i = 0; i < filtered.length; i++) {
+						const h = filtered[i];
+						const detail = h.handler.command || h.handler.url || h.handler.prompt || "(unknown)";
+						const matcher_str = h.matcher ? ` [${h.matcher}]` : "";
+						const source = h.source === "plugin" ? `plugin: ${h.plugin_key}` : h.scope;
+						console.log(`${i}: [${source}] ${h.event}${matcher_str} → ${h.handler.type}: ${detail}`);
+					}
+					if (disabled.length > 0) {
+						console.log("\nDisabled:");
+						for (let i = 0; i < disabled.length; i++) {
+							const d = disabled[i];
+							const detail = d.original_handler.command || d.original_handler.url || d.original_handler.prompt || "(unknown)";
+							const matcher_str = d.matcher ? ` [${d.matcher}]` : "";
+							console.log(`${i}: [${d.plugin_key}] ${d.event}${matcher_str} → ${d.original_handler.type}: ${detail}`);
+						}
+					}
+				}
+			}
+		}),
+		disable: defineCommand({
+			meta: {
+				name: "disable",
+				description: "Disable a hook by index (use \"hooks list\" to see indices)"
+			},
+			args: {
+				index: {
+					type: "positional",
+					description: "Hook index from \"hooks list\" (0-based)",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const hooks = await get_all_hooks();
+				const idx = parseInt(args.index, 10);
+				if (isNaN(idx) || idx < 0 || idx >= hooks.length) error(`Invalid index: ${args.index}. Run "mcpick hooks list" to see available hooks (0-${hooks.length - 1}).`);
+				const entry = hooks[idx];
+				if (entry.source === "plugin") {
+					await disable_plugin_hook(entry);
+					if (args.json) output({
+						disabled: true,
+						event: entry.event,
+						plugin_key: entry.plugin_key
+					}, true);
+					else {
+						console.log(`Disabled: ${entry.event} from ${entry.plugin_key}`);
+						console.log("Restart Claude Code for changes to take effect.");
+					}
+				} else {
+					await remove_hook(entry);
+					if (args.json) output({
+						removed: true,
+						event: entry.event,
+						scope: entry.scope
+					}, true);
+					else console.log(`Removed: ${entry.event} (${entry.scope})`);
+				}
+			}
+		}),
+		enable: defineCommand({
+			meta: {
+				name: "enable",
+				description: "Re-enable a disabled hook by index (use \"hooks list\" to see disabled hooks)"
+			},
+			args: {
+				index: {
+					type: "positional",
+					description: "Disabled hook index from \"hooks list\" (0-based)",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const disabled = await read_disabled_hooks();
+				const idx = parseInt(args.index, 10);
+				if (isNaN(idx) || idx < 0 || idx >= disabled.length) error(`Invalid index: ${args.index}. Run "mcpick hooks list" to see disabled hooks (0-${disabled.length - 1}).`);
+				const entry = disabled[idx];
+				await enable_plugin_hook(entry);
+				if (args.json) output({
+					enabled: true,
+					event: entry.event,
+					plugin_key: entry.plugin_key
+				}, true);
+				else {
+					console.log(`Re-enabled: ${entry.event} for ${entry.plugin_key}`);
+					console.log("Restart Claude Code for changes to take effect.");
+				}
+			}
+		}),
+		add: defineCommand({
+			meta: {
+				name: "add",
+				description: "Add a new settings-based hook"
+			},
+			args: {
+				event: {
+					type: "positional",
+					description: "Hook event type (e.g. UserPromptSubmit, PreToolUse)",
+					required: true
+				},
+				handler_type: {
+					type: "positional",
+					description: "Handler type: command, prompt, http, or agent",
+					required: true
+				},
+				value: {
+					type: "positional",
+					description: "Handler value (command string, prompt text, URL, or agent prompt)",
+					required: true
+				},
+				matcher: {
+					type: "string",
+					description: "Matcher pattern (e.g. Bash, Edit|Write) — only for tool/session events"
+				},
+				scope: {
+					type: "string",
+					description: "Scope: user, project, or project-local (default: user)",
+					default: "user"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const scope = args.scope;
+				if (![
+					"user",
+					"project",
+					"project-local"
+				].includes(scope)) error(`Invalid scope: ${scope}. Use user, project, or project-local.`);
+				const handler_type = args.handler_type;
+				if (![
+					"command",
+					"prompt",
+					"http",
+					"agent"
+				].includes(handler_type)) error(`Invalid handler type: ${handler_type}. Use command, prompt, http, or agent.`);
+				const handler = { type: handler_type };
+				if (handler_type === "command") handler.command = args.value;
+				else if (handler_type === "prompt") handler.prompt = args.value;
+				else if (handler_type === "http") handler.url = args.value;
+				else if (handler_type === "agent") handler.prompt = args.value;
+				await add_hook(scope, args.event, args.matcher || void 0, handler);
+				if (args.json) output({
+					added: true,
+					event: args.event,
+					handler_type,
+					scope,
+					matcher: args.matcher || null
+				}, true);
+				else console.log(`Hook added: ${args.event} → ${handler_type} (${scope})`);
+			}
+		}),
+		remove: defineCommand({
+			meta: {
+				name: "remove",
+				description: "Remove a settings hook by index (use \"hooks list\" to see indices)"
+			},
+			args: {
+				index: {
+					type: "positional",
+					description: "Hook index from \"hooks list\" (0-based)",
+					required: true
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const settings_hooks = (await get_all_hooks()).filter((h) => h.source !== "plugin");
+				const idx = parseInt(args.index, 10);
+				if (isNaN(idx) || idx < 0 || idx >= settings_hooks.length) error(`Invalid index: ${args.index}. Use "mcpick hooks list" to see settings hooks.`);
+				const entry = settings_hooks[idx];
+				await remove_hook(entry);
+				if (args.json) output({
+					removed: true,
+					event: entry.event,
+					scope: entry.scope
+				}, true);
+				else {
+					const detail = entry.handler.command || entry.handler.url || entry.handler.prompt || "(unknown)";
+					console.log(`Removed: [${entry.scope}] ${entry.event} → ${entry.handler.type}: ${detail}`);
+				}
+			}
+		}),
+		check: defineCommand({
+			meta: {
+				name: "check",
+				description: "Check if marketplace updates restored any disabled hooks"
+			},
+			args: {
+				fix: {
+					type: "boolean",
+					description: "Automatically re-disable restored hooks",
+					default: false
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const restored = await check_restored_hooks();
+				if (args.json) {
+					output({
+						restored: restored.length,
+						hooks: restored
+					}, true);
+					return;
+				}
+				if (restored.length === 0) {
+					console.log("No disabled hooks were restored. All good.");
+					return;
+				}
+				console.log(`${restored.length} disabled hook(s) were restored:`);
+				for (const r of restored) console.log(`  ${r.plugin_key}: ${r.event}`);
+				if (args.fix) {
+					const result = await redisable_restored_hooks(restored);
+					console.log(`Re-disabled ${result.success} hook(s).${result.failed > 0 ? ` Failed: ${result.failed}` : ""}`);
+				} else console.log("Run with --fix to re-disable, or use \"mcpick hooks disable\".");
+			}
+		})
+	}
+});
+//#endregion
+export { hooks_default as default };
+
+//# sourceMappingURL=hooks-Bmn7pUZa.js.map