mcpick 0.0.14 → 0.0.15

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # mcpick
 
+## 0.0.15
+
+### Patch Changes
+
+- 0170ea0: Add local dev workflow: mcpick dev + cache link/unlink
+- 2161258: Fix marketplace refresh, cache clear, uninstall detection;
+  add marketplace commands
+
 ## 0.0.14
 
 ### Patch Changes

package/dist/cli/commands/cache.js

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty';
-import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, link_local_plugin, list_linked_plugins, read_installed_plugins, refresh_all_marketplaces, unlink_local_plugin, } from '../../core/plugin-cache.js';
+import { clean_orphaned_versions, clear_plugin_caches, get_cached_plugins_info, link_local_plugin, list_linked_plugins, read_installed_plugins, refresh_all_marketplaces, scan_all_cache_keys, unlink_local_plugin, } from '../../core/plugin-cache.js';
 import { error, output } from '../output.js';
 const status = defineCommand({
     meta: {
@@ -65,7 +65,13 @@ const clear = defineCommand({
     },
     async run({ args }) {
         const installed = await read_installed_plugins();
-        const all_keys = Object.keys(installed.plugins);
+        const installed_keys = Object.keys(installed.plugins);
+        // When --all, also scan disk for marketplace-sourced caches
+        // not tracked in installed_plugins.json
+        const scanned_keys = args.all ? await scan_all_cache_keys() : [];
+        const all_keys = [
+            ...new Set([...installed_keys, ...scanned_keys]),
+        ];
         if (all_keys.length === 0) {
             if (args.json) {
                 output({ cleared: [], errors: [] }, true);
@@ -77,7 +83,8 @@ const clear = defineCommand({
         }
         let keys_to_clear;
         if (args.plugin) {
-            if (!installed.plugins[args.plugin]) {
+            if (!installed.plugins[args.plugin] &&
+                !scanned_keys.includes(args.plugin)) {
                 error(`Plugin '${args.plugin}' not found in cache. Run 'mcpick cache status' to see cached plugins.`);
             }
             keys_to_clear = [args.plugin];

package/dist/cli/commands/dev.js

@@ -36,9 +36,7 @@ const apply = defineCommand({
         if (scope && !['local', 'project', 'user'].includes(scope)) {
             error(`Invalid scope: ${scope}. Use local, project, or user.`);
         }
-        const cmd_args = args.args
-            ? args.args.split(',')
-            : [];
+        const cmd_args = args.args ? args.args.split(',') : [];
         const result = await apply_dev_override(args.name, args.command, cmd_args, scope);
         if (args.json) {
             output(result, true);
@@ -82,7 +80,8 @@ const restore = defineCommand({
                 output(result, true);
             }
             else {
-                if (result.restored.length === 0 && result.errors.length === 0) {
+                if (result.restored.length === 0 &&
+                    result.errors.length === 0) {
                     console.log('No dev overrides to restore.');
                 }
                 else {

package/dist/cli/commands/marketplace.js

@@ -0,0 +1,162 @@
+import { defineCommand } from 'citty';
+import { marketplace_add_via_cli, marketplace_list_via_cli, marketplace_remove_via_cli, marketplace_update_via_cli, } from '../../utils/claude-cli.js';
+import { error, output } from '../output.js';
+const list = defineCommand({
+    meta: {
+        name: 'list',
+        description: 'List configured marketplaces',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_list_via_cli();
+        if (!result.success) {
+            error(result.error || 'Unknown error');
+        }
+        if (args.json) {
+            // Try to parse CLI JSON output, fallback to raw
+            try {
+                const parsed = JSON.parse(result.stdout || '[]');
+                output(parsed, true);
+            }
+            catch {
+                output({ marketplaces: result.stdout }, true);
+            }
+        }
+        else {
+            console.log(result.stdout || 'No marketplaces configured.');
+        }
+    },
+});
+const add = defineCommand({
+    meta: {
+        name: 'add',
+        description: 'Add a marketplace from URL, path, or GitHub repo',
+    },
+    args: {
+        source: {
+            type: 'positional',
+            description: 'Marketplace source (GitHub repo, URL, or local path)',
+            required: true,
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope: user, project, or local (default: user)',
+            default: 'user',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const scope = args.scope;
+        if (!['user', 'project', 'local'].includes(scope)) {
+            error(`Invalid scope: ${scope}. Use user, project, or local.`);
+        }
+        const result = await marketplace_add_via_cli(args.source, scope);
+        if (args.json) {
+            output({
+                added: args.source,
+                scope,
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(`Marketplace added: ${args.source} (scope: ${scope})`);
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+const remove = defineCommand({
+    meta: {
+        name: 'remove',
+        description: 'Remove a marketplace',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Marketplace name to remove',
+            required: true,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_remove_via_cli(args.name);
+        if (args.json) {
+            output({
+                removed: args.name,
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(`Marketplace removed: ${args.name}`);
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+const update = defineCommand({
+    meta: {
+        name: 'update',
+        description: 'Update marketplace(s) from source',
+    },
+    args: {
+        name: {
+            type: 'positional',
+            description: 'Marketplace name to update (omit to update all)',
+            required: false,
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await marketplace_update_via_cli(args.name || undefined);
+        if (args.json) {
+            output({
+                updated: args.name || 'all',
+                success: result.success,
+                error: result.error,
+            }, true);
+        }
+        else if (result.success) {
+            console.log(args.name
+                ? `Marketplace updated: ${args.name}`
+                : 'All marketplaces updated.');
+        }
+        else {
+            error(result.error || 'Unknown error');
+        }
+    },
+});
+export default defineCommand({
+    meta: {
+        name: 'marketplace',
+        description: 'Manage Claude Code plugin marketplaces',
+    },
+    subCommands: {
+        list,
+        add,
+        remove,
+        update,
+    },
+});
+//# sourceMappingURL=marketplace.js.map

package/dist/cli/commands/plugins.js

@@ -1,4 +1,5 @@
 import { defineCommand } from 'citty';
+import { parse_plugin_key, read_known_marketplaces, } from '../../core/plugin-cache.js';
 import { build_enabled_plugins, get_all_plugins, read_claude_settings, write_claude_settings, } from '../../core/settings.js';
 import { install_plugin_via_cli, uninstall_plugin_via_cli, update_plugin_via_cli, } from '../../utils/claude-cli.js';
 import { error, output } from '../output.js';
@@ -144,6 +145,25 @@ const uninstall = defineCommand({
     },
     async run({ args }) {
         const scope = args.scope;
+        // Check if this is a marketplace-managed plugin
+        const { marketplace } = parse_plugin_key(args.plugin);
+        const known = await read_known_marketplaces();
+        if (known[marketplace]) {
+            const msg = `'${args.plugin}' is managed by marketplace '${marketplace}'.\n` +
+                `To remove the marketplace: mcpick marketplace remove ${marketplace}\n` +
+                `Or via Claude CLI: claude plugin marketplace remove ${marketplace}`;
+            if (args.json) {
+                output({
+                    success: false,
+                    error: msg,
+                    marketplace_managed: true,
+                }, true);
+            }
+            else {
+                error(msg);
+            }
+            return;
+        }
         const result = await uninstall_plugin_via_cli(args.plugin, scope);
         if (args.json) {
             output(result, true);

package/dist/cli/commands/reload.js

@@ -0,0 +1,36 @@
+import { defineCommand } from 'citty';
+import { output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'reload',
+        description: 'Reload plugins in Claude Code',
+    },
+    args: {
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const info = {
+            supported: false,
+            message: 'Claude Code does not expose a programmatic reload API.',
+            instructions: [
+                'Run /reload-plugins inside an active Claude Code session',
+                'Or restart your Claude Code session to pick up changes',
+            ],
+        };
+        if (args.json) {
+            output(info, true);
+        }
+        else {
+            console.log(info.message);
+            console.log('\nTo reload plugins:');
+            for (const instruction of info.instructions) {
+                console.log(`  - ${instruction}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=reload.js.map

package/dist/cli/index.js

@@ -16,6 +16,8 @@ const main = defineCommand({
         plugins: () => import('./commands/plugins.js').then((m) => m.default),
         cache: () => import('./commands/cache.js').then((m) => m.default),
         dev: () => import('./commands/dev.js').then((m) => m.default),
+        marketplace: () => import('./commands/marketplace.js').then((m) => m.default),
+        reload: () => import('./commands/reload.js').then((m) => m.default),
     },
 });
 export const run = () => runMain(main);

package/dist/core/dev-override.js

@@ -82,8 +82,7 @@ async function write_server_to_scope(name, server, scope) {
             if (!existing.mcpServers) {
                 existing.mcpServers = {};
             }
-            existing.mcpServers[name] =
-                server;
+            existing.mcpServers[name] = server;
             return existing;
         });
     }
@@ -100,7 +99,8 @@ async function write_server_to_scope(name, server, scope) {
             if (!projects[cwd].mcpServers) {
                 projects[cwd].mcpServers = {};
             }
-            projects[cwd].mcpServers[name] = server;
+            projects[cwd].mcpServers[name] =
+                server;
             return existing;
         });
     }

package/dist/core/plugin-cache.js

@@ -1,5 +1,5 @@
 import { exec } from 'node:child_process';
-import { lstat, readdir, readFile, readlink, rename, rm, symlink } from 'node:fs/promises';
+import { lstat, readdir, readFile, readlink, rename, rm, symlink, } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { atomic_json_write } from '../utils/atomic-write.js';
@@ -50,6 +50,51 @@ async function get_marketplace_head_sha(marketplace_path) {
         return null;
     }
 }
+/**
+ * Recover a marketplace clone stuck on a deleted branch.
+ * Resets the fetch refspec, fetches all branches, and checks out the default branch.
+ */
+async function recover_deleted_branch(dir) {
+    const q = JSON.stringify(dir);
+    try {
+        // Reset narrow refspec to fetch all branches
+        await execAsync(`git -C ${q} remote set-branches origin '*'`, {
+            timeout: 10_000,
+        });
+        await execAsync(`git -C ${q} fetch origin`, {
+            timeout: 30_000,
+        });
+        // Detect default branch
+        let default_branch = 'main';
+        try {
+            const { stdout } = await execAsync(`git -C ${q} symbolic-ref refs/remotes/origin/HEAD`, { timeout: 5_000 });
+            const match = stdout
+                .trim()
+                .match(/refs\/remotes\/origin\/(.+)/);
+            if (match)
+                default_branch = match[1];
+        }
+        catch {
+            // symbolic-ref not set — try main, then master
+            try {
+                await execAsync(`git -C ${q} rev-parse --verify origin/main`, { timeout: 5_000 });
+                default_branch = 'main';
+            }
+            catch {
+                default_branch = 'master';
+            }
+        }
+        await execAsync(`git -C ${q} checkout ${default_branch}`, {
+            timeout: 10_000,
+        });
+        await execAsync(`git -C ${q} reset --hard origin/${default_branch}`, { timeout: 10_000 });
+        return { recovered: true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        return { recovered: false, error: msg };
+    }
+}
 export async function refresh_marketplace(name, marketplace) {
     const dir = marketplace.installLocation;
     try {
@@ -58,9 +103,16 @@ export async function refresh_marketplace(name, marketplace) {
         });
         return { success: true };
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return { success: false, error: `${name}: ${message}` };
+    catch {
+        // Fast-forward failed — attempt recovery from deleted branch
+        const recovery = await recover_deleted_branch(dir);
+        if (recovery.recovered) {
+            return { success: true };
+        }
+        return {
+            success: false,
+            error: `${name}: recovery failed: ${recovery.error}`,
+        };
     }
 }
 export async function refresh_all_marketplaces() {
@@ -155,6 +207,42 @@ export async function get_cached_plugins_info() {
     }
     return results;
 }
+// --- Cache scanning ---
+/**
+ * Scan the cache directory on disk to find all plugin keys,
+ * including marketplace-sourced plugins not tracked in installed_plugins.json.
+ */
+export async function scan_all_cache_keys() {
+    const cache_dir = get_plugin_cache_dir();
+    const keys = [];
+    try {
+        const marketplaces = await readdir(cache_dir, {
+            withFileTypes: true,
+        });
+        for (const mkt of marketplaces) {
+            if (!mkt.isDirectory() && !mkt.isSymbolicLink())
+                continue;
+            const mkt_path = join(cache_dir, mkt.name);
+            try {
+                const plugins = await readdir(mkt_path, {
+                    withFileTypes: true,
+                });
+                for (const plugin of plugins) {
+                    if (!plugin.isDirectory() && !plugin.isSymbolicLink())
+                        continue;
+                    keys.push(`${plugin.name}@${mkt.name}`);
+                }
+            }
+            catch {
+                // Skip unreadable marketplace dirs
+            }
+        }
+    }
+    catch {
+        // Cache dir doesn't exist
+    }
+    return keys;
+}
 // --- Cache clearing ---
 function is_safe_cache_path(path) {
     const cache_dir = resolve(get_plugin_cache_dir());
@@ -377,7 +465,9 @@ export async function list_linked_plugins() {
     const cache_dir = get_plugin_cache_dir();
     const links = [];
     try {
-        const marketplaces = await readdir(cache_dir, { withFileTypes: true });
+        const marketplaces = await readdir(cache_dir, {
+            withFileTypes: true,
+        });
         for (const mkt of marketplaces) {
             if (!mkt.isDirectory() && !mkt.isSymbolicLink())
                 continue;

package/dist/index.js

@@ -282,6 +282,8 @@ const SUBCOMMANDS = new Set([
     'plugins',
     'cache',
     'dev',
+    'marketplace',
+    'reload',
 ]);
 const arg = process.argv[2];
 if ((arg && SUBCOMMANDS.has(arg)) ||

package/dist/utils/claude-cli.js

@@ -189,6 +189,101 @@ export async function update_plugin_via_cli(key, scope = 'user') {
         };
     }
 }
+/**
+ * Add a marketplace via Claude CLI
+ */
+export async function marketplace_add_via_cli(source, 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 marketplace add ${shell_escape(source)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to add marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * Remove a marketplace via Claude CLI
+ */
+export async function marketplace_remove_via_cli(name) {
+    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 marketplace remove ${shell_escape(name)}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to remove marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * Update marketplace(s) via Claude CLI
+ */
+export async function marketplace_update_via_cli(name) {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const cmd = name
+            ? `claude plugin marketplace update ${shell_escape(name)}`
+            : 'claude plugin marketplace update';
+        await execAsync(cmd);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to update marketplace: ${message}`,
+        };
+    }
+}
+/**
+ * List marketplaces via Claude CLI
+ */
+export async function marketplace_list_via_cli() {
+    const cli_available = await check_claude_cli();
+    if (!cli_available) {
+        return {
+            success: false,
+            error: 'Claude CLI not found. Please install Claude Code CLI.',
+        };
+    }
+    try {
+        const { stdout } = await execAsync('claude plugin marketplace list');
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to list marketplaces: ${message}`,
+        };
+    }
+}
 /**
  * Get the scope description for display
  */

package/package.json

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