mcpick 0.0.10 → 0.0.12

package/dist/core/registry.js

@@ -40,7 +40,17 @@ export async function add_server_to_registry(server) {
     await write_server_registry(registry);
 }
 export async function get_all_available_servers() {
+    const { get_enabled_servers, read_claude_config } = await import('./config.js');
     const registry = await read_server_registry();
+    const config = await read_claude_config();
+    const config_servers = get_enabled_servers(config);
+    // Merge: registry is base, config servers fill in any missing
+    const known_names = new Set(registry.servers.map((s) => s.name));
+    for (const server of config_servers) {
+        if (!known_names.has(server.name)) {
+            registry.servers.push(server);
+        }
+    }
     return registry.servers;
 }
 export async function sync_servers_to_registry(servers) {
@@ -56,36 +66,40 @@ export async function sync_servers_to_registry(servers) {
     });
     await write_server_registry(registry);
 }
-export async function list_backups() {
-    const backups_dir = get_backups_dir();
-    try {
-        await access(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 {
-                filename: file,
-                timestamp,
-                path: join(backups_dir, file),
-            };
-        })
-            .filter((backup) => backup !== null)
-            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-        return backup_files;
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return [];
+function parse_backups(prefix, pattern) {
+    return async () => {
+        const backups_dir = get_backups_dir();
+        try {
+            await access(backups_dir);
+            const files = await readdir(backups_dir);
+            const backup_files = files
+                .filter((file) => file.startsWith(prefix) && file.endsWith('.json'))
+                .map((file) => {
+                const timestamp_match = file.match(pattern);
+                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 {
+                    filename: file,
+                    timestamp,
+                    path: join(backups_dir, file),
+                };
+            })
+                .filter((backup) => backup !== null)
+                .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            return backup_files;
         }
-        throw error;
-    }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    };
 }
+export const list_backups = parse_backups('mcp-servers-', /mcp-servers-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
+export const list_plugin_backups = parse_backups('plugins-', /plugins-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
 //# sourceMappingURL=registry.js.map

package/dist/core/settings.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_settings_path } from '../utils/paths.js';
 export async function read_claude_settings() {
     const settings_path = get_claude_settings_path();
@@ -17,20 +18,12 @@ export async function read_claude_settings() {
     }
 }
 export async function write_claude_settings(updates) {
-    const settings_path = get_claude_settings_path();
-    let existing = {};
-    try {
-        const content = await readFile(settings_path, 'utf-8');
-        existing = JSON.parse(content);
-    }
-    catch {
-        // Start with empty if file doesn't exist
-    }
-    // Merge only the keys we're updating
-    for (const [key, value] of Object.entries(updates)) {
-        existing[key] = value;
-    }
-    await writeFile(settings_path, JSON.stringify(existing, null, 2), 'utf-8');
+    await atomic_json_write(get_claude_settings_path(), (existing) => {
+        for (const [key, value] of Object.entries(updates)) {
+            existing[key] = value;
+        }
+        return existing;
+    });
 }
 /**
  * Parse enabledPlugins into structured list.

package/dist/index.js

@@ -8,6 +8,7 @@ import { manage_cache } from './commands/manage-cache.js';
 import { restore_config } from './commands/restore.js';
 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';
 function parse_args() {
     const args = process.argv.slice(2);
     const result = {};
@@ -29,10 +30,17 @@ function parse_args() {
 async function apply_profile(name) {
     intro(`MCPick - Loading profile: ${name}`);
     try {
-        const profile_config = await load_profile(name);
-        await write_claude_config(profile_config);
-        const server_count = Object.keys(profile_config.mcpServers || {}).length;
-        log.success(`Profile '${name}' applied (${server_count} servers)`);
+        const profile = await load_profile(name);
+        await write_claude_config(profile.config);
+        const server_count = Object.keys(profile.config.mcpServers || {}).length;
+        const parts = [`${server_count} servers`];
+        if (profile.enabledPlugins) {
+            await write_claude_settings({
+                enabledPlugins: profile.enabledPlugins,
+            });
+            parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
+        }
+        log.success(`Profile '${name}' applied (${parts.join(', ')})`);
         outro('Done!');
     }
     catch (error) {
@@ -62,8 +70,12 @@ async function show_profiles() {
 async function create_profile(name) {
     intro(`MCPick - Saving profile: ${name}`);
     try {
-        const server_count = await save_profile(name);
-        log.success(`Profile '${name}' saved (${server_count} servers)`);
+        const counts = await save_profile(name);
+        const parts = [`${counts.serverCount} servers`];
+        if (counts.pluginCount > 0) {
+            parts.push(`${counts.pluginCount} plugins`);
+        }
+        log.success(`Profile '${name}' saved (${parts.join(', ')})`);
         outro('Done!');
     }
     catch (error) {
@@ -85,18 +97,31 @@ async function handle_load_profile() {
     }
     const profile_name = await select({
         message: 'Select a profile to load:',
-        options: profiles.map((p) => ({
-            value: p.name,
-            label: p.name,
-            hint: `${p.serverCount} servers`,
-        })),
+        options: profiles.map((p) => {
+            const parts = [`${p.serverCount} servers`];
+            if (p.pluginCount > 0) {
+                parts.push(`${p.pluginCount} plugins`);
+            }
+            return {
+                value: p.name,
+                label: p.name,
+                hint: parts.join(', '),
+            };
+        }),
     });
     if (isCancel(profile_name))
         return;
-    const profile_config = await load_profile(profile_name);
-    await write_claude_config(profile_config);
-    const server_count = Object.keys(profile_config.mcpServers || {}).length;
-    log.success(`Profile '${profile_name}' applied (${server_count} servers)`);
+    const profile = await load_profile(profile_name);
+    await write_claude_config(profile.config);
+    const server_count = Object.keys(profile.config.mcpServers || {}).length;
+    const parts = [`${server_count} servers`];
+    if (profile.enabledPlugins) {
+        await write_claude_settings({
+            enabledPlugins: profile.enabledPlugins,
+        });
+        parts.push(`${Object.keys(profile.enabledPlugins).length} plugins`);
+    }
+    log.success(`Profile '${profile_name}' applied (${parts.join(', ')})`);
 }
 async function handle_save_profile() {
     const name = await text({
@@ -113,8 +138,12 @@ async function handle_save_profile() {
     });
     if (isCancel(name))
         return;
-    const server_count = await save_profile(name);
-    log.success(`Profile '${name}' saved (${server_count} servers)`);
+    const counts = await save_profile(name);
+    const parts = [`${counts.serverCount} servers`];
+    if (counts.pluginCount > 0) {
+        parts.push(`${counts.pluginCount} plugins`);
+    }
+    log.success(`Profile '${name}' saved (${parts.join(', ')})`);
 }
 async function main() {
     const args = parse_args();
@@ -146,8 +175,8 @@ async function main() {
                     },
                     {
                         value: 'edit-plugins',
-                        label: 'Enable / Disable plugins',
-                        hint: 'Toggle Claude Code plugins on/off',
+                        label: 'Manage plugins',
+                        hint: 'Toggle, install, uninstall, or update plugins',
                     },
                     {
                         value: 'manage-cache',

package/dist/utils/atomic-write.js

@@ -0,0 +1,27 @@
+import { readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/**
+ * Atomically write a JSON file with fresh-read merging.
+ *
+ * 1. Re-reads the file right before writing to pick up concurrent changes
+ * 2. Applies the merge function to the freshest data
+ * 3. Writes to a temp file, then renames (atomic on same filesystem)
+ */
+export async function atomic_json_write(file_path, merge) {
+    // Read the freshest version right before writing
+    let existing = {};
+    try {
+        const content = await readFile(file_path, 'utf-8');
+        existing = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist or invalid — start fresh
+    }
+    const merged = merge(existing);
+    const content = JSON.stringify(merged, null, 2);
+    // Write to temp file then rename for atomicity
+    const tmp_path = join(dirname(file_path), `.${Date.now()}.tmp`);
+    await writeFile(tmp_path, content, 'utf-8');
+    await rename(tmp_path, file_path);
+}
+//# sourceMappingURL=atomic-write.js.map

package/dist/utils/claude-cli.js

@@ -115,6 +115,75 @@ export async function remove_mcp_via_cli(name) {
         };
     }
 }
