mcpick 0.0.15 → 0.0.17

package/dist/core/settings.js

@@ -1,4 +1,5 @@
 import { access, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 import { atomic_json_write } from '../utils/atomic-write.js';
 import { get_claude_settings_path } from '../utils/paths.js';
 export async function read_claude_settings() {
@@ -49,4 +50,194 @@ export function build_enabled_plugins(plugins) {
     }
     return result;
 }
+async function read_settings_file(path) {
+    try {
+        await access(path);
+        const content = await readFile(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+function get_settings_paths() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return [
+        {
+            scope: 'user',
+            path: resolve(home, '.claude', 'settings.json'),
+        },
+        {
+            scope: 'project',
+            path: resolve(process.cwd(), '.claude', 'settings.json'),
+        },
+        {
+            scope: 'project-local',
+            path: resolve(process.cwd(), '.claude', 'settings.local.json'),
+        },
+    ];
+}
+/**
+ * Read all hooks across all scopes (settings + plugins), flattened for display.
+ */
+export async function get_all_hooks() {
+    const entries = [];
+    // Settings-based hooks
+    for (const { scope, path } of get_settings_paths()) {
+        const data = await read_settings_file(path);
+        const hooks = data.hooks;
+        if (!hooks)
+            continue;
+        for (const [event, matchers] of Object.entries(hooks)) {
+            if (!Array.isArray(matchers))
+                continue;
+            for (let mi = 0; mi < matchers.length; mi++) {
+                const m = matchers[mi];
+                if (!m.hooks?.length)
+                    continue;
+                for (let hi = 0; hi < m.hooks.length; hi++) {
+                    entries.push({
+                        event: event,
+                        matcher: m.matcher,
+                        handler: m.hooks[hi],
+                        scope,
+                        source: scope,
+                        matcher_index: mi,
+                        hook_index: hi,
+                    });
+                }
+            }
+        }
+    }
+    // Plugin-based hooks
+    const plugin_hooks = await get_all_plugin_hooks();
+    entries.push(...plugin_hooks);
+    return entries;
+}
+/**
+ * Scan all installed plugins for hooks.json and return flattened hook entries.
+ * Checks both cache and marketplace source paths since Claude Code reads from both.
+ */
+export async function get_all_plugin_hooks() {
+    const { read_installed_plugins } = await import('./plugin-cache.js');
+    const { get_marketplaces_dir } = await import('../utils/paths.js');
+    const installed = await read_installed_plugins();
+    const entries = [];
+    const seen_hooks = new Set();
+    for (const [plugin_key, installs] of Object.entries(installed.plugins)) {
+        if (!installs?.length)
+            continue;
+        const install = installs[0];
+        const at_index = plugin_key.lastIndexOf('@');
+        const plugin_name = at_index > 0 ? plugin_key.substring(0, at_index) : plugin_key;
+        const marketplace_name = at_index > 0 ? plugin_key.substring(at_index + 1) : '';
+        // Collect all hooks.json paths for this plugin (cache + marketplace source)
+        const hooks_paths = [
+            join(install.installPath, 'hooks', 'hooks.json'),
+        ];
+        // Also check marketplace source path
+        if (marketplace_name) {
+            hooks_paths.push(join(get_marketplaces_dir(), marketplace_name, 'plugins', plugin_name, 'hooks', 'hooks.json'));
+        }
+        for (const hooks_path of hooks_paths) {
+            let hooks_data;
+            try {
+                const content = await readFile(hooks_path, 'utf-8');
+                hooks_data = JSON.parse(content);
+            }
+            catch {
+                continue;
+            }
+            const hooks = (hooks_data.hooks || hooks_data);
+            for (const [event, matchers] of Object.entries(hooks)) {
+                if (!Array.isArray(matchers))
+                    continue;
+                for (let mi = 0; mi < matchers.length; mi++) {
+                    const m = matchers[mi];
+                    if (!m.hooks?.length)
+                        continue;
+                    for (let hi = 0; hi < m.hooks.length; hi++) {
+                        // Deduplicate: same plugin + event + handler type + command
+                        const h = m.hooks[hi];
+                        const dedup_key = `${plugin_key}:${event}:${h.type}:${h.command || h.url || h.prompt}`;
+                        if (seen_hooks.has(dedup_key))
+                            continue;
+                        seen_hooks.add(dedup_key);
+                        entries.push({
+                            event: event,
+                            matcher: m.matcher,
+                            handler: h,
+                            scope: 'user',
+                            source: 'plugin',
+                            matcher_index: mi,
+                            hook_index: hi,
+                            plugin_key,
+                            hooks_json_path: hooks_path,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Remove a specific hook entry by scope/event/indices.
+ */
+export async function remove_hook(entry) {
+    const scope_path = get_settings_paths().find((s) => s.scope === entry.scope);
+    if (!scope_path)
+        throw new Error(`Unknown scope: ${entry.scope}`);
+    await atomic_json_write(scope_path.path, (existing) => {
+        const hooks = existing.hooks;
+        if (!hooks)
+            return existing;
+        const matchers = hooks[entry.event];
+        if (!matchers?.[entry.matcher_index])
+            return existing;
+        const matcher = matchers[entry.matcher_index];
+        matcher.hooks.splice(entry.hook_index, 1);
+        // Clean up empty matchers
+        if (matcher.hooks.length === 0) {
+            matchers.splice(entry.matcher_index, 1);
+        }
+        // Clean up empty events
+        if (matchers.length === 0) {
+            delete hooks[entry.event];
+        }
+        // Clean up empty hooks object
+        if (Object.keys(hooks).length === 0) {
+            delete existing.hooks;
+        }
+        return existing;
+    });
+}
+/**
+ * Add a hook to a specific scope.
+ */
+export async function add_hook(scope, event, matcher, handler) {
+    const scope_path = get_settings_paths().find((s) => s.scope === scope);
+    if (!scope_path)
+        throw new Error(`Unknown scope: ${scope}`);
+    await atomic_json_write(scope_path.path, (existing) => {
+        if (!existing.hooks)
+            existing.hooks = {};
+        const hooks = existing.hooks;
+        if (!hooks[event])
+            hooks[event] = [];
+        const matchers = hooks[event];
+        // Find existing matcher group or create new
+        const existing_matcher = matchers.find((m) => (m.matcher || undefined) === matcher);
+        if (existing_matcher) {
+            existing_matcher.hooks.push(handler);
+        }
+        else {
+            const new_matcher = { hooks: [handler] };
+            if (matcher)
+                new_matcher.matcher = matcher;
+            matchers.push(new_matcher);
+        }
+        return existing;
+    });
+}
 //# sourceMappingURL=settings.js.map

package/dist/index.js

@@ -5,6 +5,8 @@ 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 { manage_hooks } from './commands/manage-hooks.js';
+import { manage_marketplace } from './commands/manage-marketplace.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';
@@ -178,6 +180,16 @@ async function main() {
                         label: 'Manage plugins',
                         hint: 'Toggle, install, uninstall, or update plugins',
                     },
+                    {
+                        value: 'manage-marketplace',
+                        label: 'Manage marketplaces',
+                        hint: 'Add, remove, or update plugin marketplaces',
+                    },
+                    {
+                        value: 'manage-hooks',
+                        label: 'Manage hooks',
+                        hint: 'List, add, or remove event hooks',
+                    },
                     {
                         value: 'manage-cache',
                         label: 'Manage plugin cache',
@@ -226,6 +238,12 @@ async function main() {
                 case 'edit-plugins':
                     await edit_plugins();
                     break;
+                case 'manage-marketplace':
+                    await manage_marketplace();
+                    break;
+                case 'manage-hooks':
+                    await manage_hooks();
+                    break;
                 case 'manage-cache':
                     await manage_cache();
                     break;
@@ -276,6 +294,10 @@ const SUBCOMMANDS = new Set([
     'disable',
     'remove',
     'add',
+    'add-json',
+    'get',
+    'reset-project-choices',
+    'hooks',
     'backup',
     'restore',
     'profile',

package/dist/utils/claude-cli.js

@@ -192,7 +192,51 @@ 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') {
+/**
+ * Extract GitHub owner/repo from various source formats.
+ * Returns null if not a recognizable GitHub reference.
+ */
+function parse_github_repo(source) {
+    // HTTPS URL: https://github.com/owner/repo[.git]
+    const https_match = source.match(/^https?:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (https_match)
+        return { owner: https_match[1], repo: https_match[2] };
+    // SSH URL: git@github.com:owner/repo[.git]
+    const ssh_match = source.match(/^git@github\.com:([^/]+)\/([^/.]+)(?:\.git)?$/);
+    if (ssh_match)
+        return { owner: ssh_match[1], repo: ssh_match[2] };
+    // Shorthand: owner/repo (no slashes beyond the one separator)
+    const shorthand_match = source.match(/^([^/\s]+)\/([^/\s]+)$/);
+    if (shorthand_match)
+        return { owner: shorthand_match[1], repo: shorthand_match[2] };
+    return null;
+}
+/**
+ * Validate that a GitHub repository exists and is accessible.
+ * Returns an error message if validation fails, null if OK.
+ */
+async function validate_github_repo(owner, repo) {
+    try {
+        const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+            method: 'GET',
+            headers: { Accept: 'application/vnd.github.v3+json' },
+        });
+        if (response.status === 200)
+            return null;
+        if (response.status === 404) {
+            return `Repository '${owner}/${repo}' not found on GitHub. Check the name or ensure it's not private.`;
+        }
+        if (response.status === 403) {
+            return `Access denied for '${owner}/${repo}'. The repository may be private — configure a GitHub token or use SSH.`;
+        }
+        return `GitHub API returned status ${response.status} for '${owner}/${repo}'.`;
+    }
+    catch {
+        // Network error — skip validation and let the CLI attempt the clone
+        return null;
+    }
+}
+export async function marketplace_add_via_cli(source) {
     const cli_available = await check_claude_cli();
     if (!cli_available) {
         return {
@@ -200,12 +244,37 @@ export async function marketplace_add_via_cli(source, scope = 'user') {
             error: 'Claude CLI not found. Please install Claude Code CLI.',
         };
     }
+    // Validate GitHub repo exists before attempting clone
+    // Only validate shorthand (owner/repo) — explicit URLs imply the user knows the repo
+    const gh = parse_github_repo(source);
+    const is_shorthand = gh && !source.startsWith('http') && !source.startsWith('git@');
+    if (gh && is_shorthand) {
+        const validation_error = await validate_github_repo(gh.owner, gh.repo);
+        if (validation_error) {
+            return { success: false, error: validation_error };
+        }
+    }
     try {
-        await execAsync(`claude plugin marketplace add ${shell_escape(source)} --scope ${scope}`);
+        await execAsync(`claude plugin marketplace add ${shell_escape(source)}`);
         return { success: true };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : 'Unknown error';
+        // Provide clearer error messages for common failures
+        if (message.includes('SSH') ||
+            message.includes('Permission denied (publickey)')) {
+            return {
+                success: false,
+                error: `SSH authentication failed for '${source}'. Either:\n  - Configure SSH keys: https://docs.github.com/en/authentication/connecting-to-github-with-ssh\n  - Use HTTPS URL instead: https://github.com/${gh ? `${gh.owner}/${gh.repo}` : source}`,
+            };
+        }
+        if (message.includes('not found') ||
+            message.includes('does not exist')) {
+            return {
+                success: false,
+                error: `Repository '${source}' not found. Check the name and your access permissions.`,
+            };
+        }
         return {
             success: false,
             error: `Failed to add marketplace: ${message}`,
@@ -297,6 +366,98 @@ export function get_scope_description(scope) {
             return 'Global - all projects';
     }
 }
+/**
+ * Validate a plugin or marketplace manifest via Claude CLI
+ */
+export async function validate_plugin_via_cli(path) {
+    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 validate ${shell_escape(path)}`);
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Validation failed: ${message}`,
+        };
+    }
+}
+/**
+ * Get details about an MCP server via Claude CLI
+ */
+export async function mcp_get_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 { stdout } = await execAsync(`claude mcp get ${shell_escape(name)}`);
+        return { success: true, stdout: stdout.trim() };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to get server details: ${message}`,
+        };
+    }
+}
+/**
+ * Add an MCP server from raw JSON via Claude CLI
+ */
+export async function mcp_add_json_via_cli(name, json, scope = 'local') {
+    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 mcp add-json ${shell_escape(name)} ${shell_escape(json)} --scope ${scope}`);
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to add server from JSON: ${message}`,
+        };
+    }
+}
+/**
+ * Reset project-scoped MCP server choices via Claude CLI
+ */
+export async function mcp_reset_project_choices_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 {
+        await execAsync('claude mcp reset-project-choices');
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to reset project choices: ${message}`,
+        };
+    }
+}
 /**
  * Get scope options for select prompt
  */

package/dist/utils/paths.js

@@ -105,6 +105,9 @@ export function get_plugin_cache_dir() {
 export function get_marketplaces_dir() {
     return join(get_plugins_dir(), 'marketplaces');
 }
+export function get_disabled_hooks_path() {
+    return join(get_mcpick_dir(), 'disabled-hooks.json');
+}
 export function get_marketplace_manifest_path(name) {
     return join(get_marketplaces_dir(), name, '.claude-plugin', 'marketplace.json');
 }

package/package.json

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