mcpick 0.0.8 → 0.0.10

package/dist/cli/commands/profile.js

@@ -0,0 +1,112 @@
+import { defineCommand } from 'citty';
+import { write_claude_config } from '../../core/config.js';
+import { list_profiles, load_profile, save_profile, } from '../../core/profile.js';
+import { error, output } from '../output.js';
+const list = defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all saved profiles',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const profiles = await list_profiles();
+        if (args.json) {
+            output(profiles, true);
+        }
+        else {
+            if (profiles.length === 0) {
+                console.log('No profiles found.');
+                return;
+            }
+            for (const p of profiles) {
+                console.log(`${p.name}  (${p.serverCount} servers)`);
+            }
+        }
+    },
+});
+const load = defineCommand({
+    meta: {
+        name: 'load',
+        description: 'Load and apply a saved profile',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Profile name',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        try {
+            const config = await load_profile(args.name);
+            await write_claude_config(config);
+            const server_count = Object.keys(config.mcpServers || {}).length;
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: server_count,
+                }, true);
+            }
+            else {
+                console.log(`Profile '${args.name}' applied (${server_count} servers)`);
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to load profile');
+        }
+    },
+});
+const save = defineCommand({
+    meta: {
+        name: 'save',
+        description: 'Save current config as a profile',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Profile name',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        try {
+            const server_count = await save_profile(args.name);
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: server_count,
+                }, true);
+            }
+            else {
+                console.log(`Profile '${args.name}' saved (${server_count} servers)`);
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to save profile');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'profile',
+        description: 'Manage MCP server profiles',
+    },
+    subCommands: { list, load, save },
+});
+//# sourceMappingURL=profile.js.map

package/dist/cli/commands/remove.js

@@ -0,0 +1,31 @@
+import { defineCommand } from 'citty';
+import { read_server_registry, write_server_registry, } from '../../core/registry.js';
+import { remove_mcp_via_cli } from '../../utils/claude-cli.js';
+import { error } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'remove',
+        description: 'Remove an MCP server from the registry and disable it',
+    },
+    args: {
+        server: {
+            type: 'positional',
+            description: 'Server name to remove',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const registry = await read_server_registry();
+        const index = registry.servers.findIndex((s) => s.name === args.server);
+        if (index < 0) {
+            error(`Server '${args.server}' not found in registry. Run 'mcpick list' to see available servers.`);
+        }
+        // Remove from registry
+        registry.servers.splice(index, 1);
+        await write_server_registry(registry);
+        // Also disable via CLI (best effort)
+        await remove_mcp_via_cli(args.server);
+        console.log(`Removed '${args.server}' from registry`);
+    },
+});
+//# sourceMappingURL=remove.js.map

package/dist/cli/commands/restore.js

@@ -0,0 +1,56 @@
+import { defineCommand } from 'citty';
+import { readFile } from 'node:fs/promises';
+import { write_claude_config } from '../../core/config.js';
+import { list_backups } from '../../core/registry.js';
+import { validate_claude_config } from '../../core/validation.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'restore',
+        description: 'Restore MCP server config from a backup (latest if no file specified)',
+    },
+    args: {
+        file: {
+            type: 'positional',
+            description: 'Backup filename or path (optional, defaults to latest)',
+            required: false,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const backups = await list_backups();
+        if (backups.length === 0) {
+            error('No backups found. Run "mcpick backup" first.');
+        }
+        let backup_path;
+        if (args.file) {
+            const found = backups.find((b) => b.filename === args.file || b.path === args.file);
+            if (!found) {
+                error(`Backup '${args.file}' not found. Available: ${backups.map((b) => b.filename).join(', ')}`);
+            }
+            backup_path = found.path;
+        }
+        else {
+            backup_path = backups[0].path;
+        }
+        const content = await readFile(backup_path, 'utf-8');
+        const parsed = JSON.parse(content);
+        const config = validate_claude_config(parsed);
+        await write_claude_config(config);
+        const server_count = Object.keys(config.mcpServers || {}).length;
+        if (args.json) {
+            output({
+                restored: backup_path,
+                servers: server_count,
+            }, true);
+        }
+        else {
+            console.log(`Restored from ${backup_path} (${server_count} servers)`);
+        }
+    },
+});
+//# sourceMappingURL=restore.js.map

package/dist/cli/index.js

@@ -0,0 +1,21 @@
+import { defineCommand, runMain } from 'citty';
+const main = defineCommand({
+    meta: {
+        name: 'mcpick',
+        description: 'MCP Server Configuration Manager',
+    },
+    subCommands: {
+        list: () => import('./commands/list.js').then((m) => m.default),
+        enable: () => import('./commands/enable.js').then((m) => m.default),
+        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),
+        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),
+    },
+});
+export const run = () => runMain(main);
+//# sourceMappingURL=index.js.map

package/dist/cli/output.js

@@ -0,0 +1,21 @@
+export function output(data, json) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (typeof data === 'string') {
+        console.log(data);
+    }
+    else if (Array.isArray(data)) {
+        for (const item of data) {
+            console.log(item);
+        }
+    }
+    else {
+        console.log(data);
+    }
+}
+export function error(message) {
+    console.error(`error: ${message}`);
+    process.exit(1);
+}
+//# sourceMappingURL=output.js.map

