mcpick 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # mcpick
 
+## 0.0.12
+
+### Patch Changes
+
+- b4f38d5: fix: discover externally-added servers and use atomic JSON
+  writes
+
+## 0.0.11
+
+### Patch Changes
+
+- 7ec3323: feat: add plugin install, uninstall, and update commands
+  via Claude CLI
+- 99b2bf3: feat: add plugin install, uninstall, and update to
+  interactive menu
+- 9b1c6d7: feat: add plugin support to backup, restore, and profiles
+
 ## 0.0.10
 
 ### Patch Changes

package/README.md

@@ -1,8 +1,8 @@
 # McPick
 
-A CLI tool for dynamically managing MCP server configurations in
-Claude Code. Enable and disable MCP servers on-demand to optimize
-context usage and performance.
+A CLI tool for managing MCP servers, plugins, and plugin caches in
+Claude Code. Toggle servers and plugins on/off, manage stale plugin
+caches, and optimise context usage and performance.
 
 ## Installation
 
@@ -51,10 +51,15 @@ This can lead to:
 
 ## The Solution
 
-McPick provides an intuitive CLI menu to:
+McPick provides an intuitive CLI menu and non-interactive subcommands
+to:
 
 - ✅ **Toggle servers on/off** - Enable only the MCP servers you need
   for your current task
+- 🔌 **Toggle plugins on/off** - Enable or disable Claude Code
+  marketplace plugins
+- 🗑️ **Manage plugin cache** - Detect stale plugins, clear caches,
+  clean orphaned versions, refresh marketplaces
 - 📁 **Manage server registry** - Keep a database of all your
   available MCP servers
 - 🔄 **Safe configuration** - Only modifies the `mcpServers` section,
@@ -71,6 +76,8 @@ McPick provides an intuitive CLI menu to:
 │
 ◆  What would you like to do?
 │  ● Enable / Disable MCP servers (Toggle MCP servers on/off)
+│  ○ Enable / Disable plugins (Toggle Claude Code plugins on/off)
+│  ○ Manage plugin cache (View, clear, or refresh plugin caches)
 │  ○ Backup config
 │  ○ Add MCP server
 │  ○ Restore from backup
