mcpick 0.0.9 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # mcpick
 
+## 0.0.10
+
+### Patch Changes
+
+- ffe29b3: Add non-interactive CLI mode with citty for scripting and
+  LLM usage
+- fff6c0d: add plugin cache management with staleness detection and
+  cleanup
+
 ## 0.0.9
 
 ### Patch Changes

package/dist/cli/commands/add.js

@@ -0,0 +1,135 @@
+import { defineCommand } from 'citty';
+import { add_server_to_registry } from '../../core/registry.js';
+import { validate_mcp_server } from '../../core/validation.js';
+import { add_mcp_via_cli } from '../../utils/claude-cli.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'add',
+        description: 'Add a new MCP server to the registry and enable it',
+    },
+    args: {
+        name: {
+            type: 'string',
+            description: 'Server name',
+            required: true,
+        },
+        command: {
+            type: 'string',
+            description: 'Command to run (for stdio transport)',
+        },
+        args: {
+            type: 'string',
+            description: 'Comma-separated arguments (e.g. "npx,-y,mcp-sqlite")',
+        },
+        url: {
+            type: 'string',
+            description: 'URL (for sse or http transport)',
+        },
+        type: {
+            type: 'string',
+            description: 'Transport type: stdio, sse, or http (default: stdio)',
+            default: 'stdio',
+        },
+        env: {
+            type: 'string',
+            description: 'Environment variables as KEY=val,KEY=val',
+        },
+        headers: {
+            type: 'string',
+            description: 'HTTP headers as KEY=val,KEY=val',
+        },
+        description: {
+            type: 'string',
+            description: 'Server description',
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope: local, project, or user (default: local)',
+            default: 'local',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        if (!['local', 'project', 'user'].includes(scope)) {
+            error(`Invalid scope: ${scope}. Use local, project, or user.`);
+        }
+        const transport = args.type;
+        if (!['stdio', 'sse', 'http'].includes(transport)) {
+            error(`Invalid type: ${transport}. Use stdio, sse, or http.`);
+        }
+        // Build server object
+        const server_data = {
+            name: args.name,
+        };
+        if (transport === 'stdio') {
+            if (!args.command) {
+                error('--command is required for stdio transport');
+            }
+            server_data.command = args.command;
+            if (args.args) {
+                server_data.args = args.args.split(',');
+            }
+        }
+        else {
+            if (!args.url) {
+                error(`--url is required for ${transport} transport`);
+            }
+            server_data.type = transport;
+            server_data.url = args.url;
+            if (args.headers) {
+                server_data.headers = parse_key_value_pairs(args.headers);
+            }
+        }
+        if (args.env) {
+            server_data.env = parse_key_value_pairs(args.env);
+        }
+        if (args.description) {
+            server_data.description = args.description;
+        }
+        // Validate
+        let server;
+        try {
+            server = validate_mcp_server(server_data);
+        }
+        catch (err) {
+            error(`Invalid server config: ${err instanceof Error ? err.message : 'validation failed'}`);
+        }
+        // Add to registry
+        await add_server_to_registry(server);
+        // Enable via CLI
+        const result = await add_mcp_via_cli(server, scope);
+        if (args.json) {
+            output({
+                added: server.name,
+                scope,
+                cli: result.success,
+                error: result.error,
+            }, true);
+        }
+        else {
+            if (result.success) {
+                console.log(`Added '${server.name}' and enabled (scope: ${scope})`);
+            }
+            else {
+                console.log(`Added '${server.name}' to registry but CLI failed: ${result.error}`);
+            }
+        }
+    },
+});
+function parse_key_value_pairs(input) {
+    const result = {};
+    for (const pair of input.split(',')) {
+        const eq = pair.indexOf('=');
+        if (eq > 0) {
+            result[pair.substring(0, eq)] = pair.substring(eq + 1);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=add.js.map

package/dist/cli/commands/backup.js

@@ -0,0 +1,55 @@
+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 { output } from '../output.js';
+const MAX_BACKUPS = 10;
+export default defineCommand({
+    meta: {
+        name: 'backup',
+        description: 'Create a timestamped backup of MCP server config',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const current_config = await read_claude_config();
+        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);
+        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
+        }
+        const server_count = Object.keys(current_config.mcpServers || {}).length;
+        if (args.json) {
+            output({ path: backup_path, servers: server_count }, true);
+        }
+        else {
+            console.log(`Backup created: ${backup_path} (${server_count} servers)`);
+        }
+    },
+});
+//# sourceMappingURL=backup.js.map

package/dist/cli/commands/cache.js

@@ -0,0 +1,181 @@
+import { defineCommand } from 'citty';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, read_installed_plugins, refresh_all_marketplaces, } from '../../core/plugin-cache.js';
+import { error, output } from '../output.js';
+const status = defineCommand({
+    meta: {
+        name: 'status',
+        description: 'Show cached plugins with staleness info',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const plugins = await get_cached_plugins_info();
+        if (args.json) {
+            output(plugins, true);
+            return;
+        }
+        if (plugins.length === 0) {
+            console.log('No cached plugins found.');
+            return;
+        }
+        for (const p of plugins) {
+            const stale_markers = [];
+            if (p.isVersionStale) {
+                stale_markers.push(`version: ${p.installedVersion} → ${p.latestVersion}`);
+            }
+            if (p.isShaStale) {
+                stale_markers.push('commits behind');
+            }
+            if (p.orphanedVersions.length > 0) {
+                stale_markers.push(`${p.orphanedVersions.length} orphaned`);
+            }
+            const status_str = stale_markers.length > 0
+                ? `  [stale: ${stale_markers.join(', ')}]`
+                : '  [up to date]';
+            console.log(`${p.name}@${p.marketplace}  v${p.installedVersion}${status_str}`);
+        }
+    },
+});
+const clear = defineCommand({
+    meta: {
+        name: 'clear',
+        description: 'Clear plugin caches (refreshes marketplace first)',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace) — omit for all',
+            required: false,
+        },
+        all: {
+            type: 'boolean',
+            description: 'Clear all plugin caches',
+            default: false,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const installed = await read_installed_plugins();
+        const all_keys = Object.keys(installed.plugins);
+        if (all_keys.length === 0) {
+            if (args.json) {
+                output({ cleared: [], errors: [] }, true);
+            }
+            else {
+                console.log('No cached plugins to clear.');
+            }
+            return;
+        }
+        let keys_to_clear;
+        if (args.plugin) {
+            if (!installed.plugins[args.plugin]) {
+                error(`Plugin '${args.plugin}' not found in cache. Run 'mcpick cache status' to see cached plugins.`);
+            }
+            keys_to_clear = [args.plugin];
+        }
+        else if (args.all) {
+            keys_to_clear = all_keys;
+        }
+        else {
+            error('Specify a plugin key or use --all. Run "mcpick cache status" to see cached plugins.');
+        }
+        const result = await clear_plugin_caches(keys_to_clear);
+        if (args.json) {
+            output(result, true);
+        }
+        else {
+            for (const key of result.cleared) {
+                console.log(`Cleared: ${key}`);
+            }
+            for (const err of result.errors) {
+                console.error(`Error: ${err}`);
+            }
+            if (result.cleared.length > 0) {
+                console.log('\nRun /reload-plugins in Claude Code or restart your session.');
+            }
+        }
+    },
+});
+const clean_orphaned = defineCommand({
+    meta: {
+        name: 'clean-orphaned',
+        description: 'Remove orphaned plugin version directories',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await clean_orphaned_versions();
+        if (args.json) {
+            output(result, true);
+        }
+        else if (result.cleaned === 0) {
+            console.log('No orphaned versions found.');
+        }
+        else {
+            for (const p of result.paths) {
+                console.log(`Removed: ${p}`);
+            }
+            console.log(`\nCleaned ${result.cleaned} orphaned version(s).`);
+        }
+    },
+});
+const refresh = defineCommand({
+    meta: {
+        name: 'refresh',
+        description: 'Refresh all marketplace clones (git pull)',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const results = await refresh_all_marketplaces();
+        if (args.json) {
+            const data = Object.fromEntries(results);
+            output(data, true);
+            return;
+        }
+        if (results.size === 0) {
+            console.log('No marketplaces configured.');
+            return;
+        }
+        for (const [name, result] of results) {
+            if (result.success) {
+                console.log(`${name}  refreshed`);
+            }
+            else {
+                console.error(`${name}  failed: ${result.error}`);
+            }
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'cache',
+        description: 'Manage plugin cache',
+    },
+    subCommands: {
+        status,
+        clear,
+        'clean-orphaned': clean_orphaned,
+        refresh,
+    },
+});
+//# sourceMappingURL=cache.js.map

package/dist/cli/commands/disable.js

@@ -0,0 +1,33 @@
+import { defineCommand } from 'citty';
+import { remove_mcp_via_cli } from '../../utils/claude-cli.js';
+import { error } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'disable',
+        description: 'Disable an MCP server',
+    },
+    args: {
+        server: {
+            type: 'positional',
+            description: 'Server name to disable',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope: local, project, or user (default: local)',
+            default: 'local',
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        if (!['local', 'project', 'user'].includes(scope)) {
+            error(`Invalid scope: ${scope}. Use local, project, or user.`);
+        }
+        const result = await remove_mcp_via_cli(args.server);
+        if (!result.success) {
+            error(result.error || 'Failed to disable server');
+        }
+        console.log(`Disabled '${args.server}' (scope: ${scope})`);
+    },
+});
+//# sourceMappingURL=disable.js.map

