mcpick 0.0.9 → 0.0.10

package/dist/cli/commands/profile.js

@@ -0,0 +1,112 @@
+import { defineCommand } from 'citty';
+import { write_claude_config } from '../../core/config.js';
+import { list_profiles, load_profile, save_profile, } from '../../core/profile.js';
+import { error, output } from '../output.js';
+const list = defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all saved profiles',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const profiles = await list_profiles();
+        if (args.json) {
+            output(profiles, true);
+        }
+        else {
+            if (profiles.length === 0) {
+                console.log('No profiles found.');
+                return;
+            }
+            for (const p of profiles) {
+                console.log(`${p.name}  (${p.serverCount} servers)`);
+            }
+        }
+    },
+});
+const load = defineCommand({
+    meta: {
+        name: 'load',
+        description: 'Load and apply a saved profile',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Profile name',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        try {
+            const config = await load_profile(args.name);
+            await write_claude_config(config);
+            const server_count = Object.keys(config.mcpServers || {}).length;
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: server_count,
+                }, true);
+            }
+            else {
+                console.log(`Profile '${args.name}' applied (${server_count} servers)`);
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to load profile');
+        }
+    },
+});
+const save = defineCommand({
+    meta: {
+        name: 'save',
+        description: 'Save current config as a profile',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Profile name',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        try {
+            const server_count = await save_profile(args.name);
+            if (args.json) {
+                output({
+                    profile: args.name,
+                    servers: server_count,
+                }, true);
+            }
+            else {
+                console.log(`Profile '${args.name}' saved (${server_count} servers)`);
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to save profile');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'profile',
+        description: 'Manage MCP server profiles',
+    },
+    subCommands: { list, load, save },
+});
+//# sourceMappingURL=profile.js.map

package/dist/cli/commands/remove.js

@@ -0,0 +1,31 @@
+import { defineCommand } from 'citty';
+import { 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({
+    meta: {
+        name: 'remove',
+        description: 'Remove an MCP server from the registry and disable it',
+    },
+    args: {
+        server: {
+            type: 'positional',
+            description: 'Server name to remove',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        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.`);
+        }
+        // Remove from registry
+        registry.servers.splice(index, 1);
+        await write_server_registry(registry);
+        // Also disable via CLI (best effort)
+        await remove_mcp_via_cli(args.server);
+        console.log(`Removed '${args.server}' from registry`);
+    },
+});
+//# sourceMappingURL=remove.js.map

package/dist/cli/commands/restore.js

@@ -0,0 +1,56 @@
+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 { 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)',
+    },
+    args: {
+        file: {
+            type: 'positional',
+            description: 'Backup filename or path (optional, defaults to latest)',
+            required: false,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    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(', ')}`);
+            }
+            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;
+        if (args.json) {
+            output({
+                restored: backup_path,
+                servers: server_count,
+            }, true);
+        }
+        else {
+            console.log(`Restored from ${backup_path} (${server_count} servers)`);
+        }
+    },
+});
+//# sourceMappingURL=restore.js.map

package/dist/cli/index.js

@@ -0,0 +1,21 @@
+import { defineCommand, runMain } from 'citty';
+const main = defineCommand({
+    meta: {
+        name: 'mcpick',
+        description: 'MCP Server Configuration Manager',
+    },
+    subCommands: {
+        list: () => import('./commands/list.js').then((m) => m.default),
+        enable: () => import('./commands/enable.js').then((m) => m.default),
+        disable: () => import('./commands/disable.js').then((m) => m.default),
+        remove: () => import('./commands/remove.js').then((m) => m.default),
+        add: () => import('./commands/add.js').then((m) => m.default),
+        backup: () => import('./commands/backup.js').then((m) => m.default),
+        restore: () => import('./commands/restore.js').then((m) => m.default),
+        profile: () => import('./commands/profile.js').then((m) => m.default),
+        plugins: () => import('./commands/plugins.js').then((m) => m.default),
+        cache: () => import('./commands/cache.js').then((m) => m.default),
+    },
+});
+export const run = () => runMain(main);
+//# sourceMappingURL=index.js.map

package/dist/cli/output.js

@@ -0,0 +1,21 @@
+export function output(data, json) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else if (typeof data === 'string') {
+        console.log(data);
+    }
+    else if (Array.isArray(data)) {
+        for (const item of data) {
+            console.log(item);
+        }
+    }
+    else {
+        console.log(data);
+    }
+}
+export function error(message) {
+    console.error(`error: ${message}`);
+    process.exit(1);
+}
+//# sourceMappingURL=output.js.map

package/dist/commands/manage-cache.js

