mcpick 0.0.15 → 0.0.17

package/dist/commands/manage-hooks.js

@@ -0,0 +1,99 @@
+import { isCancel, log, multiselect, note } from '@clack/prompts';
+import { disable_plugin_hook, enable_plugin_hook, read_disabled_hooks, } from '../core/hook-state.js';
+import { get_all_hooks } from '../core/settings.js';
+function format_hook(entry) {
+    const detail = entry.handler.command ||
+        entry.handler.url ||
+        entry.handler.prompt ||
+        '(unknown)';
+    const truncated = detail.length > 50 ? detail.substring(0, 47) + '...' : detail;
+    return `${entry.event} → ${entry.handler.type}: ${truncated}`;
+}
+function format_source(entry) {
+    if (entry.source === 'plugin' && entry.plugin_key) {
+        return entry.plugin_key;
+    }
+    return entry.scope;
+}
+export async function manage_hooks() {
+    // Get all active hooks + disabled hooks
+    const active_hooks = await get_all_hooks();
+    const disabled = await read_disabled_hooks();
+    const items = [];
+    // Active hooks
+    for (let i = 0; i < active_hooks.length; i++) {
+        const h = active_hooks[i];
+        items.push({
+            id: `active:${i}`,
+            active_entry: h,
+            label: format_hook(h),
+            hint: format_source(h),
+        });
+    }
+    // Disabled hooks
+    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 truncated = detail.length > 50 ? detail.substring(0, 47) + '...' : detail;
+        items.push({
+            id: `disabled:${i}`,
+            disabled_index: i,
+            label: `${d.event} → ${d.original_handler.type}: ${truncated}`,
+            hint: `${d.plugin_key} (disabled)`,
+        });
+    }
+    if (items.length === 0) {
+        note('No hooks found (settings or plugins).');
+        return;
+    }
+    // Currently enabled = active hooks
+    const currently_enabled = items
+        .filter((item) => item.active_entry)
+        .map((item) => item.id);
+    const selected = await multiselect({
+        message: 'Toggle hooks on/off:',
+        options: items.map((item) => ({
+            value: item.id,
+            label: item.label,
+            hint: item.hint,
+        })),
+        initialValues: currently_enabled,
+        required: false,
+    });
+    if (isCancel(selected))
+        return;
+    const selected_set = new Set(selected);
+    let changes = 0;
+    // Disable hooks that were deselected (active → disabled)
+    for (const item of items) {
+        if (!item.active_entry)
+            continue;
+        if (selected_set.has(item.id))
+            continue;
+        // Only plugin hooks can be disabled — settings hooks get removed
+        if (item.active_entry.source === 'plugin') {
+            await disable_plugin_hook(item.active_entry);
+            changes++;
+        }
+    }
+    // Enable hooks that were selected (disabled → active)
+    for (const item of items) {
+        if (item.disabled_index === undefined)
+            continue;
+        if (!selected_set.has(item.id))
+            continue;
+        await enable_plugin_hook(disabled[item.disabled_index]);
+        changes++;
+    }
+    if (changes > 0) {
+        log.success(`${changes} hook(s) updated.`);
+        log.info('Restart Claude Code for changes to take effect.');
+    }
+    else {
+        log.info('No changes.');
+    }
+}
+//# sourceMappingURL=manage-hooks.js.map

package/dist/commands/manage-marketplace.js