package/dist/cli/commands/enable.js

@@ -0,0 +1,39 @@
+import { defineCommand } from 'citty';
+import { get_all_available_servers } from '../../core/registry.js';
+import { add_mcp_via_cli } from '../../utils/claude-cli.js';
+import { error } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'enable',
+        description: 'Enable an MCP server',
+    },
+    args: {
+        server: {
+            type: 'positional',
+            description: 'Server name to enable',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope: local, project, or user (default: local)',
+            default: 'local',
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        if (!['local', 'project', 'user'].includes(scope)) {
+            error(`Invalid scope: ${scope}. Use local, project, or user.`);
+        }
+        const all_servers = await get_all_available_servers();
+        const server = all_servers.find((s) => s.name === args.server);
+        if (!server) {
+            error(`Server '${args.server}' not found in registry. Run 'mcpick list' to see available servers.`);
+        }
+        const result = await add_mcp_via_cli(server, scope);
+        if (!result.success) {
+            error(result.error || 'Failed to enable server');
+        }
+        console.log(`Enabled '${server.name}' (scope: ${scope})`);
+    },
+});
+//# sourceMappingURL=enable.js.map

package/dist/cli/commands/list.js

@@ -0,0 +1,63 @@
+import { defineCommand } from 'citty';
+import { get_enabled_servers_for_scope } from '../../core/config.js';
+import { get_all_available_servers } from '../../core/registry.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all MCP servers and their status',
+    },
+    args: {
+        scope: {
+            type: 'string',
+            description: 'Scope to check: local, project, or user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scopes = args.scope
+            ? [args.scope]
+            : ['local', 'project', 'user'];
+        if (args.scope &&
+            !['local', 'project', 'user'].includes(args.scope)) {
+            error(`Invalid scope: ${args.scope}. Use local, project, or user.`);
+        }
+        const all_servers = await get_all_available_servers();
+        const enabled_by_scope = {};
+        for (const scope of scopes) {
+            enabled_by_scope[scope] =
+                await get_enabled_servers_for_scope(scope);
+        }
+        if (args.json) {
+            const data = all_servers.map((server) => {
+                const status = {};
+                for (const scope of scopes) {
+                    status[scope] = enabled_by_scope[scope].includes(server.name);
+                }
+                const { name, ...rest } = server;
+                return { name, ...status, ...rest };
+            });
+            output(data, true);
+        }
+        else {
+            if (all_servers.length === 0) {
+                console.log('No servers in registry.');
+                return;
+            }
+            for (const server of all_servers) {
+                const statuses = scopes
+                    .map((scope) => {
+                    const enabled = enabled_by_scope[scope].includes(server.name);
+                    return `${scope}:${enabled ? 'on' : 'off'}`;
+                })
+                    .join(' ');
+                console.log(`${server.name}  ${statuses}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=list.js.map

package/dist/cli/commands/plugins.js

@@ -0,0 +1,93 @@
+import { defineCommand } from 'citty';
+import { build_enabled_plugins, get_all_plugins, read_claude_settings, write_claude_settings, } from '../../core/settings.js';
+import { error, output } from '../output.js';
+const list = defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List all plugins and their status',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        if (args.json) {
+            output(plugins, true);
+        }
+        else {
+            if (plugins.length === 0) {
+                console.log('No plugins found.');
+                return;
+            }
+            for (const p of plugins) {
+                const status = p.enabled ? 'on' : 'off';
+                console.log(`${p.name}@${p.marketplace}  ${status}`);
+            }
+        }
+    },
+});
+const enable = defineCommand({
+    meta: {
+        name: 'enable',
+        description: 'Enable a plugin',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        const key = args.plugin;
+        const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+        if (!plugin) {
+            error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+        }
+        plugin.enabled = true;
+        const updated = build_enabled_plugins(plugins);
+        await write_claude_settings({ enabledPlugins: updated });
+        console.log(`Enabled plugin '${key}'`);
+    },
+});
+const disable = defineCommand({
+    meta: {
+        name: 'disable',
+        description: 'Disable a plugin',
+    },
+    args: {
+        plugin: {
+            type: 'positional',
+            description: 'Plugin key (name@marketplace)',
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const settings = await read_claude_settings();
+        const plugins = get_all_plugins(settings);
+        const key = args.plugin;
+        const plugin = plugins.find((p) => `${p.name}@${p.marketplace}` === key);
+        if (!plugin) {
+            error(`Plugin '${key}' not found. Run 'mcpick plugins list' to see available plugins.`);
+        }
+        plugin.enabled = false;
+        const updated = build_enabled_plugins(plugins);
+        await write_claude_settings({ enabledPlugins: updated });
+        console.log(`Disabled plugin '${key}'`);
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'plugins',
+        description: 'Manage Claude Code plugins',
+    },
+    subCommands: { list, enable, disable },
+});
+//# sourceMappingURL=plugins.js.map