@@ -162,6 +169,104 @@ Or use full format with `mcpServers` wrapper:
 }
 ```
 
+### Plugin Cache Management
+
+Claude Code caches marketplace plugins at `~/.claude/plugins/cache/`.
+When marketplace authors update plugins, your cached versions can go
+stale. McPick detects this and lets you fix it.
+
+#### Interactive
+
+Select "Manage plugin cache" from the main menu to:
+
+- **View cache status** - See all cached plugins with staleness
+  indicators (version mismatch, commits behind, orphaned versions)
+- **Clear plugin caches** - Refreshes the marketplace and clears
+  selected caches so they rebuild with the latest version
+- **Clean orphaned versions** - Remove old version directories marked
+  as orphaned
+- **Refresh marketplaces** - Git pull all marketplace clones to get
+  latest plugin listings
+
+#### CLI Subcommands
+
+```bash
+# Show cache status for all plugins
+npx mcpick cache status
+npx mcpick cache status --json
+
+# Clear a specific plugin cache (refreshes marketplace first)
+npx mcpick cache clear plugin-name@marketplace
+npx mcpick cache clear --all
+
+# Remove orphaned version directories
+npx mcpick cache clean-orphaned
+
+# Refresh all marketplace clones
+npx mcpick cache refresh
+```
+
+### Plugin Management
+
+Install, update, and toggle Claude Code marketplace plugins:
+
+```bash
+# List all plugins and their status
+npx mcpick plugins list
+npx mcpick plugins list --json
+
+# Install/uninstall a plugin (wraps claude plugin CLI)
+npx mcpick plugins install plugin-name@marketplace
+npx mcpick plugins uninstall plugin-name@marketplace
+
+# Update a plugin to latest version
+npx mcpick plugins update plugin-name@marketplace
+
+# Enable/disable a plugin
+npx mcpick plugins enable plugin-name@marketplace
+npx mcpick plugins disable plugin-name@marketplace
+```
+
+All plugin commands support `--scope` (user, project, local) and
+`--json` flags.
+
+### CLI Subcommands
+
+McPick supports both an interactive menu (default) and non-interactive
+CLI subcommands for scripting and LLM tool use:
+
+```bash
+# MCP server management
+npx mcpick list                    # List servers
+npx mcpick enable <server>         # Enable a server
+npx mcpick disable <server>        # Disable a server
+npx mcpick add --name <n> ...      # Add a server
+npx mcpick remove <server>         # Remove a server
+
+# Backups and profiles
+npx mcpick backup                  # Create backup
+npx mcpick restore [file]          # Restore from backup
+npx mcpick profile list            # List profiles
+npx mcpick profile load <name>     # Load a profile
+npx mcpick profile save <name>     # Save current config
+
+# Plugin management
+npx mcpick plugins list            # List plugins
+npx mcpick plugins enable <key>    # Enable plugin
+npx mcpick plugins disable <key>   # Disable plugin
+npx mcpick plugins install <key>   # Install from marketplace
+npx mcpick plugins uninstall <key> # Remove plugin
+npx mcpick plugins update <key>    # Update to latest version
+
+# Cache management
+npx mcpick cache status            # Show staleness info
+npx mcpick cache clear [key]       # Clear plugin cache
+npx mcpick cache clean-orphaned    # Remove orphaned dirs
+npx mcpick cache refresh           # Git pull marketplaces
+```
+
+All subcommands support `--json` for machine-readable output.
+
 ### Typical Workflow
 
 1. **Before a coding session**: Run `mcpick -p <profile>` or use the
@@ -209,6 +314,11 @@ MCPick works with the standard Claude Code configuration format:
   server database)
 - **Backups**: `~/.claude/mcpick/backups/` (MCP configuration backups)
 - **Profiles**: `~/.claude/mcpick/profiles/` (predefined server sets)
+- **Plugin Cache**: `~/.claude/plugins/cache/` (cached plugin files)
+- **Installed Plugins**: `~/.claude/plugins/installed_plugins.json`
+  (plugin install registry)
+- **Marketplaces**: `~/.claude/plugins/marketplaces/` (marketplace git
+  clones)
 
 #### MCP Server Storage by Scope
 

package/dist/cli/commands/backup.js

@@ -2,13 +2,32 @@ import { defineCommand } from 'citty';
 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';
 import { output } from '../output.js';
 const MAX_BACKUPS = 10;
+async function cleanup_old_backups(prefix) {
+    try {
+        const backups_dir = get_backups_dir();
+        const files = await readdir(backups_dir);
+        const backup_files = files
+            .filter((f) => f.startsWith(prefix) && f.endsWith('.json'))
+            .sort()
+            .reverse();
+        if (backup_files.length > MAX_BACKUPS) {
+            for (const file of backup_files.slice(MAX_BACKUPS)) {
+                await unlink(join(backups_dir, file));
+            }
+        }
+    }
+    catch {
+        // Cleanup is best-effort
+    }
+}
 export default defineCommand({
     meta: {
         name: 'backup',
-        description: 'Create a timestamped backup of MCP server config',
+        description: 'Create a timestamped backup of MCP servers and plugins',
     },
     args: {
         json: {
@@ -19,36 +38,45 @@ export default defineCommand({
     },
     async run({ args }) {
         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 || {},
         };
-        await writeFile(backup_path, JSON.stringify(mcp_backup, null, 2), 'utf-8');
-        // Cleanup old backups
-        try {
-            const files = await readdir(backups_dir);
-            const backup_files = files
-                .filter((f) => f.startsWith('mcp-servers-') && f.endsWith('.json'))
-                .sort()
-                .reverse();
-            if (backup_files.length > MAX_BACKUPS) {
-                for (const file of backup_files.slice(MAX_BACKUPS)) {
-                    await unlink(join(backups_dir, file));
-                }
-            }
-        }
-        catch {
-            // Cleanup is best-effort
+        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_path = null;
+        if (plugin_count > 0) {
+            const plugin_filename = get_plugin_backup_filename();
+            plugin_path = join(backups_dir, plugin_filename);
+            const plugin_backup = { enabledPlugins: plugins };
+            await writeFile(plugin_path, JSON.stringify(plugin_backup, null, 2), 'utf-8');
         }
+        await cleanup_old_backups('mcp-servers-');
+        await cleanup_old_backups('plugins-');
         const server_count = Object.keys(current_config.mcpServers || {}).length;
         if (args.json) {
-            output({ path: backup_path, servers: server_count }, true);
+            output({
+                mcp: { path: mcp_path, servers: server_count },
+                plugins: plugin_path
+                    ? {
+                        path: plugin_path,
+                        plugins: plugin_count,
+                    }
+                    : null,
+            }, true);
         }
         else {
-            console.log(`Backup created: ${backup_path} (${server_count} servers)`);
+            console.log(`Backup created: ${mcp_path} (${server_count} servers)`);
+            if (plugin_path) {
+                console.log(`Plugin backup: ${plugin_path} (${plugin_count} plugins)`);
+            }
         }
     },
 });

package/dist/cli/commands/plugins.js

@@ -1,5 +1,6 @@
 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: {
@@ -83,11 +84,119 @@ const disable = defineCommand({
         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 },
+    subCommands: { list, enable, disable, install, uninstall, update },
 });
 //# sourceMappingURL=plugins.js.map

package/dist/cli/commands/profile.js

@@ -1,6 +1,7 @@
 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: {
@@ -25,7 +26,11 @@ const list = defineCommand({
                 return;
             }
             for (const p of profiles) {
-                console.log(`${p.name}  (${p.serverCount} servers)`);
+                const parts = [`${p.serverCount} servers`];
+                if (p.pluginCount > 0) {
+                    parts.push(`${p.pluginCount} plugins`);
+                }
+                console.log(`${p.name}  (${parts.join(', ')})`);
             }
         }
     },
@@ -49,17 +54,29 @@ const load = defineCommand({
     },
     async run({ args }) {
         try {
-            const config = await load_profile(args.name);
-            await write_claude_config(config);
-            const server_count = Object.keys(config.mcpServers || {}).length;
+            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 {
-                console.log(`Profile '${args.name}' applied (${server_count} servers)`);
+                const parts = [`${server_count} servers`];
+                if (plugin_count > 0) {
+                    parts.push(`${plugin_count} plugins`);
+                }
+                console.log(`Profile '${args.name}' applied (${parts.join(', ')})`);
             }
         }
         catch (err) {
@@ -86,15 +103,20 @@ const save = defineCommand({
     },
     async run({ args }) {
         try {
-            const server_count = await save_profile(args.name);
+            const counts = await save_profile(args.name);
             if (args.json) {
                 output({
                     profile: args.name,
-                    servers: server_count,
+                    servers: counts.serverCount,
+                    plugins: counts.pluginCount,
                 }, true);
             }
             else {
-                console.log(`Profile '${args.name}' saved (${server_count} servers)`);
+                const parts = [`${counts.serverCount} servers`];
+                if (counts.pluginCount > 0) {
+                    parts.push(`${counts.pluginCount} plugins`);
+                }
+                console.log(`Profile '${args.name}' saved (${parts.join(', ')})`);
             }
         }
         catch (err) {
@@ -105,7 +127,7 @@ const save = defineCommand({
 export default defineCommand({
     meta: {
         name: 'profile',
-        description: 'Manage MCP server profiles',
+        description: 'Manage profiles (MCP servers + plugins)',
     },
     subCommands: { list, load, save },
 });

package/dist/cli/commands/remove.js

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { read_server_registry, write_server_registry, } from '../../core/registry.js';
+import { get_all_available_servers, 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({
@@ -15,17 +15,21 @@ export default defineCommand({
         },
     },
     async run({ args }) {
+        const all_servers = await get_all_available_servers();
+        const found = all_servers.find((s) => s.name === args.server);
+        if (!found) {
+            error(`Server '${args.server}' not found. Run 'mcpick list' to see available servers.`);
+        }
+        // Remove from registry if present
         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.`);
+        if (index >= 0) {
+            registry.servers.splice(index, 1);
+            await write_server_registry(registry);
         }
-        // Remove from registry
-        registry.servers.splice(index, 1);
-        await write_server_registry(registry);
-        // Also disable via CLI (best effort)
+        // Remove via CLI
         await remove_mcp_via_cli(args.server);
-        console.log(`Removed '${args.server}' from registry`);
+        console.log(`Removed '${args.server}'`);
     },
 });
 //# sourceMappingURL=remove.js.map

package/dist/cli/commands/restore.js

@@ -1,13 +1,14 @@
 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 { 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 MCP server config from a backup (latest if no file specified)',
+        description: 'Restore config from a backup (latest if no file specified)',
     },
     args: {
         file: {
@@ -15,6 +16,11 @@ export default defineCommand({
             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',
@@ -22,34 +28,77 @@ export default defineCommand({
         },
     },
     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(', ')}`);
+        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)`);
+                }
             }
-            backup_path = found.path;
         }
-        else {
-            backup_path = backups[0].path;
+        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)`);
+                }
+            }
         }
-        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)`);
+            output(results, true);
         }
     },
 });