mcpick 0.0.18 → 0.0.20

package/dist/core/registry.js

@@ -1,121 +0,0 @@
-import { access, readdir, readFile, writeFile, } from 'node:fs/promises';
-import { join } from 'node:path';
-import { ensure_directory_exists, get_backups_dir, get_mcpick_dir, get_server_registry_path, } from '../utils/paths.js';
-import { validate_server_registry } from './validation.js';
-export async function read_server_registry() {
-    const registry_path = get_server_registry_path();
-    try {
-        await access(registry_path);
-        const registry_content = await readFile(registry_path, 'utf-8');
-        const parsed_registry = JSON.parse(registry_content);
-        return validate_server_registry(parsed_registry);
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            await ensure_directory_exists(get_mcpick_dir());
-            const default_registry = { servers: [] };
-            await write_server_registry(default_registry);
-            return default_registry;
-        }
-        throw error;
-    }
-}
-export async function write_server_registry(registry) {
-    const registry_path = get_server_registry_path();
-    await ensure_directory_exists(get_mcpick_dir());
-    const registry_content = JSON.stringify(registry, null, 2);
-    await writeFile(registry_path, registry_content, 'utf-8');
-}
-export async function add_server_to_registry(server) {
-    const registry = await read_server_registry();
-    const existing_index = registry.servers.findIndex((s) => s.name === server.name);
-    if (existing_index >= 0) {
-        registry.servers[existing_index] = server;
-    }
-    else {
-        registry.servers.push(server);
-    }
-    await write_server_registry(registry);
-}
-export async function get_all_available_servers() {
-    const { get_enabled_servers, read_claude_config } = await import('./config.js');
-    const registry = await read_server_registry();
-    const config = await read_claude_config();
-    const config_servers = get_enabled_servers(config);
-    // Merge: config is the live truth, so update registry entries with config data
-    const config_by_name = new Map(config_servers.map((s) => [s.name, s]));
-    const known_names = new Set();
-    let registry_updated = false;
-    for (let i = 0; i < registry.servers.length; i++) {
-        const name = registry.servers[i].name;
-        known_names.add(name);
-        const config_server = config_by_name.get(name);
-        if (config_server) {
-            registry.servers[i] = config_server;
-            registry_updated = true;
-        }
-    }
-    for (const server of config_servers) {
-        if (!known_names.has(server.name)) {
-            registry.servers.push(server);
-            registry_updated = true;
-        }
-    }
-    // Persist updated data back to registry so it survives disable/enable cycles
-    if (registry_updated) {
-        await write_server_registry(registry);
-    }
-    return registry.servers;
-}
-export async function sync_servers_to_registry(servers) {
-    const registry = await read_server_registry();
-    servers.forEach((server) => {
-        const existing_index = registry.servers.findIndex((s) => s.name === server.name);
-        if (existing_index >= 0) {
-            registry.servers[existing_index] = server;
-        }
-        else {
-            registry.servers.push(server);
-        }
-    });
-    await write_server_registry(registry);
-}
-function parse_backups(prefix, pattern) {
-    return async () => {
-        const backups_dir = get_backups_dir();
-        try {
-            await access(backups_dir);
-            const files = await readdir(backups_dir);
-            const backup_files = files
-                .filter((file) => file.startsWith(prefix) && file.endsWith('.json'))
-                .map((file) => {
-                const timestamp_match = file.match(pattern);
-                if (!timestamp_match)
-                    return null;
-                const [, year, month, day, hour, minute, second] = timestamp_match;
-                const timestamp = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
-                return {
-                    filename: file,
-                    timestamp,
-                    path: join(backups_dir, file),
-                };
-            })
-                .filter((backup) => backup !== null)
-                .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-            return backup_files;
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                'code' in error &&
-                error.code === 'ENOENT') {
-                return [];
-            }
-            throw error;
-        }
-    };
-}
-export const list_backups = parse_backups('mcp-servers-', /mcp-servers-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
-export const list_plugin_backups = parse_backups('plugins-', /plugins-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})(\d{2})\.json/);
-//# sourceMappingURL=registry.js.map

package/dist/core/settings.js

@@ -1,243 +0,0 @@
-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() {
-    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) {
-    await atomic_json_write(get_claude_settings_path(), (existing) => {
-        for (const [key, value] of Object.entries(updates)) {
-            existing[key] = value;
-        }
-        return existing;
-    });
-}
-/**
- * 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;
-}
-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/core/validation.js

@@ -1,49 +0,0 @@
-import * as v from 'valibot';
-export const mcp_server_schema_stdio = v.object({
-    type: v.optional(v.literal('stdio')),
-    command: v.pipe(v.string(), v.minLength(1)),
-    args: v.optional(v.array(v.string())),
-    env: v.optional(v.record(v.string(), v.string())),
-    description: v.optional(v.string()),
-});
-export const mcp_server_schema_sse = v.object({
-    type: v.literal('sse'),
-    env: v.optional(v.record(v.string(), v.string())),
-    url: v.pipe(v.string(), v.minLength(1)),
-    headers: v.optional(v.record(v.string(), v.string())),
-    description: v.optional(v.string()),
-});
-export const mcp_server_schema_http = v.object({
-    type: v.literal('http'),
-    env: v.optional(v.record(v.string(), v.string())),
-    url: v.pipe(v.string(), v.minLength(1)),
-    headers: v.optional(v.record(v.string(), v.string())),
-    description: v.optional(v.string()),
-});
-export const mcp_server_schema_base = v.union([
-    mcp_server_schema_stdio,
-    mcp_server_schema_sse,
-    mcp_server_schema_http,
-]);
-export const mcp_server_schema = v.intersect([
-    v.object({
-        name: v.pipe(v.string(), v.minLength(1)),
-    }),
-    mcp_server_schema_base,
-]);
-export const claude_config_schema = v.object({
-    mcpServers: v.optional(v.record(v.string(), mcp_server_schema_base)),
-});
-export const server_registry_schema = v.object({
-    servers: v.array(mcp_server_schema),
-});
-export function validate_mcp_server(data) {
-    return v.parse(mcp_server_schema, data);
-}
-export function validate_claude_config(data) {
-    return v.parse(claude_config_schema, data);
-}
-export function validate_server_registry(data) {
-    return v.parse(server_registry_schema, data);
-}
-//# sourceMappingURL=validation.js.map

package/dist/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/utils/atomic-write.js

@@ -1,27 +0,0 @@
-import { readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-/**
- * Atomically write a JSON file with fresh-read merging.
- *
- * 1. Re-reads the file right before writing to pick up concurrent changes
- * 2. Applies the merge function to the freshest data
- * 3. Writes to a temp file, then renames (atomic on same filesystem)
- */
-export async function atomic_json_write(file_path, merge) {
-    // Read the freshest version right before writing
-    let existing = {};
-    try {
-        const content = await readFile(file_path, 'utf-8');
-        existing = JSON.parse(content);
-    }
-    catch {
-        // File doesn't exist or invalid — start fresh
-    }
-    const merged = merge(existing);
-    const content = JSON.stringify(merged, null, 2);
-    // Write to temp file then rename for atomicity
-    const tmp_path = join(dirname(file_path), `.${Date.now()}.tmp`);
-    await writeFile(tmp_path, content, 'utf-8');
-    await rename(tmp_path, file_path);
-}
-//# sourceMappingURL=atomic-write.js.map