mcpick 0.0.9 → 0.0.11

package/dist/cli/commands/list.js

@@ -0,0 +1,63 @@
+import { defineCommand } from 'citty';
+import { get_enabled_servers_for_scope } from '../../core/config.js';
+import { get_all_available_servers } from '../../core/registry.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all MCP servers and their status',
+    },
+    args: {
+        scope: {
+            type: 'string',
+            description: 'Scope to check: local, project, or user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scopes = args.scope
+            ? [args.scope]
+            : ['local', 'project', 'user'];
+        if (args.scope &&
+            !['local', 'project', 'user'].includes(args.scope)) {
+            error(`Invalid scope: ${args.scope}. Use local, project, or user.`);
+        }
+        const all_servers = await get_all_available_servers();
+        const enabled_by_scope = {};
+        for (const scope of scopes) {
+            enabled_by_scope[scope] =
+                await get_enabled_servers_for_scope(scope);
+        }
+        if (args.json) {
+            const data = all_servers.map((server) => {
+                const status = {};
+                for (const scope of scopes) {
+                    status[scope] = enabled_by_scope[scope].includes(server.name);
+                }
+                const { name, ...rest } = server;
+                return { name, ...status, ...rest };
+            });
+            output(data, true);
+        }
+        else {
+            if (all_servers.length === 0) {
+                console.log('No servers in registry.');
+                return;
+            }
+            for (const server of all_servers) {
+                const statuses = scopes
+                    .map((scope) => {
+                    const enabled = enabled_by_scope[scope].includes(server.name);
+                    return `${scope}:${enabled ? 'on' : 'off'}`;
+                })
+                    .join(' ');
+                console.log(`${server.name}  ${statuses}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=list.js.map

package/dist/cli/commands/plugins.js

@@ -0,0 +1,202 @@
+import { defineCommand } from 'citty';
+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 { error, output } from '../output.js';
+const list = defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all plugins and their status',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        if (args.json) {
+            output(plugins, true);
+        }
+        else {
+            if (plugins.length === 0) {
+                console.log('No plugins found.');
+                return;
+            }
+            for (const p of plugins) {
+                const status = p.enabled ? 'on' : 'off';
+                console.log(`${p.name}@${p.marketplace}  ${status}`);
+            }
+        }
+    },
+});
+const enable = defineCommand({
+    meta: {
+        name: 'enable',
+        description: 'Enable a plugin',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        const key = args.plugin;
+        const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+        if (!plugin) {
+            error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+        }
+        plugin.enabled = true;
+        const updated = build_enabled_plugins(plugins);
+        await write_claude_settings({ enabledPlugins: updated });
+        console.log(`Enabled plugin '${key}'`);
+    },
+});
+const disable = defineCommand({
+    meta: {
+        name: 'disable',
+        description: 'Disable a plugin',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        const key = args.plugin;
+        const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+        if (!plugin) {
+            error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+        }
+        plugin.enabled = false;
+        const updated = build_enabled_plugins(plugins);
+        await write_claude_settings({ enabledPlugins: updated });
+        console.log(`Disabled plugin '${key}'`);
+    },
+});
+const install = defineCommand({
+    meta: {
+        name: 'install',
+        description: 'Install a plugin from a marketplace',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Installation scope: user, project, or local',
+            default: 'user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        const result = await install_plugin_via_cli(args.plugin, scope);
+        if (args.json) {
+            output(result, true);
+        }
+        else if (result.success) {
+            console.log(`Installed plugin '${args.plugin}' (scope: ${scope})`);
+        }
+        else {
+            error(result.error ?? 'Unknown error');
+        }
+    },
+});
+const uninstall = defineCommand({
+    meta: {
+        name: 'uninstall',
+        description: 'Uninstall a plugin',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Uninstall from scope: user, project, or local',
+            default: 'user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        const result = await uninstall_plugin_via_cli(args.plugin, scope);
+        if (args.json) {
+            output(result, true);
+        }
+        else if (result.success) {
+            console.log(`Uninstalled plugin '${args.plugin}' (scope: ${scope})`);
+        }
+        else {
+            error(result.error ?? 'Unknown error');
+        }
+    },
+});
+const update = defineCommand({
+    meta: {
+        name: 'update',
+        description: 'Update a plugin to latest version',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope to update: user, project, or local',
+            default: 'user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        const result = await update_plugin_via_cli(args.plugin, scope);
+        if (args.json) {
+            output(result, true);
+        }
+        else if (result.success) {
+            console.log(`Updated plugin '${args.plugin}' (scope: ${scope})`);
+        }
+        else {
+            error(result.error ?? 'Unknown error');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'plugins',
+        description: 'Manage Claude Code plugins',
+    },
+    subCommands: { list, enable, disable, install, uninstall, update },
+});
+//# sourceMappingURL=plugins.js.map

package/dist/cli/commands/profile.js

@@ -0,0 +1,134 @@
+import { defineCommand } from 'citty';
+import { write_claude_config } from '../../core/config.js';
+import { list_profiles, load_profile, save_profile, } from '../../core/profile.js';
+import { write_claude_settings } from '../../core/settings.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) {
+                const parts = [`${p.serverCount} servers`];
+                if (p.pluginCount > 0) {
+                    parts.push(`${p.pluginCount} plugins`);
+                }
+                console.log(`${p.name}  (${parts.join(', ')})`);
+            }
+        }
+    },
+});
+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 profile = await load_profile(args.name);
+            await write_claude_config(profile.config);
+            const server_count = Object.keys(profile.config.mcpServers || {}).length;
+            let plugin_count = 0;
+            if (profile.enabledPlugins) {
+                await write_claude_settings({
+                    enabledPlugins: profile.enabledPlugins,
+                });
+                plugin_count = Object.keys(profile.enabledPlugins).length;
+            }
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: server_count,
+                    plugins: plugin_count,
+                }, true);
+            }
+            else {
+                const parts = [`${server_count} servers`];
+                if (plugin_count > 0) {
+                    parts.push(`${plugin_count} plugins`);
+                }
+                console.log(`Profile '${args.name}' applied (${parts.join(', ')})`);
+            }
+        }
+        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 counts = await save_profile(args.name);
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: counts.serverCount,
+                    plugins: counts.pluginCount,
+                }, true);
+            }
+            else {
+                const parts = [`${counts.serverCount} servers`];
+                if (counts.pluginCount > 0) {
+                    parts.push(`${counts.pluginCount} plugins`);
+                }
+                console.log(`Profile '${args.name}' saved (${parts.join(', ')})`);
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to save profile');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'profile',
+        description: 'Manage profiles (MCP servers + plugins)',
+    },
+    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,105 @@
+import { defineCommand } from 'citty';
+import { readFile } from 'node:fs/promises';
+import { write_claude_config } from '../../core/config.js';
+import { list_backups, list_plugin_backups, } from '../../core/registry.js';
+import { write_claude_settings } from '../../core/settings.js';
+import { validate_claude_config } from '../../core/validation.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'restore',
+        description: 'Restore config from a backup (latest if no file specified)',
+    },
+    args: {
+        file: {
+            type: 'positional',
+            description: 'Backup filename or path (optional, defaults to latest)',
+            required: false,
+        },
+        type: {
+            type: 'string',
+            description: 'What to restore: mcp (default), plugins, or all',
+            default: 'mcp',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const restore_type = args.type;
+        const results = {};
+        if (restore_type === 'mcp' || restore_type === 'all') {
+            const backups = await list_backups();
+            if (backups.length === 0) {
+                if (restore_type === 'mcp') {
+                    error('No MCP backups found. Run "mcpick backup" first.');
+                }
+            }
+            else {
+                let backup_path;
+                if (args.file && restore_type === 'mcp') {
+                    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;
+                results.mcp = {
+                    restored: backup_path,
+                    servers: server_count,
+                };
+                if (!args.json) {
+                    console.log(`Restored MCP: ${backup_path} (${server_count} servers)`);
+                }
+            }
+        }
+        if (restore_type === 'plugins' || restore_type === 'all') {
+            const backups = await list_plugin_backups();
+            if (backups.length === 0) {
+                if (restore_type === 'plugins') {
+                    error('No plugin backups found. Run "mcpick backup" first.');
+                }
+            }
+            else {
+                let backup_path;
+                if (args.file && restore_type === 'plugins') {
+                    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);
+                await write_claude_settings({
+                    enabledPlugins: parsed.enabledPlugins || {},
+                });
+                const plugin_count = Object.keys(parsed.enabledPlugins || {}).length;
+                results.plugins = {
+                    restored: backup_path,
+                    plugins: plugin_count,
+                };
+                if (!args.json) {
+                    console.log(`Restored plugins: ${backup_path} (${plugin_count} plugins)`);
+                }
+            }
+        }
+        if (args.json) {
+            output(results, true);
+        }
+    },
+});
+//# 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/backup.js

@@ -2,53 +2,59 @@ 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 { ensure_directory_exists, get_backup_filename, get_backups_dir, } from '../utils/paths.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);
-        const backup_filename = get_backup_filename();
-        const backup_path = join(backups_dir, backup_filename);
+        // Backup MCP servers
+        const mcp_filename = get_backup_filename();
+        const mcp_path = join(backups_dir, mcp_filename);
         const mcp_backup = {
             mcpServers: current_config.mcpServers || {},
         };
-        const backup_content = JSON.stringify(mcp_backup, null, 2);
-        await writeFile(backup_path, backup_content, 'utf-8');
-        await cleanup_old_backups();
+        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 created:\n${backup_path}\n(${server_count} servers backed up)`);
+        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() {
+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('mcp-servers-') && file.endsWith('.json'))
-            .map((file) => {
-            const timestamp_match = file.match(/mcp-servers-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
-            if (!timestamp_match)
-                return null;
-            const [, year, month, day, hour, minute, second] = timestamp_match;
-            const timestamp = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
-            return { file, timestamp };
-        })
-            .filter((backup) => backup !== null)
-            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            .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) {
+            for (const file of files_to_delete) {
                 await unlink(join(backups_dir, file));
             }
         }
     }
-    catch (error) {
-        console.warn('Warning: Failed to cleanup old backups:', error);
+    catch {
+        // Cleanup is best-effort
     }
 }
 //# sourceMappingURL=backup.js.map