mcpick 0.0.10 → 0.0.12

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

package/dist/commands/edit-plugins.js

@@ -1,56 +1,201 @@
-import { log, multiselect, note } from '@clack/prompts';
+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() {
-    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,
+    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 (typeof selected === 'symbol') {
+        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;
+            }
         }
-        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(', ')}`);
+        catch (err) {
+            log.error(err instanceof Error ? err.message : 'Unknown error');
         }
-        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/restore.js

@@ -1,50 +1,101 @@
-import { confirm, note, select } from '@clack/prompts';
+import { confirm, isCancel, log, note, select } from '@clack/prompts';
 import { readFile } from 'node:fs/promises';
 import { read_claude_config, write_claude_config, } from '../core/config.js';
-import { list_backups } from '../core/registry.js';
+import { list_backups, list_plugin_backups, } from '../core/registry.js';
+import { write_claude_settings } from '../core/settings.js';
 export async function restore_config() {
     try {
-        const backups = await list_backups();
-        if (backups.length === 0) {
-            note('No backups found.');
-            return;
-        }
-        const backup_choices = backups.map((backup) => ({
-            value: backup.path,
-            label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
-            hint: format_time_ago(backup.timestamp),
-        }));
-        const selected_backup_path = await select({
-            message: 'Select backup to restore:',
-            options: backup_choices,
+        const restore_type = await select({
+            message: 'What would you like to restore?',
+            options: [
+                {
+                    value: 'mcp',
+                    label: 'MCP servers',
+                    hint: 'Restore server configuration',
+                },
+                {
+                    value: 'plugins',
+                    label: 'Plugins',
+                    hint: 'Restore plugin enabled/disabled state',
+                },
+            ],
         });
-        if (typeof selected_backup_path === 'symbol') {
+        if (isCancel(restore_type))
             return;
+        if (restore_type === 'mcp') {
+            await restore_mcp();
         }
-        const should_restore = await confirm({
-            message: 'This will replace your current MCP servers configuration. Continue?',
-        });
-        if (typeof should_restore === 'symbol' || !should_restore) {
-            return;
+        else {
+            await restore_plugins();
         }
-        // Read the backup file
-        const backup_content = await readFile(selected_backup_path, 'utf-8');
-        const backup_data = JSON.parse(backup_content);
-        // Read current config and merge
-        const current_config = await read_claude_config();
-        const updated_config = {
-            ...current_config,
-            mcpServers: backup_data.mcpServers || {},
-        };
-        // Write back only the updated config
-        await write_claude_config(updated_config);
-        const server_count = Object.keys(backup_data.mcpServers || {}).length;
-        note(`MCP servers configuration restored successfully!\n(${server_count} servers restored)`);
     }
     catch (error) {
         throw new Error(`Failed to restore configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+async function restore_mcp() {
+    const backups = await list_backups();
+    if (backups.length === 0) {
+        note('No MCP server backups found.');
+        return;
+    }
+    const backup_choices = backups.map((backup) => ({
+        value: backup.path,
+        label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+        hint: format_time_ago(backup.timestamp),
+    }));
+    const selected_backup_path = await select({
+        message: 'Select backup to restore:',
+        options: backup_choices,
+    });
+    if (isCancel(selected_backup_path))
+        return;
+    const should_restore = await confirm({
+        message: 'This will replace your current MCP servers configuration. Continue?',
+    });
+    if (isCancel(should_restore) || !should_restore)
+        return;
+    const backup_content = await readFile(selected_backup_path, 'utf-8');
+    const backup_data = JSON.parse(backup_content);
+    const current_config = await read_claude_config();
+    const updated_config = {
+        ...current_config,
+        mcpServers: backup_data.mcpServers || {},
+    };
+    await write_claude_config(updated_config);
+    const server_count = Object.keys(backup_data.mcpServers || {}).length;
+    log.success(`MCP servers restored (${server_count} servers)`);
+}
+async function restore_plugins() {
+    const backups = await list_plugin_backups();
+    if (backups.length === 0) {
+        note('No plugin backups found.');
+        return;
+    }
+    const backup_choices = backups.map((backup) => ({
+        value: backup.path,
+        label: `${backup.filename} (${backup.timestamp.toLocaleString()})`,
+        hint: format_time_ago(backup.timestamp),
+    }));
+    const selected_backup_path = await select({
+        message: 'Select plugin backup to restore:',
+        options: backup_choices,
+    });
+    if (isCancel(selected_backup_path))
+        return;
+    const should_restore = await confirm({
+        message: 'This will replace your current plugin configuration. Continue?',
+    });
+    if (isCancel(should_restore) || !should_restore)
+        return;
+    const backup_content = await readFile(selected_backup_path, 'utf-8');
+    const backup_data = JSON.parse(backup_content);
+    await write_claude_settings({
+        enabledPlugins: backup_data.enabledPlugins || {},
+    });
+    const plugin_count = Object.keys(backup_data.enabledPlugins || {}).length;
+    log.success(`Plugins restored (${plugin_count} plugins)`);
+}
 function format_time_ago(date) {
     const now = new Date();
     const diff = now.getTime() - date.getTime();

package/dist/core/config.js

@@ -1,4 +1,5 @@
-import { access, readFile, writeFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
+import { atomic_json_write } from '../utils/atomic-write.js';
 import { get_claude_config_path, get_current_project_path, get_project_mcp_json_path, } from '../utils/paths.js';
 import { validate_claude_config } from './validation.js';
 export async function read_claude_config() {
@@ -19,20 +20,10 @@ export async function read_claude_config() {
     }
 }
 export async function write_claude_config(config) {
-    const config_path = get_claude_config_path();
-    // Read the entire existing file to preserve all other sections
-    let existing_config = {};
-    try {
-        const existing_content = await readFile(config_path, 'utf-8');
-        existing_config = JSON.parse(existing_content);
-    }
-    catch (error) {
-        // If file doesn't exist or is invalid, start with empty object
-    }
-    // Only update the mcpServers section, preserve everything else
-    existing_config.mcpServers = config.mcpServers;
-    const config_content = JSON.stringify(existing_config, null, 2);
-    await writeFile(config_path, config_content, 'utf-8');
+    await atomic_json_write(get_claude_config_path(), (existing) => {
+        existing.mcpServers = config.mcpServers;
+        return existing;
+    });
 }
 export function get_enabled_servers(config) {
     if (!config.mcpServers) {

package/dist/core/plugin-cache.js

@@ -1,7 +1,8 @@
 import { exec } from 'node:child_process';
-import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { readdir, readFile, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { atomic_json_write } from '../utils/atomic-write.js';
 import { get_installed_plugins_path, get_known_marketplaces_path, get_marketplace_manifest_path, get_plugin_cache_dir, } from '../utils/paths.js';
 const execAsync = promisify(exec);
 const EMPTY_INSTALLED = {
@@ -19,7 +20,7 @@ export async function read_installed_plugins() {
     }
 }
 export async function write_installed_plugins(data) {
-    await writeFile(get_installed_plugins_path(), JSON.stringify(data, null, 2), 'utf-8');
+    await atomic_json_write(get_installed_plugins_path(), () => data);
 }
 export async function read_known_marketplaces() {
     try {

package/dist/core/profile.js

@@ -1,6 +1,7 @@
 import { access, readFile, readdir, writeFile, } from 'node:fs/promises';
 import { ensure_directory_exists, get_profile_path, get_profiles_dir, } from '../utils/paths.js';
 import { read_claude_config } from './config.js';
+import { read_claude_settings } from './settings.js';
 import { validate_claude_config } from './validation.js';
 export async function load_profile(name) {
     const profile_path = get_profile_path(name);
@@ -8,12 +9,24 @@ export async function load_profile(name) {
         await access(profile_path);
         const content = await readFile(profile_path, 'utf-8');
         const parsed = JSON.parse(content);
-        // Profile can be either full ClaudeConfig format or just mcpServers object
+        // Profile can be either full format or just mcpServers object
+        let config;
         if (parsed.mcpServers) {
-            return validate_claude_config(parsed);
+            config = validate_claude_config(parsed);
         }
-        // If it's just a servers object, wrap it
-        return validate_claude_config({ mcpServers: parsed });
+        else if (!parsed.enabledPlugins) {
+            // Bare servers object (legacy)
+            config = validate_claude_config({ mcpServers: parsed });
+        }
+        else {
+            config = validate_claude_config({
+                mcpServers: parsed.mcpServers || {},
+            });
+        }
+        return {
+            config,
+            enabledPlugins: parsed.enabledPlugins,
+        };
     }
     catch (error) {
         if (error instanceof Error &&
@@ -37,10 +50,12 @@ export async function list_profiles() {
                 const content = await readFile(path, 'utf-8');
                 const parsed = JSON.parse(content);
                 const servers = parsed.mcpServers || parsed;
+                const plugins = parsed.enabledPlugins || {};
                 profiles.push({
                     name: file.replace('.json', ''),
                     path,
                     serverCount: Object.keys(servers).length,
+                    pluginCount: Object.keys(plugins).length,
                 });
             }
             catch {
@@ -55,16 +70,25 @@ export async function list_profiles() {
 }
 export async function save_profile(name) {
     const config = await read_claude_config();
+    const settings = await read_claude_settings();
     const servers = config.mcpServers || {};
+    const plugins = settings.enabledPlugins || {};
     const server_count = Object.keys(servers).length;
-    if (server_count === 0) {
-        throw new Error('No MCP servers configured to save');
+    const plugin_count = Object.keys(plugins).length;
+    if (server_count === 0 && plugin_count === 0) {
+        throw new Error('No MCP servers or plugins configured to save');
     }
     const profiles_dir = get_profiles_dir();
     await ensure_directory_exists(profiles_dir);
+    const profile_data = {
+        mcpServers: servers,
+    };
+    if (plugin_count > 0) {
+        profile_data.enabledPlugins = plugins;
+    }
     const profile_path = get_profile_path(name);
-    const content = JSON.stringify({ mcpServers: servers }, null, 2);
+    const content = JSON.stringify(profile_data, null, 2);
     await writeFile(profile_path, content, 'utf-8');
-    return server_count;
+    return { serverCount: server_count, pluginCount: plugin_count };
 }
 //# sourceMappingURL=profile.js.map