mcpick 0.0.15 → 0.0.17

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # mcpick
 
+## 0.0.17
+
+### Patch Changes
+
+- 54fe401: feat: plugin hook management with per-hook disable/enable
+  and update guard
+
+## 0.0.16
+
+### Patch Changes
+
+- b671135: fix: validate marketplace repos upfront, remove unsupported
+  --scope flag
+- fed8311: feat: TUI marketplace management, plugin browse, CLI parity
+  commands
+
 ## 0.0.15
 
 ### Patch Changes

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

@@ -0,0 +1,60 @@
+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/get.js

@@ -0,0 +1,45 @@
+import { defineCommand } from 'citty';
+import { mcp_get_via_cli } from '../../utils/claude-cli.js';
+import { error, output } from '../output.js';
+export 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 {
+                const parsed = JSON.parse(result.stdout || '{}');
+                output(parsed, 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');
+        }
+    },
+});
+//# sourceMappingURL=get.js.map

package/dist/cli/commands/hooks.js

@@ -0,0 +1,314 @@
+import { defineCommand } from 'citty';
+import { check_restored_hooks, disable_plugin_hook, enable_plugin_hook, read_disabled_hooks, redisable_restored_hooks, } from '../../core/hook-state.js';
+import { add_hook, get_all_hooks, remove_hook, } from '../../core/settings.js';
+import { error, output } from '../output.js';
+const 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}`);
+                }
+            }
+        }
+    },
+});
+const 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 {
+            // Settings hook — remove it
+            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})`);
+            }
+        }
+    },
+});
+const 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.');
+        }
+    },
+});
+const 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 || undefined, 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})`);
+        }
+    },
+});
+const 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 hooks = await get_all_hooks();
+        const settings_hooks = 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}`);
+        }
+    },
+});
+const 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".');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'hooks',
+        description: 'Manage hooks (settings + plugin). Disable individual plugin hooks, add/remove settings hooks.',
+    },
+    subCommands: { list, disable, enable, add, remove, check },
+});
+//# sourceMappingURL=hooks.js.map

package/dist/cli/commands/marketplace.js

@@ -1,4 +1,6 @@
 import { defineCommand } from 'citty';
