mcpick 0.0.18 → 0.0.19

package/dist/commands/add-server.js

@@ -1,310 +0,0 @@
-import { confirm, log, note, select, text } from '@clack/prompts';
-import { add_server_to_registry } from '../core/registry.js';
-import { validate_mcp_server } from '../core/validation.js';
-import { add_mcp_via_cli, check_claude_cli, get_scope_options, get_scope_description, } from '../utils/claude-cli.js';
-function format_server_details(server) {
-    const details = [`Name: ${server.name}`];
-    if ('command' in server) {
-        details.push(`Command: ${server.command} ${(server.args || []).join(' ')}`);
-    }
-    if ('url' in server) {
-        details.push(`URL: ${server.url}`);
-    }
-    details.push(`Description: ${server.description || 'None'}`);
-    if (server.type) {
-        details.push(`Transport: ${server.type}`);
-    }
-    if (server.env) {
-        details.push(`Environment: ${Object.keys(server.env).length} variables`);
-    }
-    if ('headers' in server && server.headers) {
-        details.push(`Headers: ${Object.keys(server.headers).length} headers`);
-    }
-    return details;
-}
-export async function add_server() {
-    try {
-        // Check if Claude CLI is available
-        const cli_available = await check_claude_cli();
-        // First, ask where to install the server (scope)
-        const scope = await select({
-            message: 'Where should this server be installed?',
-            options: get_scope_options(),
-            initialValue: 'local',
-        });
-        if (typeof scope === 'symbol')
-            return;
-        // Then ask how they want to configure the server
-        const config_method = await select({
-            message: 'How would you like to add the server?',
-            options: [
-                {
-                    value: 'json',
-                    label: 'Paste JSON configuration',
-                    hint: 'Paste complete server config as JSON',
-                },
-                {
-                    value: 'form',
-                    label: 'Step-by-step form',
-                    hint: 'Fill out fields one by one',
-                },
-            ],
-            initialValue: 'json',
-        });
-        if (typeof config_method === 'symbol')
-            return;
-        if (config_method === 'json') {
-            return await add_server_from_json(scope, cli_available);
-        }
-        const name = await text({
-            message: 'Server name:',
-            placeholder: 'e.g., mcp-sqlite-tools',
-            validate: (value) => {
-                if (!value || value.trim().length === 0) {
-                    return 'Server name is required';
-                }
-                return undefined;
-            },
-        });
-        if (typeof name === 'symbol')
-            return;
-        const command = await text({
-            message: 'Command to run:',
-            placeholder: 'e.g., uvx, npx, node',
-            validate: (value) => {
-                if (!value || value.trim().length === 0) {
-                    return 'Command is required';
-                }
-                return undefined;
-            },
-        });
-        if (typeof command === 'symbol')
-            return;
-        const args_input = await text({
-            message: 'Arguments (comma-separated):',
-            placeholder: 'e.g., mcp-sqlite-tools, --port, 3000',
-            defaultValue: '',
-        });
-        if (typeof args_input === 'symbol')
-            return;
-        const args = args_input
-            .split(',')
-            .map((arg) => arg.trim())
-            .filter((arg) => arg.length > 0);
-        const description = await text({
-            message: 'Description (optional):',
-            placeholder: 'Brief description of what this server provides',
-        });
-        if (typeof description === 'symbol')
-            return;
-        // Advanced configuration
-        const configure_advanced = await confirm({
-            message: 'Configure advanced settings (env variables, transport, etc.)?',
-            initialValue: false,
-        });
-        if (typeof configure_advanced === 'symbol')
-            return;
-        let server_data = {
-            name: name.trim(),
-            type: 'stdio',
-            command: command.trim(),
-            args,
-            ...(description &&
-                description.trim() && { description: description.trim() }),
-        };
-        if (configure_advanced) {
-            // Transport type
-            const transport_type = await select({
-                message: 'Transport type:',
-                options: [
-                    {
-                        value: 'stdio',
-                        label: 'stdio (default)',
-                        hint: 'Standard input/output',
-                    },
-                    { value: 'sse', label: 'sse', hint: 'Server-sent events' },
-                    { value: 'http', label: 'http', hint: 'HTTP transport' },
-                ],
-                initialValue: 'stdio',
-            });
-            if (typeof transport_type === 'symbol')
-                return;
-            server_data.type = transport_type;
-            // URL for non-stdio transports
-            if (transport_type === 'sse' || transport_type === 'http') {
-                // Remove stdio-specific fields
-                delete server_data.command;
-                delete server_data.args;
-                const url = await text({
-                    message: 'Server URL:',
-                    placeholder: 'e.g., http://localhost:3000',
-                    validate: (value) => {
-                        if (!value || value.trim().length === 0) {
-                            return 'URL is required for non-stdio transport';
-                        }
-                        return undefined;
-                    },
-                });
-                if (typeof url === 'symbol')
-                    return;
-                server_data.url = url.trim();
-            }
-            // Environment variables
-            const env_input = await text({
-                message: 'Environment variables (KEY=value, comma-separated):',
-                placeholder: 'e.g., API_KEY=abc123, TIMEOUT=30',
-            });
-            if (typeof env_input === 'symbol')
-                return;
-            if (env_input && env_input.trim()) {
-                const env = {};
-                env_input.split(',').forEach((pair) => {
-                    const [key, ...valueParts] = pair.split('=');
-                    if (key && valueParts.length > 0) {
-                        env[key.trim()] = valueParts.join('=').trim();
-                    }
-                });
-                if (Object.keys(env).length > 0) {
-                    server_data.env = env;
-                }
-            }
-            // Headers for HTTP transport
-            if (transport_type === 'http') {
-                const headers_input = await text({
-                    message: 'HTTP headers (KEY=value, comma-separated):',
-                    placeholder: 'e.g., Authorization=Bearer token, Content-Type=application/json',
-                });
-                if (typeof headers_input === 'symbol')
-                    return;
-                if (headers_input && headers_input.trim()) {
-                    const headers = {};
-                    headers_input.split(',').forEach((pair) => {
-                        const [key, ...valueParts] = pair.split('=');
-                        if (key && valueParts.length > 0) {
-                            headers[key.trim()] = valueParts.join('=').trim();
-                        }
-                    });
-                    if (Object.keys(headers).length > 0) {
-                        server_data.headers = headers;
-                    }
-                }
-            }
-        }
-        const validated_server = validate_mcp_server(server_data);
-        const details = format_server_details(validated_server);
-        details.push(`Scope: ${get_scope_description(scope)}`);
-        note(`Server to add:\n${details.join('\n')}`);
-        const should_add = await confirm({
-            message: 'Add this server?',
-        });
-        if (typeof should_add === 'symbol' || !should_add) {
-            return;
-        }
-        // Always add to registry for profile/backup management
-        await add_server_to_registry(validated_server);
-        // Install via Claude CLI if available
-        if (cli_available) {
-            const result = await add_mcp_via_cli(validated_server, scope);
-            if (result.success) {
-                note(`Server "${validated_server.name}" installed successfully!\n` +
-                    `Scope: ${get_scope_description(scope)}\n` +
-                    `Also added to mcpick registry for profile management.`);
-            }
-            else {
-                log.warn(`CLI installation failed: ${result.error}\n` +
-                    `Server added to registry only. Use 'claude mcp add' manually.`);
-            }
-        }
-        else {
-            log.warn(`Claude CLI not found. Server added to registry only.\n` +
-                `Install Claude Code CLI and run 'claude mcp add' to activate.`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to add server: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function add_server_from_json(scope, cli_available) {
-    const json_input = await text({
-        message: 'Paste JSON configuration:',
-        placeholder: '{ "name": "mcp-sqlite-tools", "command": "npx", "args": ["-y", "mcp-sqlite-tools"] }',
-        validate: (value) => {
-            if (!value || value.trim().length === 0) {
-                return 'JSON configuration is required';
-            }
-            let jsonString = value.trim();
-            // If it doesn't start with {, wrap it in braces
-            if (!jsonString.startsWith('{')) {
-                jsonString = `{${jsonString}}`;
-            }
-            try {
-                const parsed = JSON.parse(jsonString);
-                if (typeof parsed !== 'object' || parsed === null) {
-                    return 'JSON must be an object';
-                }
-                if (!parsed.command) {
-                    return 'Server configuration must include a "command" field';
-                }
-            }
-            catch (error) {
-                return 'Invalid JSON format';
-            }
-            return undefined;
-        },
-    });
-    if (typeof json_input === 'symbol')
-        return;
-    try {
-        let jsonString = json_input.trim();
-        // If it doesn't start with {, wrap it in braces
-        if (!jsonString.startsWith('{')) {
-            jsonString = `{${jsonString}}`;
-        }
-        const parsed = JSON.parse(jsonString);
-        const server_data = parsed;
-        // Normalize the data to match schema expectations
-        if (!server_data.type && server_data.command) {
-            server_data.type = 'stdio';
-        }
-        if (server_data.type !== 'stdio') {
-            delete server_data.command;
-            delete server_data.args;
-        }
-        if (server_data.command && !server_data.args) {
-            server_data.args = [];
-        }
-        const validated_server = validate_mcp_server(server_data);
-        const details = format_server_details(validated_server);
-        details.push(`Scope: ${get_scope_description(scope)}`);
-        note(`Server to add:\n${details.join('\n')}`);
-        const should_add = await confirm({
-            message: 'Add this server?',
-        });
-        if (typeof should_add === 'symbol' || !should_add) {
-            return;
-        }
-        // Always add to registry for profile/backup management
-        await add_server_to_registry(validated_server);
-        // Install via Claude CLI if available
-        if (cli_available) {
-            const result = await add_mcp_via_cli(validated_server, scope);
-            if (result.success) {
-                note(`Server "${validated_server.name}" installed successfully!\n` +
-                    `Scope: ${get_scope_description(scope)}\n` +
-                    `Also added to mcpick registry for profile management.`);
-            }
-            else {
-                log.warn(`CLI installation failed: ${result.error}\n` +
-                    `Server added to registry only. Use 'claude mcp add' manually.`);
-            }
-        }
-        else {
-            log.warn(`Claude CLI not found. Server added to registry only.\n` +
-                `Install Claude Code CLI and run 'claude mcp add' to activate.`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to parse or validate JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-//# sourceMappingURL=add-server.js.map

package/dist/commands/backup.js

@@ -1,60 +0,0 @@
-import { note } from '@clack/prompts';
-import { readdir, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { read_claude_config } from '../core/config.js';
-import { read_claude_settings } from '../core/settings.js';
-import { ensure_directory_exists, get_backup_filename, get_backups_dir, get_plugin_backup_filename, } from '../utils/paths.js';
-const MAX_BACKUPS = 10;
-export async function backup_config() {
-    try {
-        const current_config = await read_claude_config();
-        const current_settings = await read_claude_settings();
-        const backups_dir = get_backups_dir();
-        await ensure_directory_exists(backups_dir);
-        // Backup MCP servers
-        const mcp_filename = get_backup_filename();
-        const mcp_path = join(backups_dir, mcp_filename);
-        const mcp_backup = {
-            mcpServers: current_config.mcpServers || {},
-        };
-        await writeFile(mcp_path, JSON.stringify(mcp_backup, null, 2), 'utf-8');
-        // Backup plugins
-        const plugins = current_settings.enabledPlugins || {};
-        const plugin_count = Object.keys(plugins).length;
-        let plugin_msg = '';
-        if (plugin_count > 0) {
-            const plugin_filename = get_plugin_backup_filename();
-            const plugin_path = join(backups_dir, plugin_filename);
-            const plugin_backup = { enabledPlugins: plugins };
-            await writeFile(plugin_path, JSON.stringify(plugin_backup, null, 2), 'utf-8');
-            plugin_msg = `\nPlugins backup: ${plugin_path}\n(${plugin_count} plugins backed up)`;
-        }
-        await cleanup_old_backups('mcp-servers-');
-        await cleanup_old_backups('plugins-');
-        const server_count = Object.keys(current_config.mcpServers || {}).length;
-        note(`MCP servers backup: ${mcp_path}\n(${server_count} servers backed up)${plugin_msg}`);
-    }
-    catch (error) {
-        throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function cleanup_old_backups(prefix) {
-    try {
-        const backups_dir = get_backups_dir();
-        const files = await readdir(backups_dir);
-        const backup_files = files
-            .filter((file) => file.startsWith(prefix) && file.endsWith('.json'))
-            .sort()
-            .reverse();
-        if (backup_files.length > MAX_BACKUPS) {
-            const files_to_delete = backup_files.slice(MAX_BACKUPS);
-            for (const file of files_to_delete) {
-                await unlink(join(backups_dir, file));
-            }
-        }
-    }
-    catch {
-        // Cleanup is best-effort
-    }
-}
-//# sourceMappingURL=backup.js.map

package/dist/commands/edit-config.js

@@ -1,109 +0,0 @@
-import { log, multiselect, note, select } from '@clack/prompts';
-import { create_config_from_servers, get_enabled_servers, get_enabled_servers_for_scope, read_claude_config, write_claude_config, } from '../core/config.js';
-import { get_all_available_servers, sync_servers_to_registry, } from '../core/registry.js';
-import { add_mcp_via_cli, check_claude_cli, get_scope_description, get_scope_options, remove_mcp_via_cli, } from '../utils/claude-cli.js';
-export async function edit_config() {
-    try {
-        // Check if Claude CLI is available
-        const cli_available = await check_claude_cli();
-        // Ask which scope to edit
-        const scope = await select({
-            message: 'Which configuration do you want to edit?',
-            options: get_scope_options(),
-            initialValue: 'local',
-        });
-        if (typeof scope === 'symbol')
-            return;
-        const current_config = await read_claude_config();
-        // If registry is empty but .claude.json has servers, populate registry from config
-        let all_servers = await get_all_available_servers();
-        if (all_servers.length === 0 && current_config.mcpServers) {
-            const current_servers = get_enabled_servers(current_config);
-            if (current_servers.length > 0) {
-                await sync_servers_to_registry(current_servers);
-                all_servers = current_servers;
-                note(`Imported ${current_servers.length} servers from your .claude.json file into registry.`);
-            }
-        }
-        if (all_servers.length === 0) {
-            note('No MCP servers found in .claude.json or registry. Add servers first.');
-            return;
-        }
-        // Get currently enabled servers for the selected scope
-        const currently_enabled = await get_enabled_servers_for_scope(scope);
-        const server_choices = all_servers.map((server) => ({
-            value: server.name,
-            label: server.name,
-            hint: server.description || '',
-        }));
-        const selected_server_names = await multiselect({
-            message: `Select MCP servers for ${get_scope_description(scope)}:`,
-            options: server_choices,
-            initialValues: currently_enabled,
-            required: false,
-        });
-        if (typeof selected_server_names === 'symbol') {
-            return;
-        }
-        const selected_servers = all_servers.filter((server) => selected_server_names.includes(server.name));
-        // Determine which servers to add and remove
-        const servers_to_add = selected_server_names.filter((name) => !currently_enabled.includes(name));
-        const servers_to_remove = currently_enabled.filter((name) => !selected_server_names.includes(name));
-        // If CLI is available, use it for add/remove operations
-        if (cli_available && (scope === 'local' || scope === 'project')) {
-            let success_count = 0;
-            let error_count = 0;
-            // Add new servers
-            for (const name of servers_to_add) {
-                const server = all_servers.find((s) => s.name === name);
-                if (server) {
-                    const result = await add_mcp_via_cli(server, scope);
-                    if (result.success) {
-                        success_count++;
-                    }
-                    else {
-                        error_count++;
-                        log.warn(`Failed to add ${name}: ${result.error}`);
-                    }
-                }
-            }
-            // Remove servers
-            for (const name of servers_to_remove) {
-                const result = await remove_mcp_via_cli(name);
-                if (result.success) {
-                    success_count++;
-                }
-                else {
-                    error_count++;
-                    log.warn(`Failed to remove ${name}: ${result.error}`);
-                }
-            }
-            await sync_servers_to_registry(selected_servers);
-            if (error_count > 0) {
-                note(`Configuration updated with ${error_count} errors.\n` +
-                    `Scope: ${get_scope_description(scope)}\n` +
-                    `Added: ${servers_to_add.length}, Removed: ${servers_to_remove.length}`);
-            }
-            else {
-                note(`Configuration updated!\n` +
-                    `Scope: ${get_scope_description(scope)}\n` +
-                    `Enabled servers: ${selected_servers.length}`);
-            }
-        }
-        else {
-            // Fallback to direct file writing (user scope or no CLI)
-            const new_config = create_config_from_servers(selected_servers);
-            await write_claude_config(new_config);
-            await sync_servers_to_registry(selected_servers);
-            if (!cli_available && scope !== 'user') {
-                log.warn(`Claude CLI not available. Changes written to ~/.claude.json (user scope) instead of ${scope} scope.`);
-            }
-            note(`Configuration updated!\n` +
-                `Enabled servers: ${selected_servers.length}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to edit configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-//# sourceMappingURL=edit-config.js.map

package/dist/commands/edit-plugins.js

@@ -1,201 +0,0 @@
-import { confirm, isCancel, log, multiselect, note, select, text, } from '@clack/prompts';
-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';
-async function handle_toggle() {
-    const settings = await read_claude_settings();
-    const plugins = get_all_plugins(settings);
-    if (plugins.length === 0) {
-        note('No plugins found in ~/.claude/settings.json.\n' +
-            'Install plugins via Claude Code: /plugin');
-        return;
-    }
-    const plugin_choices = plugins.map((plugin) => ({
-        value: `${plugin.name}@${plugin.marketplace}`,
-        label: plugin.name,
-        hint: plugin.marketplace,
-    }));
-    const currently_enabled = plugins
-        .filter((p) => p.enabled)
-        .map((p) => `${p.name}@${p.marketplace}`);
-    const selected = await multiselect({
-        message: 'Select plugins to enable:',
-        options: plugin_choices,
-        initialValues: currently_enabled,
-        required: false,
-    });
-    if (typeof selected === 'symbol')
-        return;
-    const selected_set = new Set(selected);
-    const updated_plugins = plugins.map((plugin) => ({
-        ...plugin,
-        enabled: selected_set.has(`${plugin.name}@${plugin.marketplace}`),
-    }));
-    const enabled_plugins = build_enabled_plugins(updated_plugins);
-    await write_claude_settings({ enabledPlugins: enabled_plugins });
-    const enabled_count = updated_plugins.filter((p) => p.enabled).length;
-    const disabled_count = updated_plugins.filter((p) => !p.enabled).length;
-    note(`Plugins updated!\n` +
-        `Enabled: ${enabled_count}, Disabled: ${disabled_count}`);
-    const newly_enabled = updated_plugins.filter((p) => p.enabled &&
-        !currently_enabled.includes(`${p.name}@${p.marketplace}`));
-    const newly_disabled = updated_plugins.filter((p) => !p.enabled &&
-        currently_enabled.includes(`${p.name}@${p.marketplace}`));
-    if (newly_enabled.length > 0) {
-        log.success(`Enabled: ${newly_enabled.map((p) => p.name).join(', ')}`);
-    }
-    if (newly_disabled.length > 0) {
-        log.warn(`Disabled: ${newly_disabled.map((p) => p.name).join(', ')}`);
-    }
-}
-async function handle_install() {
-    const key = await text({
-        message: 'Plugin to install (name@marketplace):',
-        placeholder: 'e.g. commit-commands@claude-plugins-official',
-        validate: (value) => {
-            if (!value || value.trim().length === 0) {
-                return 'Plugin key is required';
-            }
-            if (!value.includes('@')) {
-                return 'Format: plugin-name@marketplace-name';
-            }
-        },
-    });
-    if (isCancel(key))
-        return;
-    const scope = await select({
-        message: 'Installation scope:',
-        options: [
-            { value: 'user', label: 'User', hint: 'Global (default)' },
-            {
-                value: 'project',
-                label: 'Project',
-                hint: 'Shared with team',
-            },
-            {
-                value: 'local',
-                label: 'Local',
-                hint: 'This project only (gitignored)',
-            },
-        ],
-    });
-    if (isCancel(scope))
-        return;
-    const result = await install_plugin_via_cli(key, scope);
-    if (result.success) {
-        log.success(`Installed '${key}' (scope: ${scope})`);
-    }
-    else {
-        log.error(result.error ?? 'Unknown error');
-    }
-}
-async function handle_uninstall() {
-    const settings = await read_claude_settings();
-    const plugins = get_all_plugins(settings);
-    if (plugins.length === 0) {
-        log.info('No plugins installed.');
-        return;
-    }
-    const selected = await select({
-        message: 'Select plugin to uninstall:',
-        options: plugins.map((p) => ({
-            value: `${p.name}@${p.marketplace}`,
-            label: p.name,
-            hint: p.marketplace,
-        })),
-    });
-    if (isCancel(selected))
-        return;
-    const should_uninstall = await confirm({
-        message: `Uninstall '${selected}'?`,
-    });
-    if (isCancel(should_uninstall) || !should_uninstall)
-        return;
-    const result = await uninstall_plugin_via_cli(selected);
-    if (result.success) {
-        log.success(`Uninstalled '${selected}'`);
-    }
-    else {
-        log.error(result.error ?? 'Unknown error');
-    }
-}
-async function handle_update() {
-    const settings = await read_claude_settings();
-    const plugins = get_all_plugins(settings);
-    if (plugins.length === 0) {
-        log.info('No plugins installed.');
-        return;
-    }
-    const selected = await select({
-        message: 'Select plugin to update:',
-        options: plugins.map((p) => ({
-            value: `${p.name}@${p.marketplace}`,
-            label: p.name,
-            hint: p.marketplace,
-        })),
-    });
-    if (isCancel(selected))
-        return;
-    const result = await update_plugin_via_cli(selected);
-    if (result.success) {
-        log.success(`Updated '${selected}'`);
-    }
-    else {
-        log.error(result.error ?? 'Unknown error');
-    }
-}
-export async function edit_plugins() {
-    while (true) {
-        const action = await select({
-            message: 'Plugin management:',
-            options: [
-                {
-                    value: 'toggle',
-                    label: 'Enable / Disable plugins',
-                    hint: 'Toggle plugins on/off',
-                },
-                {
-                    value: 'install',
-                    label: 'Install plugin',
-                    hint: 'Install from a marketplace',
-                },
-                {
-                    value: 'uninstall',
-                    label: 'Uninstall plugin',
-                    hint: 'Remove a plugin entirely',
-                },
-                {
-                    value: 'update',
-                    label: 'Update plugin',
-                    hint: 'Update to latest version',
-                },
-                {
-                    value: 'back',
-                    label: 'Back',
-                    hint: 'Return to main menu',
-                },
-            ],
-        });
-        if (isCancel(action) || action === 'back')
-            return;
-        try {
-            switch (action) {
-                case 'toggle':
-                    await handle_toggle();
-                    break;
-                case 'install':
-                    await handle_install();
-                    break;
-                case 'uninstall':
-                    await handle_uninstall();
-                    break;
-                case 'update':
-                    await handle_update();
-                    break;
-            }
-        }
-        catch (err) {
-            log.error(err instanceof Error ? err.message : 'Unknown error');
-        }
-    }
-}
-//# sourceMappingURL=edit-plugins.js.map