mcpick 0.0.8 → 0.0.10

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/settings.js

@@ -0,0 +1,59 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { get_claude_settings_path } from '../utils/paths.js';
+export async function read_claude_settings() {
+    const settings_path = get_claude_settings_path();
+    try {
+        await access(settings_path);
+        const content = await readFile(settings_path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+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');
+}
+/**
+ * Parse enabledPlugins into structured list.
+ * Keys are in format "plugin-name@marketplace-name"
+ */
+export function get_all_plugins(settings) {
+    const enabled_plugins = settings.enabledPlugins || {};
+    return Object.entries(enabled_plugins).map(([key, enabled]) => {
+        const at_index = key.lastIndexOf('@');
+        const name = at_index > 0 ? key.substring(0, at_index) : key;
+        const marketplace = at_index > 0 ? key.substring(at_index + 1) : 'unknown';
+        return { name, marketplace, enabled };
+    });
+}
+/**
+ * Build the enabledPlugins record from a list of PluginInfo
+ */
+export function build_enabled_plugins(plugins) {
+    const result = {};
+    for (const plugin of plugins) {
+        const key = `${plugin.name}@${plugin.marketplace}`;
+        result[key] = plugin.enabled;
+    }
+    return result;
+}
+//# sourceMappingURL=settings.js.map

package/dist/index.js

@@ -3,6 +3,8 @@ import { cancel, intro, isCancel, log, outro, select, text, } from '@clack/promp
 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';
@@ -142,6 +144,16 @@ async function main() {
                         label: 'Enable / Disable MCP servers',
                         hint: 'Toggle MCP servers on/off',
                     },
+                    {
+                        value: 'edit-plugins',
+                        label: 'Enable / Disable plugins',
+                        hint: 'Toggle Claude Code plugins on/off',
+                    },
+                    {
+                        value: 'manage-cache',
+                        label: 'Manage plugin cache',
+                        hint: 'View, clear, or refresh plugin caches',
+                    },
                     {
                         value: 'backup',
                         label: 'Backup config',
@@ -182,6 +194,12 @@ async function main() {
                 case 'edit-config':
                     await edit_config();
                     break;
+                case 'edit-plugins':
+                    await edit_plugins();
+                    break;
+                case 'manage-cache':
+                    await manage_cache();
+                    break;
                 case 'backup':
                     await backup_config();
                     break;
@@ -223,8 +241,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/paths.js

@@ -25,6 +25,9 @@ export function get_claude_config_path() {
     }
     return join(parentDir, '.claude.json');
 }
+export function get_claude_settings_path() {
+    return join(get_base_dir().baseDir, 'settings.json');
+}
 export function get_mcpick_dir() {
     return join(get_base_dir().baseDir, 'mcpick');
 }
@@ -78,4 +81,22 @@ export function get_project_mcp_json_path() {
 export function get_global_mcp_json_path() {
     return join(homedir(), '.mcp.json');
 }
+export function get_plugins_dir() {
+    return join(get_base_dir().baseDir, 'plugins');
+}
+export function get_installed_plugins_path() {
+    return join(get_plugins_dir(), 'installed_plugins.json');
+}
+export function get_known_marketplaces_path() {
+    return join(get_plugins_dir(), 'known_marketplaces.json');
+}
+export function get_plugin_cache_dir() {
+    return join(get_plugins_dir(), 'cache');
+}
+export function get_marketplaces_dir() {
+    return join(get_plugins_dir(), 'marketplaces');
+}
+export function get_marketplace_manifest_path(name) {
+    return join(get_marketplaces_dir(), name, '.claude-plugin', 'marketplace.json');
+}
 //# sourceMappingURL=paths.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcpick",
-  "version": "0.0.8",
-  "description": "Dynamic MCP server configuration manager for Claude Code",
+  "version": "0.0.10",
+  "description": "Dynamic MCP server and plugin configuration manager for Claude Code",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
@@ -20,13 +20,14 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
-    "valibot": "^1.2.0"
+    "@clack/prompts": "^1.1.0",
+    "citty": "^0.2.1",
+    "valibot": "^1.3.1"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.29.8",
-    "@types/node": "^24.10.1",
-    "prettier": "^3.7.4",
+    "@changesets/cli": "^2.30.0",
+    "@types/node": "^25.5.0",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3"
   },
   "scripts": {

package/dist/commands/launch.js

@@ -1,21 +0,0 @@
-import { outro } from '@clack/prompts';
-import { execSync } from 'node:child_process';
-export async function launch_claude_code() {
-    try {
-        outro('Launching Claude Code...');
-        // Replace the current process with claude using exec
-        // This ensures the terminal stays valid and Claude gets full control
-        execSync('claude', {
-            stdio: 'inherit',
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && 'status' in error) {
-            // Claude exited normally, just return
-            return;
-        }
-        // Only throw for actual errors (not exit codes)
-        throw new Error(`Failed to launch Claude Code: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-//# sourceMappingURL=launch.js.map