@@ -0,0 +1,293 @@
+import { confirm, isCancel, log, multiselect, note, select, text, } from '@clack/prompts';
+import { check_restored_hooks, redisable_restored_hooks, } from '../core/hook-state.js';
+import { read_known_marketplaces, read_marketplace_manifest, } from '../core/plugin-cache.js';
+import { get_all_plugins, read_claude_settings, } from '../core/settings.js';
+import { install_plugin_via_cli, marketplace_add_via_cli, marketplace_remove_via_cli, marketplace_update_via_cli, uninstall_plugin_via_cli, } from '../utils/claude-cli.js';
+/**
+ * Browse all available plugins across all marketplaces.
+ * Shows a multiselect with installed plugins pre-selected — toggle to install/uninstall.
+ */
+async function handle_browse() {
+    const known = await read_known_marketplaces();
+    const marketplace_names = Object.keys(known);
+    if (marketplace_names.length === 0) {
+        note('No marketplaces configured.\nAdd one first to browse plugins.');
+        return;
+    }
+    // Build list of all available plugins across marketplaces
+    const all_available = [];
+    for (const mkt_name of marketplace_names) {
+        const manifest = await read_marketplace_manifest(mkt_name);
+        if (!manifest?.plugins?.length)
+            continue;
+        for (const p of manifest.plugins) {
+            all_available.push({
+                key: `${p.name}@${mkt_name}`,
+                name: p.name,
+                marketplace: mkt_name,
+                description: p.description,
+            });
+        }
+    }
+    if (all_available.length === 0) {
+        note('No plugins found in any marketplace.');
+        return;
+    }
+    // Get currently installed plugins
+    const settings = await read_claude_settings();
+    const installed = get_all_plugins(settings);
+    const installed_keys = new Set(installed.map((p) => `${p.name}@${p.marketplace}`));
+    const selected = await multiselect({
+        message: `Available plugins (${all_available.length}) — toggle to install/uninstall:`,
+        options: all_available.map((p) => ({
+            value: p.key,
+            label: p.name,
+            hint: `${p.marketplace}${p.description ? ` · ${p.description}` : ''}`,
+        })),
+        initialValues: all_available
+            .filter((p) => installed_keys.has(p.key))
+            .map((p) => p.key),
+        required: false,
+    });
+    if (isCancel(selected))
+        return;
+    const selected_set = new Set(selected);
+    // Determine what to install and uninstall
+    const to_install = all_available.filter((p) => selected_set.has(p.key) && !installed_keys.has(p.key));
+    const to_uninstall = all_available.filter((p) => !selected_set.has(p.key) && installed_keys.has(p.key));
+    if (to_install.length === 0 && to_uninstall.length === 0) {
+        log.info('No changes.');
+        return;
+    }
+    // Install new plugins
+    for (const p of to_install) {
+        log.info(`Installing ${p.key}...`);
+        const result = await install_plugin_via_cli(p.key);
+        if (result.success) {
+            log.success(`Installed: ${p.key}`);
+        }
+        else {
+            log.error(`Failed: ${p.key} - ${result.error}`);
+        }
+    }
+    // Uninstall deselected plugins
+    for (const p of to_uninstall) {
+        log.info(`Uninstalling ${p.key}...`);
+        const result = await uninstall_plugin_via_cli(p.key);
+        if (result.success) {
+            log.success(`Uninstalled: ${p.key}`);
+        }
+        else {
+            log.error(`Failed: ${p.key} - ${result.error}`);
+        }
+    }
+    const parts = [];
+    if (to_install.length > 0)
+        parts.push(`${to_install.length} installed`);
+    if (to_uninstall.length > 0)
+        parts.push(`${to_uninstall.length} uninstalled`);
+    note(parts.join(', '), 'Plugins updated');
+}
+async function handle_add() {
+    const source = await text({
+        message: 'Marketplace source:',
+        placeholder: 'e.g. owner/repo or https://github.com/owner/repo',
+        validate: (value) => {
+            if (!value || value.trim().length === 0) {
+                return 'Marketplace source is required';
+            }
+        },
+    });
+    if (isCancel(source))
+        return;
+    log.info(`Adding marketplace: ${source}`);
+    const result = await marketplace_add_via_cli(source);
+    if (!result.success) {
+        log.error(result.error || 'Unknown error');
+        return;
+    }
+    log.success(`Marketplace added: ${source}`);
+    // Try to find and offer available plugins
+    const marketplace_name = derive_marketplace_name(source);
+    const manifest = marketplace_name
+        ? await read_marketplace_manifest(marketplace_name)
+        : null;
+    if (!manifest?.plugins?.length) {
+        log.info('Install plugins with: mcpick plugins install <name>@<marketplace>');
+        return;
+    }
+    const should_install = await confirm({
+        message: `${manifest.plugins.length} plugins available. Install now?`,
+    });
+    if (isCancel(should_install) || !should_install)
+        return;
+    const to_install = await multiselect({
+        message: 'Select plugins to install:',
+        options: manifest.plugins.map((p) => ({
+            value: `${p.name}@${marketplace_name}`,
+            label: p.name,
+            hint: p.description,
+        })),
+        required: false,
+    });
+    if (isCancel(to_install) || to_install.length === 0)
+        return;
+    for (const key of to_install) {
+        log.info(`Installing ${key}...`);
+        const install_result = await install_plugin_via_cli(key);
+        if (install_result.success) {
+            log.success(`Installed: ${key}`);
+        }
+        else {
+            log.error(`Failed: ${key} - ${install_result.error}`);
+        }
+    }
+}
+function derive_marketplace_name(source) {
+    const match = source.match(/([^/]+?)(?:\.git)?$/);
+    return match ? match[1].toLowerCase() : null;
+}
+async function handle_remove() {
+    const known = await read_known_marketplaces();
+    const names = Object.keys(known);
+    if (names.length === 0) {
+        note('No marketplaces configured.');
+        return;
+    }
+    const name = await select({
+        message: 'Select marketplace to remove:',
+        options: names.map((n) => ({
+            value: n,
+            label: n,
+            hint: known[n].source.repo || known[n].source.url,
+        })),
+    });
+    if (isCancel(name))
+        return;
+    const should_remove = await confirm({
+        message: `Remove marketplace '${name}'? Its plugins will also be removed.`,
+    });
+    if (isCancel(should_remove) || !should_remove)
+        return;
+    const remove_result = await marketplace_remove_via_cli(name);
+    if (remove_result.success) {
+        log.success(`Marketplace removed: ${name}`);
+    }
+    else {
+        log.error(remove_result.error || 'Unknown error');
+    }
+}
+async function handle_update() {
+    const known = await read_known_marketplaces();
+    const names = Object.keys(known);
+    if (names.length === 0) {
+        note('No marketplaces configured.');
+        return;
+    }
+    const choice = await select({
+        message: 'What to update:',
+        options: [
+            { value: '__all__', label: 'All marketplaces' },
+            ...names.map((n) => ({
+                value: n,
+                label: n,
+                hint: known[n].source.repo || known[n].source.url,
+            })),
+        ],
+    });
+    if (isCancel(choice))
+        return;
+    if (choice === '__all__') {
+        log.info('Updating all marketplaces...');
+        const result = await marketplace_update_via_cli();
+        if (result.success) {
+            log.success('All marketplaces updated.');
+        }
+        else {
+            log.error(result.error || 'Unknown error');
+        }
+    }
+    else {
+        log.info(`Updating ${choice}...`);
+        const result = await marketplace_update_via_cli(choice);
+        if (result.success) {
+            log.success(`Marketplace updated: ${choice}`);
+        }
+        else {
+            log.error(result.error || 'Unknown error');
+        }
+    }
+    // Check if update restored any disabled hooks
+    const restored = await check_restored_hooks();
+    if (restored.length > 0) {
+        log.warn(`${restored.length} disabled hook(s) were restored by the update.`);
+        const should_redisable = await confirm({
+            message: 'Re-disable these hooks?',
+        });
+        if (!isCancel(should_redisable) && should_redisable) {
+            const redisable_result = await redisable_restored_hooks(restored);
+            if (redisable_result.success > 0) {
+                log.success(`Re-disabled ${redisable_result.success} hook(s).`);
+            }
+            if (redisable_result.failed > 0) {
+                log.error(`Failed to re-disable ${redisable_result.failed} hook(s).`);
+            }
+        }
+    }
+}
+export async function manage_marketplace() {
+    while (true) {
+        const action = await select({
+            message: 'Marketplace & plugins:',
+            options: [
+                {
+                    value: 'browse',
+                    label: 'Browse & install plugins',
+                    hint: 'Toggle plugins on/off across all marketplaces',
+                },
+                {
+                    value: 'add',
+                    label: 'Add marketplace',
+                    hint: 'Add a plugin catalog, then install plugins from it',
+                },
+                {
+                    value: 'remove',
+                    label: 'Remove marketplace',
+                    hint: 'Remove a marketplace and its plugins',
+                },
+                {
+                    value: 'update',
+                    label: 'Update marketplace(s)',
+                    hint: 'Pull latest from source',
+                },
+                {
+                    value: 'back',
+                    label: 'Back',
+                    hint: 'Return to main menu',
+                },
+            ],
+        });
+        if (isCancel(action) || action === 'back')
+            return;
+        try {
+            switch (action) {
+                case 'browse':
+                    await handle_browse();
+                    break;
+                case 'add':
+                    await handle_add();
+                    break;
+                case 'remove':
+                    await handle_remove();
+                    break;
+                case 'update':
+                    await handle_update();
+                    break;
+            }
+        }
+        catch (err) {
+            log.error(err instanceof Error ? err.message : 'Unknown error');
+        }
+    }
+}
+//# sourceMappingURL=manage-marketplace.js.map