package/dist/commands/edit-plugins.js

@@ -0,0 +1,56 @@
+import { log, multiselect, note } from '@clack/prompts';
+import { build_enabled_plugins, get_all_plugins, read_claude_settings, write_claude_settings, } from '../core/settings.js';
+export async function edit_plugins() {
+    try {
+        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}`);
+        // Show what changed
+        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(', ')}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to edit plugins: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+//# sourceMappingURL=edit-plugins.js.map

package/dist/commands/manage-cache.js

@@ -0,0 +1,155 @@
+import { confirm, isCancel, log, multiselect, note, select, } from '@clack/prompts';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, refresh_all_marketplaces, } from '../core/plugin-cache.js';
+function format_status_line(p) {
+    const markers = [];
+    if (p.isVersionStale) {
+        markers.push(`version: ${p.installedVersion} → ${p.latestVersion}`);
+    }
+    if (p.isShaStale) {
+        markers.push('commits behind');
+    }
+    if (p.orphanedVersions.length > 0) {
+        markers.push(`${p.orphanedVersions.length} orphaned`);
+    }
+    const status = markers.length > 0
+        ? `[stale: ${markers.join(', ')}]`
+        : '[up to date]';
+    return `${p.name}@${p.marketplace}  v${p.installedVersion}  ${status}`;
+}
+async function handle_status() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins found.');
+        return;
+    }
+    const lines = plugins.map(format_status_line).join('\n');
+    note(lines, 'Plugin Cache Status');
+}
+async function handle_clear() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins to clear.');
+        return;
+    }
+    const selected = await multiselect({
+        message: 'Select plugins to clear cache for:',
+        options: plugins.map((p) => {
+            const stale = p.isVersionStale || p.isShaStale;
+            return {
+                value: p.key,
+                label: `${p.name}@${p.marketplace}`,
+                hint: stale
+                    ? `v${p.installedVersion} → ${p.latestVersion ?? 'unknown'} (stale)`
+                    : `v${p.installedVersion}`,
+            };
+        }),
+        initialValues: plugins
+            .filter((p) => p.isVersionStale || p.isShaStale)
+            .map((p) => p.key),
+    });
+    if (isCancel(selected) || selected.length === 0)
+        return;
+    const should_clear = await confirm({
+        message: `Clear cache for ${selected.length} plugin(s)? This will also refresh the marketplace.`,
+    });
+    if (isCancel(should_clear) || !should_clear)
+        return;
+    const result = await clear_plugin_caches(selected);
+    for (const key of result.cleared) {
+        log.success(`Cleared: ${key}`);
+    }
+    for (const err of result.errors) {
+        log.error(`Error: ${err}`);
+    }
+    if (result.cleared.length > 0) {
+        note('Run /reload-plugins in Claude Code or restart your session to apply changes.', 'Next Steps');
+    }
+}
+async function handle_clean_orphaned() {
+    const should_clean = await confirm({
+        message: 'Remove all orphaned plugin version directories?',
+    });
+    if (isCancel(should_clean) || !should_clean)
+        return;
+    const result = await clean_orphaned_versions();
+    if (result.cleaned === 0) {
+        log.info('No orphaned versions found.');
+    }
+    else {
+        for (const p of result.paths) {
+            log.success(`Removed: ${p}`);
+        }
+        log.info(`Cleaned ${result.cleaned} orphaned version(s).`);
+    }
+}
+async function handle_refresh() {
+    const should_refresh = await confirm({
+        message: 'Refresh all marketplace clones (git pull)?',
+    });
+    if (isCancel(should_refresh) || !should_refresh)
+        return;
+    const results = await refresh_all_marketplaces();
+    if (results.size === 0) {
+        log.info('No marketplaces configured.');
+        return;
+    }
+    for (const [name, result] of results) {
+        if (result.success) {
+            log.success(`${name}: refreshed`);
+        }
+        else {
+            log.error(`${name}: ${result.error}`);
+        }
+    }
+}
+export async function manage_cache() {
+    while (true) {
+        const action = await select({
+            message: 'Plugin cache management:',
+            options: [
+                {
+                    value: 'status',
+                    label: 'View cache status',
+                    hint: 'Show plugins with staleness info',
+                },
+                {
+                    value: 'clear',
+                    label: 'Clear plugin caches',
+                    hint: 'Refresh marketplace + clear selected caches',
+                },
+                {
+                    value: 'clean-orphaned',
+                    label: 'Clean orphaned versions',
+                    hint: 'Remove old version directories',
+                },
+                {
+                    value: 'refresh',
+                    label: 'Refresh marketplaces',
+                    hint: 'Git pull all marketplace clones',
+                },
+                {
+                    value: 'back',
+                    label: 'Back',
+                    hint: 'Return to main menu',
+                },
+            ],
+        });
+        if (isCancel(action) || action === 'back')
+            return;
+        switch (action) {
+            case 'status':
+                await handle_status();
+                break;
+            case 'clear':
+                await handle_clear();
+                break;
+            case 'clean-orphaned':
+                await handle_clean_orphaned();
+                break;
+            case 'refresh':
+                await handle_refresh();
+                break;
+        }
+    }
+}
+//# sourceMappingURL=manage-cache.js.map