mcpick 0.0.14 → 0.0.16

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # mcpick
 
+## 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
+
+- 0170ea0: Add local dev workflow: mcpick dev + cache link/unlink
+- 2161258: Fix marketplace refresh, cache clear, uninstall detection;
+  add marketplace commands
+
 ## 0.0.14
 
 ### 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/cache.js

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, link_local_plugin, list_linked_plugins, read_installed_plugins, refresh_all_marketplaces, unlink_local_plugin, } from '../../core/plugin-cache.js';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, link_local_plugin, list_linked_plugins, read_installed_plugins, refresh_all_marketplaces, scan_all_cache_keys, unlink_local_plugin, } from '../../core/plugin-cache.js';
 import { error, output } from '../output.js';
 const status = defineCommand({
     meta: {
@@ -65,7 +65,13 @@ const clear = defineCommand({
     },
     async run({ args }) {
         const installed = await read_installed_plugins();
-        const all_keys = Object.keys(installed.plugins);
+        const installed_keys = Object.keys(installed.plugins);
+        // When --all, also scan disk for marketplace-sourced caches
+        // not tracked in installed_plugins.json
+        const scanned_keys = args.all ? await scan_all_cache_keys() : [];
+        const all_keys = [
+            ...new Set([...installed_keys, ...scanned_keys]),
+        ];
         if (all_keys.length === 0) {
             if (args.json) {
                 output({ cleared: [], errors: [] }, true);
@@ -77,7 +83,8 @@ const clear = defineCommand({
         }
         let keys_to_clear;
         if (args.plugin) {
-            if (!installed.plugins[args.plugin]) {
+            if (!installed.plugins[args.plugin] &&
+                !scanned_keys.includes(args.plugin)) {
                 error(`Plugin '${args.plugin}' not found in cache. Run 'mcpick cache status' to see cached plugins.`);
             }
             keys_to_clear = [args.plugin];

package/dist/cli/commands/dev.js

@@ -36,9 +36,7 @@ const apply = defineCommand({
         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 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);
@@ -82,7 +80,8 @@ const restore = defineCommand({
                 output(result, true);
             }
             else {
-                if (result.restored.length === 0 && result.errors.length === 0) {
+                if (result.restored.length === 0 &&
+                    result.errors.length === 0) {
                     console.log('No dev overrides to restore.');
                 }
                 else {

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/marketplace.js

@@ -0,0 +1,203 @@
+import { defineCommand } from 'citty';
+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({
+    meta: {
+        name: 'list',
+        description: 'List configured marketplaces',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_list_via_cli();
+        if (!result.success) {
+            error(result.error || 'Unknown error');
+        }
+        if (args.json) {
+            // Try to parse CLI JSON output, fallback to raw
+            try {
+                const parsed = JSON.parse(result.stdout || '[]');
+                output(parsed, true);
+            }
+            catch {
+                output({ marketplaces: result.stdout }, true);
+            }
+        }
+        else {
+            console.log(result.stdout || 'No marketplaces configured.');
+        }
+    },
+});
+const add = defineCommand({
+    meta: {
+        name: 'add',
+        description: 'Add a plugin marketplace (a catalog of installable plugins)',
+    },
+    args: {
+        source: {
+            type: 'positional',
+            description: 'Marketplace source (GitHub repo, URL, or local path)',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        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,
+                success: result.success,
+                error: result.error,
+                available_plugins,
+            }, true);
+        }
+        else if (result.success) {
+            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',
+        description: 'Remove a marketplace',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Marketplace name to remove',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_remove_via_cli(args.name);
+        if (args.json) {
+            output({
+                removed: args.name,
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(`Marketplace removed: ${args.name}`);
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+const update = defineCommand({
+    meta: {
+        name: 'update',
+        description: 'Update marketplace(s) from source',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Marketplace name to update (omit to update all)',
+            required: false,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_update_via_cli(args.name || undefined);
+        if (args.json) {
+            output({
+                updated: args.name || 'all',
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(args.name
+                ? `Marketplace updated: ${args.name}`
+                : 'All marketplaces updated.');
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'marketplace',
+        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,
+        add,
+        remove,
+        update,
+    },
+});
+//# sourceMappingURL=marketplace.js.map

package/dist/cli/commands/plugins.js

@@ -1,6 +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: {
@@ -144,6 +145,25 @@ const uninstall = defineCommand({
     },
     async run({ args }) {
         const scope = args.scope;
+        // Check if this is a marketplace-managed plugin
+        const { marketplace } = parse_plugin_key(args.plugin);
+        const known = await read_known_marketplaces();
+        if (known[marketplace]) {
+            const msg = `'${args.plugin}' is managed by marketplace '${marketplace}'.\n` +
+                `To remove the marketplace: mcpick marketplace remove ${marketplace}\n` +
+                `Or via Claude CLI: claude plugin marketplace remove ${marketplace}`;
+            if (args.json) {
+                output({
+                    success: false,
+                    error: msg,
+                    marketplace_managed: true,
+                }, true);
+            }
+            else {
+                error(msg);
+            }
+            return;
+        }
         const result = await uninstall_plugin_via_cli(args.plugin, scope);
         if (args.json) {
             output(result, true);
@@ -192,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/reload.js

@@ -0,0 +1,36 @@
+import { defineCommand } from 'citty';
+import { output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'reload',
+        description: 'Reload plugins in Claude Code',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const info = {
+            supported: false,
+            message: 'Claude Code does not expose a programmatic reload API.',
+            instructions: [
+                'Run /reload-plugins inside an active Claude Code session',
+                'Or restart your Claude Code session to pick up changes',
+            ],
+        };
+        if (args.json) {
+            output(info, true);
+        }
+        else {
+            console.log(info.message);
+            console.log('\nTo reload plugins:');
+            for (const instruction of info.instructions) {
+                console.log(`  - ${instruction}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=reload.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,12 +10,17 @@ 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),
         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),
+        reload: () => import('./commands/reload.js').then((m) => m.default),
     },
 });
 export const run = () => runMain(main);

package/dist/commands/manage-marketplace.js

@@ -0,0 +1,275 @@
+import { confirm, isCancel, log, multiselect, note, select, text, } from '@clack/prompts';
+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');
+        }
+    }
+}
+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/dev-override.js

@@ -82,8 +82,7 @@ async function write_server_to_scope(name, server, scope) {
             if (!existing.mcpServers) {
                 existing.mcpServers = {};
             }
-            existing.mcpServers[name] =
-                server;
+            existing.mcpServers[name] = server;
             return existing;
         });
     }
@@ -100,7 +99,8 @@ async function write_server_to_scope(name, server, scope) {
             if (!projects[cwd].mcpServers) {
                 projects[cwd].mcpServers = {};
             }
-            projects[cwd].mcpServers[name] = server;
+            projects[cwd].mcpServers[name] =
+                server;
             return existing;
         });
     }

package/dist/core/plugin-cache.js

@@ -1,5 +1,5 @@
 import { exec } from 'node:child_process';
-import { lstat, readdir, readFile, readlink, rename, rm, symlink } from 'node:fs/promises';
+import { lstat, readdir, readFile, readlink, rename, rm, symlink, } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { atomic_json_write } from '../utils/atomic-write.js';
@@ -50,6 +50,51 @@ async function get_marketplace_head_sha(marketplace_path) {
         return null;
     }
 }
+/**
+ * Recover a marketplace clone stuck on a deleted branch.
+ * Resets the fetch refspec, fetches all branches, and checks out the default branch.
+ */
+async function recover_deleted_branch(dir) {
+    const q = JSON.stringify(dir);
+    try {
+        // Reset narrow refspec to fetch all branches
+        await execAsync(`git -C ${q} remote set-branches origin '*'`, {
+            timeout: 10_000,
+        });
+        await execAsync(`git -C ${q} fetch origin`, {
+            timeout: 30_000,
+        });
+        // Detect default branch
+        let default_branch = 'main';
+        try {
+            const { stdout } = await execAsync(`git -C ${q} symbolic-ref refs/remotes/origin/HEAD`, { timeout: 5_000 });
+            const match = stdout
+                .trim()
+                .match(/refs\/remotes\/origin\/(.+)/);
+            if (match)
+                default_branch = match[1];
+        }
+        catch {
+            // symbolic-ref not set — try main, then master
+            try {
+                await execAsync(`git -C ${q} rev-parse --verify origin/main`, { timeout: 5_000 });
+                default_branch = 'main';
+            }
+            catch {
+                default_branch = 'master';
+            }
+        }
+        await execAsync(`git -C ${q} checkout ${default_branch}`, {
+            timeout: 10_000,
+        });
+        await execAsync(`git -C ${q} reset --hard origin/${default_branch}`, { timeout: 10_000 });
+        return { recovered: true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        return { recovered: false, error: msg };
+    }
+}
 export async function refresh_marketplace(name, marketplace) {
     const dir = marketplace.installLocation;
     try {
@@ -58,9 +103,16 @@ export async function refresh_marketplace(name, marketplace) {
         });
         return { success: true };
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return { success: false, error: `${name}: ${message}` };
+    catch {
+        // Fast-forward failed — attempt recovery from deleted branch
+        const recovery = await recover_deleted_branch(dir);
+        if (recovery.recovered) {
+            return { success: true };
+        }
+        return {
+            success: false,
+            error: `${name}: recovery failed: ${recovery.error}`,
+        };
     }
 }
 export async function refresh_all_marketplaces() {
@@ -155,6 +207,42 @@ export async function get_cached_plugins_info() {
     }
     return results;
 }
+// --- Cache scanning ---
+/**
+ * Scan the cache directory on disk to find all plugin keys,
+ * including marketplace-sourced plugins not tracked in installed_plugins.json.
+ */
+export async function scan_all_cache_keys() {
+    const cache_dir = get_plugin_cache_dir();
+    const keys = [];
+    try {
+        const marketplaces = await readdir(cache_dir, {
+            withFileTypes: true,
+        });
+        for (const mkt of marketplaces) {
+            if (!mkt.isDirectory() && !mkt.isSymbolicLink())
+                continue;
+            const mkt_path = join(cache_dir, mkt.name);
+            try {
+                const plugins = await readdir(mkt_path, {
+                    withFileTypes: true,
+                });
+                for (const plugin of plugins) {
+                    if (!plugin.isDirectory() && !plugin.isSymbolicLink())
+                        continue;
+                    keys.push(`${plugin.name}@${mkt.name}`);
+                }
+            }
+            catch {
+                // Skip unreadable marketplace dirs
+            }
+        }
+    }
+    catch {
+        // Cache dir doesn't exist
+    }
+    return keys;
+}
 // --- Cache clearing ---
 function is_safe_cache_path(path) {
     const cache_dir = resolve(get_plugin_cache_dir());
@@ -377,7 +465,9 @@ export async function list_linked_plugins() {
     const cache_dir = get_plugin_cache_dir();
     const links = [];
     try {
-        const marketplaces = await readdir(cache_dir, { withFileTypes: true });
+        const marketplaces = await readdir(cache_dir, {
+            withFileTypes: true,
+        });
         for (const mkt of marketplaces) {
             if (!mkt.isDirectory() && !mkt.isSymbolicLink())
                 continue;

package/dist/index.js

@@ -5,6 +5,7 @@ import { backup_config } from './commands/backup.js';
 import { edit_config } from './commands/edit-config.js';
 import { edit_plugins } from './commands/edit-plugins.js';
 import { manage_cache } from './commands/manage-cache.js';
+import { manage_marketplace } from './commands/manage-marketplace.js';
 import { restore_config } from './commands/restore.js';
 import { write_claude_config } from './core/config.js';
 import { list_profiles, load_profile, save_profile, } from './core/profile.js';
@@ -178,6 +179,11 @@ async function main() {
                         label: 'Manage plugins',
                         hint: 'Toggle, install, uninstall, or update plugins',
                     },
+                    {
+                        value: 'manage-marketplace',
+                        label: 'Manage marketplaces',
+                        hint: 'Add, remove, or update plugin marketplaces',
+                    },
                     {
                         value: 'manage-cache',
                         label: 'Manage plugin cache',
@@ -226,6 +232,9 @@ async function main() {
                 case 'edit-plugins':
                     await edit_plugins();
                     break;
+                case 'manage-marketplace':
+                    await manage_marketplace();
+                    break;
                 case 'manage-cache':
                     await manage_cache();
                     break;
@@ -276,12 +285,17 @@ const SUBCOMMANDS = new Set([
     'disable',
     'remove',
     'add',
+    'add-json',
+    'get',
+    'reset-project-choices',
     'backup',
     'restore',
     'profile',
     'plugins',
     'cache',
     'dev',
+    'marketplace',
+    'reload',
 ]);
 const arg = process.argv[2];
 if ((arg && SUBCOMMANDS.has(arg)) ||

package/dist/utils/claude-cli.js

@@ -189,6 +189,170 @@ export async function update_plugin_via_cli(key, scope = 'user') {
         };
     }
 }
+/**
+ * Add a marketplace via Claude CLI
+ */
+/**
+ * Extract GitHub owner/repo from various source formats.
+ * Returns null if not a recognizable GitHub reference.
+ */
+function parse_github_repo(source) {
+    // HTTPS URL: https://github.com/owner/repo[.git]
+    const https_match = source.match(/^https?:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (https_match)
+        return { owner: https_match[1], repo: https_match[2] };
+    // SSH URL: git@github.com:owner/repo[.git]
+    const ssh_match = source.match(/^git@github\.com:([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (ssh_match)
+        return { owner: ssh_match[1], repo: ssh_match[2] };
+    // Shorthand: owner/repo (no slashes beyond the one separator)
+    const shorthand_match = source.match(/^([^/\s]+)\/([^/\s]+)$/);
+    if (shorthand_match)
+        return { owner: shorthand_match[1], repo: shorthand_match[2] };
+    return null;
+}
+/**
+ * Validate that a GitHub repository exists and is accessible.
+ * Returns an error message if validation fails, null if OK.
+ */
+async function validate_github_repo(owner, repo) {
+    try {
+        const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+            method: 'GET',
+            headers: { Accept: 'application/vnd.github.v3+json' },
+        });
+        if (response.status === 200)
+            return null;
+        if (response.status === 404) {
+            return `Repository '${owner}/${repo}' not found on GitHub. Check the name or ensure it's not private.`;
+        }
+        if (response.status === 403) {
+            return `Access denied for '${owner}/${repo}'. The repository may be private — configure a GitHub token or use SSH.`;
+        }
+        return `GitHub API returned status ${response.status} for '${owner}/${repo}'.`;
+    }
+    catch {
+        // Network error — skip validation and let the CLI attempt the clone
+        return null;
+    }
+}
+export async function marketplace_add_via_cli(source) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    // Validate GitHub repo exists before attempting clone
+    // Only validate shorthand (owner/repo) — explicit URLs imply the user knows the repo
+    const gh = parse_github_repo(source);
+    const is_shorthand = gh && !source.startsWith('http') && !source.startsWith('git@');
+    if (gh && is_shorthand) {
+        const validation_error = await validate_github_repo(gh.owner, gh.repo);
+        if (validation_error) {
+            return { success: false, error: validation_error };
+        }
+    }
+    try {
+        await execAsync(`claude plugin marketplace add ${shell_escape(source)}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        // Provide clearer error messages for common failures
+        if (message.includes('SSH') ||
+            message.includes('Permission denied (publickey)')) {
+            return {
+                success: false,
+                error: `SSH authentication failed for '${source}'. Either:\n  - Configure SSH keys: https://docs.github.com/en/authentication/connecting-to-github-with-ssh\n  - Use HTTPS URL instead: https://github.com/${gh ? `${gh.owner}/${gh.repo}` : source}`,
+            };
+        }
+        if (message.includes('not found') ||
+            message.includes('does not exist')) {
+            return {
+                success: false,
+                error: `Repository '${source}' not found. Check the name and your access permissions.`,
+            };
+        }
+        return {
+            success: false,
+            error: `Failed to add marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * Remove a marketplace via Claude CLI
+ */
+export async function marketplace_remove_via_cli(name) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync(`claude plugin marketplace remove ${shell_escape(name)}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to remove marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * Update marketplace(s) via Claude CLI
+ */
+export async function marketplace_update_via_cli(name) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const cmd = name
+            ? `claude plugin marketplace update ${shell_escape(name)}`
+            : 'claude plugin marketplace update';
+        await execAsync(cmd);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to update marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * List marketplaces via Claude CLI
+ */
+export async function marketplace_list_via_cli() {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const { stdout } = await execAsync('claude plugin marketplace list');
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to list marketplaces: ${message}`,
+        };
+    }
+}
 /**
  * Get the scope description for display
  */
@@ -202,6 +366,98 @@ export function get_scope_description(scope) {
             return 'Global - all projects';
     }
 }
+/**
+ * Validate a plugin or marketplace manifest via Claude CLI
+ */
+export async function validate_plugin_via_cli(path) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const { stdout } = await execAsync(`claude plugin validate ${shell_escape(path)}`);
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Validation failed: ${message}`,
+        };
+    }
+}
+/**
+ * Get details about an MCP server via Claude CLI
+ */
+export async function mcp_get_via_cli(name) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const { stdout } = await execAsync(`claude mcp get ${shell_escape(name)}`);
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to get server details: ${message}`,
+        };
+    }
+}
+/**
+ * Add an MCP server from raw JSON via Claude CLI
+ */
+export async function mcp_add_json_via_cli(name, json, scope = 'local') {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync(`claude mcp add-json ${shell_escape(name)} ${shell_escape(json)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to add server from JSON: ${message}`,
+        };
+    }
+}
+/**
+ * Reset project-scoped MCP server choices via Claude CLI
+ */
+export async function mcp_reset_project_choices_via_cli() {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync('claude mcp reset-project-choices');
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to reset project choices: ${message}`,
+        };
+    }
+}
 /**
  * Get scope options for select prompt
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpick",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Dynamic MCP server and plugin configuration manager for Claude Code",
   "type": "module",
   "main": "./dist/index.js",