mcpick 0.0.15 → 0.0.16

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # 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

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

@@ -1,4 +1,5 @@
 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({
@@ -36,7 +37,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 +45,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 +52,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',
@@ -150,7 +191,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,6 +10,9 @@ 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),

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/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,6 +285,9 @@ const SUBCOMMANDS = new Set([
     'disable',
     'remove',
     'add',
+    'add-json',
+    'get',
+    'reset-project-choices',
     'backup',
     'restore',
     'profile',

package/dist/utils/claude-cli.js

@@ -192,7 +192,51 @@ export async function update_plugin_via_cli(key, scope = 'user') {
 /**
  * Add a marketplace via Claude CLI
  */
-export async function marketplace_add_via_cli(source, scope = 'user') {
+/**
+ * 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 {
@@ -200,12 +244,37 @@ export async function marketplace_add_via_cli(source, scope = 'user') {
             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)} --scope ${scope}`);
+        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}`,
@@ -297,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.15",
+  "version": "0.0.16",
   "description": "Dynamic MCP server and plugin configuration manager for Claude Code",
   "type": "module",
   "main": "./dist/index.js",