@@ -0,0 +1,155 @@
+import { confirm, isCancel, log, multiselect, note, select, } from '@clack/prompts';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, refresh_all_marketplaces, } from '../core/plugin-cache.js';
+function format_status_line(p) {
+    const markers = [];
+    if (p.isVersionStale) {
+        markers.push(`version: ${p.installedVersion} → ${p.latestVersion}`);
+    }
+    if (p.isShaStale) {
+        markers.push('commits behind');
+    }
+    if (p.orphanedVersions.length > 0) {
+        markers.push(`${p.orphanedVersions.length} orphaned`);
+    }
+    const status = markers.length > 0
+        ? `[stale: ${markers.join(', ')}]`
+        : '[up to date]';
+    return `${p.name}@${p.marketplace}  v${p.installedVersion}  ${status}`;
+}
+async function handle_status() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins found.');
+        return;
+    }
+    const lines = plugins.map(format_status_line).join('\n');
+    note(lines, 'Plugin Cache Status');
+}
+async function handle_clear() {
+    const plugins = await get_cached_plugins_info();
+    if (plugins.length === 0) {
+        log.info('No cached plugins to clear.');
+        return;
+    }
+    const selected = await multiselect({
+        message: 'Select plugins to clear cache for:',
+        options: plugins.map((p) => {
+            const stale = p.isVersionStale || p.isShaStale;
+            return {
+                value: p.key,
+                label: `${p.name}@${p.marketplace}`,
+                hint: stale
+                    ? `v${p.installedVersion} → ${p.latestVersion ?? 'unknown'} (stale)`
+                    : `v${p.installedVersion}`,
+            };
+        }),
+        initialValues: plugins
+            .filter((p) => p.isVersionStale || p.isShaStale)
+            .map((p) => p.key),
+    });
+    if (isCancel(selected) || selected.length === 0)
+        return;
+    const should_clear = await confirm({
+        message: `Clear cache for ${selected.length} plugin(s)? This will also refresh the marketplace.`,
+    });
+    if (isCancel(should_clear) || !should_clear)
+        return;
+    const result = await clear_plugin_caches(selected);
+    for (const key of result.cleared) {
+        log.success(`Cleared: ${key}`);
+    }
+    for (const err of result.errors) {
+        log.error(`Error: ${err}`);
+    }
+    if (result.cleared.length > 0) {
+        note('Run /reload-plugins in Claude Code or restart your session to apply changes.', 'Next Steps');
+    }
+}
+async function handle_clean_orphaned() {
+    const should_clean = await confirm({
+        message: 'Remove all orphaned plugin version directories?',
+    });
+    if (isCancel(should_clean) || !should_clean)
+        return;
+    const result = await clean_orphaned_versions();
+    if (result.cleaned === 0) {
+        log.info('No orphaned versions found.');
+    }
+    else {
+        for (const p of result.paths) {
+            log.success(`Removed: ${p}`);
+        }
+        log.info(`Cleaned ${result.cleaned} orphaned version(s).`);
+    }
+}
+async function handle_refresh() {
+    const should_refresh = await confirm({
+        message: 'Refresh all marketplace clones (git pull)?',
+    });
+    if (isCancel(should_refresh) || !should_refresh)
+        return;
+    const results = await refresh_all_marketplaces();
+    if (results.size === 0) {
+        log.info('No marketplaces configured.');
+        return;
+    }
+    for (const [name, result] of results) {
+        if (result.success) {
+            log.success(`${name}: refreshed`);
+        }
+        else {
+            log.error(`${name}: ${result.error}`);
+        }
+    }
+}
+export async function manage_cache() {
+    while (true) {
+        const action = await select({
+            message: 'Plugin cache management:',
+            options: [
+                {
+                    value: 'status',
+                    label: 'View cache status',
+                    hint: 'Show plugins with staleness info',
+                },
+                {
+                    value: 'clear',
+                    label: 'Clear plugin caches',
+                    hint: 'Refresh marketplace + clear selected caches',
+                },
+                {
+                    value: 'clean-orphaned',
+                    label: 'Clean orphaned versions',
+                    hint: 'Remove old version directories',
+                },
+                {
+                    value: 'refresh',
+                    label: 'Refresh marketplaces',
+                    hint: 'Git pull all marketplace clones',
+                },
+                {
+                    value: 'back',
+                    label: 'Back',
+                    hint: 'Return to main menu',
+                },
+            ],
+        });
+        if (isCancel(action) || action === 'back')
+            return;
+        switch (action) {
+            case 'status':
+                await handle_status();
+                break;
+            case 'clear':
+                await handle_clear();
+                break;
+            case 'clean-orphaned':
+                await handle_clean_orphaned();
+                break;
+            case 'refresh':
+                await handle_refresh();
+                break;
+        }
+    }
+}
+//# sourceMappingURL=manage-cache.js.map

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