+import { check_restored_hooks, redisable_restored_hooks, } from '../../core/hook-state.js';
+import { read_marketplace_manifest } from '../../core/plugin-cache.js';
 import { marketplace_add_via_cli, marketplace_list_via_cli, marketplace_remove_via_cli, marketplace_update_via_cli, } from '../../utils/claude-cli.js';
 import { error, output } from '../output.js';
 const list = defineCommand({
@@ -36,7 +38,7 @@ const list = defineCommand({
 const add = defineCommand({
     meta: {
         name: 'add',
-        description: 'Add a marketplace from URL, path, or GitHub repo',
+        description: 'Add a plugin marketplace (a catalog of installable plugins)',
     },
     args: {
         source: {
@@ -44,11 +46,6 @@ const add = defineCommand({
             description: 'Marketplace source (GitHub repo, URL, or local path)',
             required: true,
         },
-        scope: {
-            type: 'string',
-            description: 'Scope: user, project, or local (default: user)',
-            default: 'user',
-        },
         json: {
             type: 'boolean',
             description: 'Output as JSON',
@@ -56,27 +53,72 @@ const add = defineCommand({
         },
     },
     async run({ args }) {
-        const scope = args.scope;
-        if (!['user', 'project', 'local'].includes(scope)) {
-            error(`Invalid scope: ${scope}. Use user, project, or local.`);
-        }
-        const result = await marketplace_add_via_cli(args.source, scope);
+        const result = await marketplace_add_via_cli(args.source);
         if (args.json) {
+            // Try to include available plugins in JSON output
+            let available_plugins = [];
+            if (result.success) {
+                const manifests = await find_marketplace_plugins(args.source);
+                available_plugins = manifests;
+            }
             output({
                 added: args.source,
-                scope,
                 success: result.success,
                 error: result.error,
+                available_plugins,
             }, true);
         }
         else if (result.success) {
-            console.log(`Marketplace added: ${args.source} (scope: ${scope})`);
+            console.log(`Marketplace added: ${args.source}`);
+            await show_available_plugins(args.source);
         }
         else {
             error(result.error || 'Unknown error');
         }
     },
 });
+/**
+ * Try to find and display available plugins from a newly added marketplace.
+ * The marketplace name in the filesystem may differ from the source string,
+ * so we try common derivations.
+ */
+async function find_marketplace_plugins(source) {
+    // Try the source as-is, then extract repo name from various formats
+    const candidates = [];
+    // Extract repo name from owner/repo, URLs, etc.
+    const repo_match = source.match(/([^/]+?)(?:\.git)?$/);
+    if (repo_match) {
+        candidates.push(repo_match[1].toLowerCase());
+        candidates.push(repo_match[1]);
+    }
+    // Try the full source as a name
+    candidates.push(source);
+    for (const name of candidates) {
+        const manifest = await read_marketplace_manifest(name);
+        if (manifest?.plugins?.length) {
+            return manifest.plugins.map((p) => {
+                const desc = p.description
+                    ? ` - ${p.description}`
+                    : '';
+                return `${p.name}${desc}`;
+            });
+        }
+    }
+    return [];
+}
+async function show_available_plugins(source) {
+    const plugins = await find_marketplace_plugins(source);
+    if (plugins.length > 0) {
+        console.log(`\nAvailable plugins (${plugins.length}):`);
+        for (const p of plugins) {
+            console.log(`  - ${p}`);
+        }
+        console.log('\nInstall with: mcpick plugins install <name>@<marketplace>');
+    }
+    else {
+        console.log('\nTo browse and install plugins: mcpick plugins install <name>@<marketplace>');
+    }
+}
 const remove = defineCommand({
     meta: {
         name: 'remove',
@@ -141,6 +183,13 @@ const update = defineCommand({
             console.log(args.name
                 ? `Marketplace updated: ${args.name}`
                 : 'All marketplaces updated.');
+            // Check if update restored any disabled hooks
+            const restored = await check_restored_hooks();
+            if (restored.length > 0) {
+                console.log(`\nWarning: ${restored.length} disabled hook(s) were restored by the update.`);
+                const redisable_result = await redisable_restored_hooks(restored);
+                console.log(`Re-disabled ${redisable_result.success} hook(s).${redisable_result.failed > 0 ? ` Failed: ${redisable_result.failed}` : ''}`);
+            }
         }
         else {
             error(result.error || 'Unknown error');
@@ -150,7 +199,7 @@ const update = defineCommand({
 export default defineCommand({
     meta: {
         name: 'marketplace',
-        description: 'Manage Claude Code plugin marketplaces',
+        description: 'Manage plugin marketplaces (catalogs of installable plugins). Add a marketplace first, then install plugins from it with: mcpick plugins install <name>@<marketplace>',
     },
     subCommands: {
         list,

package/dist/cli/commands/plugins.js

@@ -1,7 +1,7 @@
 import { defineCommand } from 'citty';
 import { parse_plugin_key, read_known_marketplaces, } from '../../core/plugin-cache.js';
 import { build_enabled_plugins, get_all_plugins, read_claude_settings, write_claude_settings, } from '../../core/settings.js';
-import { install_plugin_via_cli, uninstall_plugin_via_cli, update_plugin_via_cli, } from '../../utils/claude-cli.js';
+import { install_plugin_via_cli, uninstall_plugin_via_cli, update_plugin_via_cli, validate_plugin_via_cli, } from '../../utils/claude-cli.js';
 import { error, output } from '../output.js';
 const list = defineCommand({
     meta: {
@@ -212,11 +212,54 @@ const update = defineCommand({
         }
     },
 });
+const validate = defineCommand({
+    meta: {
+        name: 'validate',
+        description: 'Validate a plugin or marketplace manifest',
+    },
+    args: {
+        path: {
+            type: 'positional',
+            description: 'Path to plugin or marketplace manifest',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await validate_plugin_via_cli(args.path);
+        if (args.json) {
+            output({
+                path: args.path,
+                valid: result.success,
+                output: result.stdout,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(result.stdout || 'Validation passed.');
+        }
+        else {
+            error(result.error || 'Validation failed');
+        }
+    },
+});
 export default defineCommand({
     meta: {
         name: 'plugins',
         description: 'Manage Claude Code plugins',
     },
-    subCommands: { list, enable, disable, install, uninstall, update },
+    subCommands: {
+        list,
+        enable,
+        disable,
+        install,
+        uninstall,
+        update,
+        validate,
+    },
 });
 //# sourceMappingURL=plugins.js.map

package/dist/cli/commands/reset-project-choices.js

@@ -0,0 +1,32 @@
+import { defineCommand } from 'citty';
+import { mcp_reset_project_choices_via_cli } from '../../utils/claude-cli.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'reset-project-choices',
+        description: 'Reset all approved and rejected project-scoped MCP servers',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await mcp_reset_project_choices_via_cli();
+        if (args.json) {
+            output({
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log('Project MCP server choices have been reset.');
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+//# sourceMappingURL=reset-project-choices.js.map

package/dist/cli/index.js

@@ -10,10 +10,14 @@ const main = defineCommand({
         disable: () => import('./commands/disable.js').then((m) => m.default),
         remove: () => import('./commands/remove.js').then((m) => m.default),
         add: () => import('./commands/add.js').then((m) => m.default),
+        'add-json': () => import('./commands/add-json.js').then((m) => m.default),
+        get: () => import('./commands/get.js').then((m) => m.default),
+        'reset-project-choices': () => import('./commands/reset-project-choices.js').then((m) => m.default),
         backup: () => import('./commands/backup.js').then((m) => m.default),
         restore: () => import('./commands/restore.js').then((m) => m.default),
         profile: () => import('./commands/profile.js').then((m) => m.default),
         plugins: () => import('./commands/plugins.js').then((m) => m.default),
+        hooks: () => import('./commands/hooks.js').then((m) => m.default),
         cache: () => import('./commands/cache.js').then((m) => m.default),
         dev: () => import('./commands/dev.js').then((m) => m.default),
         marketplace: () => import('./commands/marketplace.js').then((m) => m.default),