package/dist/core/hook-state.js

@@ -0,0 +1,220 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ensure_directory_exists, get_disabled_hooks_path, get_marketplaces_dir, get_mcpick_dir, } from '../utils/paths.js';
+export 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, '\t'), '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 !== undefined && 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, '\t'), '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)]; // deduplicate
+}
+/**
+ * Disable a specific hook from a plugin.
+ * Removes from both cache and marketplace source hooks.json files.
+ */
+export async function disable_plugin_hook(entry) {
+    if (!entry.hooks_json_path || !entry.plugin_key) {
+        throw new Error('Not a plugin hook');
+    }
+    // Save to disabled state
+    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: new Date().toISOString(),
+    });
+    await write_disabled_hooks(disabled);
+    // Remove from all hooks.json files (cache + marketplace source)
+    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 || undefined) === matcher_pattern);
+    if (!matcher) {
+        matcher = { hooks: [] };
+        if (matcher_pattern)
+            matcher.matcher = matcher_pattern;
+        matchers.push(matcher);
+    }
+    // Only add if not already present (avoids duplicates)
+    const already_exists = matcher.hooks.some((h) => h.type === handler.type &&
+        h.command === handler.command &&
+        h.url === handler.url &&
+        h.prompt === handler.prompt);
+    if (already_exists)
+        return;
+    matcher.hooks.push(handler);
+    await writeFile(hooks_path, JSON.stringify(hooks_data, null, '\t'), 'utf-8');
+}
+/**
+ * Re-enable a previously disabled plugin hook.
+ * Restores to both cache and marketplace source hooks.json files.
+ */
+export 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);
+    }
+    // Remove from disabled state
+    const disabled = await read_disabled_hooks();
+    const updated = disabled.filter((d) => !(d.plugin_key === disabled_entry.plugin_key &&
+        d.event === disabled_entry.event &&
+        d.disabled_at === disabled_entry.disabled_at));
+    await write_disabled_hooks(updated);
+}
+/**
+ * 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.
+ */
+export 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 hooks_obj = (hooks_data.hooks || hooks_data);
+            const matchers = hooks_obj[entry.event];
+            if (!matchers)
+                continue;
+            for (const m of matchers) {
+                if ((m.matcher || undefined) !== entry.matcher)
+                    continue;
+                const has_match = 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));
+                if (has_match) {
+                    found = true;
+                    break;
+                }
+            }
+            if (found)
+                break;
+        }
+        if (found)
+            restored.push(entry);
+    }
+    return restored;
+}
+/**
+ * Re-disable hooks that were restored by a marketplace update.
+ */
+export 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) {
+                const removed = await remove_hook_from_file(hooks_path, entry.event, entry.original_handler);
+                if (removed)
+                    any_removed = true;
+            }
+            if (any_removed) {
+                success++;
+            }
+            else {
+                failed++;
+            }
+        }
+        catch {
+            failed++;
+        }
+    }
+    return { success, failed };
+}
+//# sourceMappingURL=hook-state.js.map