mcpick 0.0.9 → 0.0.11

package/dist/core/plugin-cache.js

@@ -0,0 +1,259 @@
+import { exec } from 'node:child_process';
+import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+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 = {
+    version: 2,
+    plugins: {},
+};
+// --- Data reading ---
+export async function read_installed_plugins() {
+    try {
+        const content = await readFile(get_installed_plugins_path(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { ...EMPTY_INSTALLED, plugins: {} };
+    }
+}
+export async function write_installed_plugins(data) {
+    await writeFile(get_installed_plugins_path(), JSON.stringify(data, null, 2), 'utf-8');
+}
+export async function read_known_marketplaces() {
+    try {
+        const content = await readFile(get_known_marketplaces_path(), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+export async function read_marketplace_manifest(name) {
+    try {
+        const content = await readFile(get_marketplace_manifest_path(name), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+// --- Git operations ---
+async function get_marketplace_head_sha(marketplace_path) {
+    try {
+        const { stdout } = await execAsync(`git -C ${JSON.stringify(marketplace_path)} rev-parse HEAD`, { timeout: 10_000 });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function refresh_marketplace(name, marketplace) {
+    const dir = marketplace.installLocation;
+    try {
+        await execAsync(`git -C ${JSON.stringify(dir)} pull --ff-only`, {
+            timeout: 30_000,
+        });
+        return { success: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return { success: false, error: `${name}: ${message}` };
+    }
+}
+export async function refresh_all_marketplaces() {
+    const marketplaces = await read_known_marketplaces();
+    const results = new Map();
+    for (const [name, info] of Object.entries(marketplaces)) {
+        results.set(name, await refresh_marketplace(name, info));
+    }
+    return results;
+}
+// --- Orphaned version detection ---
+async function find_orphaned_versions(marketplace, plugin_name) {
+    const cache_dir = get_plugin_cache_dir();
+    const plugin_dir = join(cache_dir, marketplace, plugin_name);
+    const orphaned = [];
+    try {
+        const versions = await readdir(plugin_dir, {
+            withFileTypes: true,
+        });
+        for (const entry of versions) {
+            if (!entry.isDirectory())
+                continue;
+            try {
+                const marker = join(plugin_dir, entry.name, '.orphaned_at');
+                await readFile(marker);
+                orphaned.push(entry.name);
+            }
+            catch {
+                // No .orphaned_at marker — not orphaned
+            }
+        }
+    }
+    catch {
+        // Plugin dir doesn't exist
+    }
+    return orphaned;
+}
+// --- Staleness analysis ---
+function parse_plugin_key(key) {
+    const at_index = key.lastIndexOf('@');
+    return {
+        name: at_index > 0 ? key.substring(0, at_index) : key,
+        marketplace: at_index > 0 ? key.substring(at_index + 1) : 'unknown',
+    };
+}
+export async function get_cached_plugins_info() {
+    const installed = await read_installed_plugins();
+    const marketplaces = await read_known_marketplaces();
+    // Load all marketplace manifests
+    const manifests = new Map();
+    for (const name of Object.keys(marketplaces)) {
+        const manifest = await read_marketplace_manifest(name);
+        if (manifest)
+            manifests.set(name, manifest);
+    }
+    // Get HEAD SHAs for each marketplace clone
+    const sha_cache = new Map();
+    for (const [name, info] of Object.entries(marketplaces)) {
+        sha_cache.set(name, await get_marketplace_head_sha(info.installLocation));
+    }
+    const results = [];
+    for (const [key, entries] of Object.entries(installed.plugins)) {
+        const entry = entries[0];
+        if (!entry)
+            continue;
+        const { name, marketplace } = parse_plugin_key(key);
+        // Version comparison
+        const manifest = manifests.get(marketplace);
+        const manifest_plugin = manifest?.plugins.find((p) => p.name === name);
+        const latest_version = manifest_plugin?.version ?? null;
+        const is_version_stale = latest_version !== null && latest_version !== entry.version;
+        // SHA comparison
+        const remote_sha = sha_cache.get(marketplace) ?? null;
+        const is_sha_stale = remote_sha !== null &&
+            entry.gitCommitSha !== '' &&
+            remote_sha !== entry.gitCommitSha;
+        // Orphaned versions
+        const orphaned = await find_orphaned_versions(marketplace, name);
+        results.push({
+            key,
+            name,
+            marketplace,
+            installedVersion: entry.version,
+            latestVersion: latest_version,
+            installedSha: entry.gitCommitSha,
+            remoteSha: remote_sha,
+            isVersionStale: is_version_stale,
+            isShaStale: is_sha_stale,
+            orphanedVersions: orphaned,
+            installPath: entry.installPath,
+        });
+    }
+    return results;
+}
+// --- Cache clearing ---
+function is_safe_cache_path(path) {
+    const cache_dir = resolve(get_plugin_cache_dir());
+    const target = resolve(path);
+    return target.startsWith(cache_dir + '/');
+}
+export async function clear_plugin_caches(keys) {
+    const installed = await read_installed_plugins();
+    const marketplaces = await read_known_marketplaces();
+    const cleared = [];
+    const errors = [];
+    // Collect unique marketplaces to refresh
+    const marketplace_names = new Set();
+    for (const key of keys) {
+        const { marketplace } = parse_plugin_key(key);
+        marketplace_names.add(marketplace);
+    }
+    // Refresh relevant marketplaces first
+    for (const mkt_name of marketplace_names) {
+        const mkt_info = marketplaces[mkt_name];
+        if (mkt_info) {
+            const result = await refresh_marketplace(mkt_name, mkt_info);
+            if (!result.success) {
+                errors.push(`Marketplace refresh failed: ${result.error}`);
+            }
+        }
+    }
+    // Delete cache dirs and remove from installed_plugins.json
+    const cache_dir = get_plugin_cache_dir();
+    for (const key of keys) {
+        const { name, marketplace } = parse_plugin_key(key);
+        const plugin_cache_path = join(cache_dir, marketplace, name);
+        if (!is_safe_cache_path(plugin_cache_path)) {
+            errors.push(`Unsafe path, skipped: ${plugin_cache_path}`);
+            continue;
+        }
+        try {
+            await rm(plugin_cache_path, {
+                recursive: true,
+                force: true,
+            });
+            delete installed.plugins[key];
+            cleared.push(key);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : 'Unknown error';
+            errors.push(`Failed to clear ${key}: ${msg}`);
+        }
+    }
+    // Write back updated installed_plugins.json
+    await write_installed_plugins(installed);
+    return { cleared, errors };
+}
+// --- Orphaned cleanup ---
+export async function clean_orphaned_versions() {
+    const cache_dir = get_plugin_cache_dir();
+    const cleaned_paths = [];
+    try {
+        const marketplaces = await readdir(cache_dir, {
+            withFileTypes: true,
+        });
+        for (const mkt of marketplaces) {
+            if (!mkt.isDirectory())
+                continue;
+            const mkt_path = join(cache_dir, mkt.name);
+            const plugins = await readdir(mkt_path, {
+                withFileTypes: true,
+            });
+            for (const plugin of plugins) {
+                if (!plugin.isDirectory())
+                    continue;
+                const plugin_path = join(mkt_path, plugin.name);
+                const versions = await readdir(plugin_path, {
+                    withFileTypes: true,
+                });
+                for (const version of versions) {
+                    if (!version.isDirectory())
+                        continue;
+                    const version_path = join(plugin_path, version.name);
+                    try {
+                        await readFile(join(version_path, '.orphaned_at'));
+                        // Has orphaned marker — safe to delete
+                        if (is_safe_cache_path(version_path)) {
+                            await rm(version_path, {
+                                recursive: true,
+                                force: true,
+                            });
+                            cleaned_paths.push(`${mkt.name}/${plugin.name}/${version.name}`);
+                        }
+                    }
+                    catch {
+                        // No marker — keep it
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Cache dir doesn't exist
+    }
+    return { cleaned: cleaned_paths.length, paths: cleaned_paths };
+}
+//# sourceMappingURL=plugin-cache.js.map

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

package/dist/core/registry.js

@@ -56,36 +56,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/index.js

@@ -4,9 +4,11 @@ import { add_server } from './commands/add-server.js';
 import { backup_config } from './commands/backup.js';
 import { edit_config } from './commands/edit-config.js';
 import { edit_plugins } from './commands/edit-plugins.js';
+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 = {};
@@ -28,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) {
@@ -61,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) {
@@ -84,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({
@@ -112,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();
@@ -145,8 +175,13 @@ 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',
+                        label: 'Manage plugin cache',
+                        hint: 'View, clear, or refresh plugin caches',
                     },
                     {
                         value: 'backup',
@@ -191,6 +226,9 @@ async function main() {
                 case 'edit-plugins':
                     await edit_plugins();
                     break;
+                case 'manage-cache':
+                    await manage_cache();
+                    break;
                 case 'backup':
                     await backup_config();
                     break;
@@ -232,8 +270,28 @@ async function main() {
         }
     }
 }
-main().catch((error) => {
-    console.error('Fatal error:', error);
-    process.exit(1);
-});
+const SUBCOMMANDS = new Set([
+    'list',
+    'enable',
+    'disable',
+    'remove',
+    'add',
+    'backup',
+    'restore',
+    'profile',
+    'plugins',
+    'cache',
+]);
+const arg = process.argv[2];
+if ((arg && SUBCOMMANDS.has(arg)) ||
+    arg === '--help' ||
+    arg === '-h') {
+    import('./cli/index.js').then((m) => m.run());
+}
+else {
+    main().catch((error) => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=index.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
  */