+/**
+ * Install a plugin via Claude CLI
+ */
+export async function install_plugin_via_cli(key, scope = 'user') {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync(`claude plugin install ${shell_escape(key)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to install plugin: ${message}`,
+        };
+    }
+}
+/**
+ * Uninstall a plugin via Claude CLI
+ */
+export async function uninstall_plugin_via_cli(key, scope = 'user') {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync(`claude plugin uninstall ${shell_escape(key)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to uninstall plugin: ${message}`,
+        };
+    }
+}
+/**
+ * Update a plugin via Claude CLI
+ */
+export async function update_plugin_via_cli(key, scope = 'user') {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        await execAsync(`claude plugin update ${shell_escape(key)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to update plugin: ${message}`,
+        };
+    }
+}
 /**
  * Get the scope description for display
  */

package/dist/utils/paths.js

@@ -45,7 +45,7 @@ export function get_profile_path(name) {
     const filename = name.endsWith('.json') ? name : `${name}.json`;
     return join(get_profiles_dir(), filename);
 }
-export function get_backup_filename() {
+function format_backup_timestamp() {
     const now = new Date();
     const year = now.getFullYear();
     const month = String(now.getMonth() + 1).padStart(2, '0');
@@ -53,7 +53,13 @@ export function get_backup_filename() {
     const hour = String(now.getHours()).padStart(2, '0');
     const minute = String(now.getMinutes()).padStart(2, '0');
     const second = String(now.getSeconds()).padStart(2, '0');
-    return `mcp-servers-${year}-${month}-${day}-${hour}${minute}${second}.json`;
+    return `${year}-${month}-${day}-${hour}${minute}${second}`;
+}
+export function get_backup_filename() {
+    return `mcp-servers-${format_backup_timestamp()}.json`;
+}
+export function get_plugin_backup_filename() {
+    return `plugins-${format_backup_timestamp()}.json`;
 }
 export async function ensure_directory_exists(dir_path) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpick",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Dynamic MCP server and plugin configuration manager for Claude Code",
   "type": "module",
   "main": "./dist/index.js",