mcpick 0.0.17 → 0.0.18

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # mcpick
 
+## 0.0.18
+
+### Patch Changes
+
+- 58ff00f: Add clone command and skip redundant stdio transport flag
+- 7f277da: redact env keys when listing
+- b52fcbd: Show available CLI commands hint in TUI intro
+
 ## 0.0.17
 
 ### Patch Changes

package/dist/cli/commands/clone.js

@@ -0,0 +1,108 @@
+import { defineCommand } from 'citty';
+import { detect_server_scope, find_server_in_scope, } from '../../core/config.js';
+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 { redact_server } from '../../utils/redact.js';
+import { error, output } from '../output.js';
+export default defineCommand({
+    meta: {
+        name: 'clone',
+        description: 'Clone an existing MCP server config with a new name, optionally overriding command/args',
+    },
+    args: {
+        source: {
+            type: 'positional',
+            description: 'Source server name to clone from',
+            required: true,
+        },
+        name: {
+            type: 'positional',
+            description: 'New server name',
+            required: true,
+        },
+        command: {
+            type: 'string',
+            description: 'Override command (e.g. "node" for local dev)',
+        },
+        args: {
+            type: 'string',
+            description: 'Override comma-separated arguments',
+        },
+        scope: {
+            type: 'string',
+            description: 'Scope for new server (default: same as source)',
+        },
+        json: {
+            type: 'boolean',
+            description: 'Output as JSON',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        if (args.scope &&
+            !['local', 'project', 'user'].includes(args.scope)) {
+            error(`Invalid scope: ${args.scope}. Use local, project, or user.`);
+        }
+        // Find the source server
+        const scope = args.scope;
+        let found;
+        if (scope) {
+            found = await find_server_in_scope(args.source, scope);
+        }
+        else {
+            found = await detect_server_scope(args.source);
+        }
+        if (!found) {
+            error(`Server '${args.source}' not found${scope ? ` in ${scope} scope` : ' in any scope'}`);
+        }
+        const target_scope = args.scope || found.scope;
+        // Clone the config, applying overrides
+        const cloned = {
+            ...found.server,
+            name: args.name,
+        };
+        if (args.command) {
+            cloned.command = args.command;
+            // When overriding command, clear url/type if switching from http/sse to stdio
+            delete cloned.url;
+            if (cloned.type === 'sse' || cloned.type === 'http') {
+                delete cloned.type;
+            }
+        }
+        if (args.args) {
+            cloned.args = args.args.split(',');
+        }
+        // Validate
+        let server;
+        try {
+            server = validate_mcp_server(cloned);
+        }
+        catch (err) {
+            error(`Invalid cloned 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, target_scope);
+        if (args.json) {
+            output({
+                cloned: server.name,
+                from: args.source,
+                scope: target_scope,
+                server: redact_server(server),
+                cli: result.success,
+                error: result.error,
+            }, true);
+        }
+        else {
+            if (result.success) {
+                console.log(`Cloned '${args.source}' → '${server.name}' (scope: ${target_scope})`);
+            }
+            else {
+                console.log(`Cloned '${args.source}' → '${server.name}' to registry but CLI failed: ${result.error}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=clone.js.map

package/dist/cli/commands/dev.js

@@ -1,5 +1,6 @@
 import { defineCommand } from 'citty';
 import { apply_dev_override, list_dev_overrides, restore_all_dev_overrides, restore_dev_override, } from '../../core/dev-override.js';
+import { redact_server_base } from '../../utils/redact.js';
 import { error, output } from '../output.js';
 const apply = defineCommand({
     meta: {
@@ -126,7 +127,12 @@ const list = defineCommand({
     async run({ args }) {
         const overrides = await list_dev_overrides();
         if (args.json) {
-            output(overrides, true);
+            const redacted = overrides.map((o) => ({
+                ...o,
+                original: redact_server_base(o.original),
+                dev: redact_server_base(o.dev),
+            }));
+            output(redacted, true);
             return;
         }
         if (overrides.length === 0) {

package/dist/cli/commands/list.js

@@ -1,6 +1,7 @@
 import { defineCommand } from 'citty';
 import { get_enabled_servers_for_scope } from '../../core/config.js';
 import { get_all_available_servers } from '../../core/registry.js';
+import { redact_server } from '../../utils/redact.js';
 import { error, output } from '../output.js';
 export default defineCommand({
     meta: {
@@ -38,7 +39,7 @@ export default defineCommand({
                 for (const scope of scopes) {
                     status[scope] = enabled_by_scope[scope].includes(server.name);
                 }
-                const { name, ...rest } = server;
+                const { name, ...rest } = redact_server(server);
                 return { name, ...status, ...rest };
             });
             output(data, true);

package/dist/cli/index.js

@@ -11,6 +11,7 @@ const main = defineCommand({
         remove: () => import('./commands/remove.js').then((m) => m.default),
         add: () => import('./commands/add.js').then((m) => m.default),
         'add-json': () => import('./commands/add-json.js').then((m) => m.default),
+        clone: () => import('./commands/clone.js').then((m) => m.default),
         get: () => import('./commands/get.js').then((m) => m.default),
         'reset-project-choices': () => import('./commands/reset-project-choices.js').then((m) => m.default),
         backup: () => import('./commands/backup.js').then((m) => m.default),

package/dist/core/config.js

@@ -42,6 +42,60 @@ export function create_config_from_servers(selected_servers) {
     });
     return { mcpServers: mcp_servers };
 }
+/**
+ * Find a server's full config in a specific scope.
+ */
+export async function find_server_in_scope(name, scope) {
+    if (scope === 'user' || scope === 'local') {
+        const config_path = get_claude_config_path();
+        try {
+            await access(config_path);
+            const content = await readFile(config_path, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (scope === 'user') {
+                const server = parsed.mcpServers?.[name];
+                if (server)
+                    return { server, scope: 'user' };
+            }
+            else {
+                const cwd = get_current_project_path();
+                const server = parsed.projects?.[cwd]?.mcpServers?.[name];
+                if (server)
+                    return { server, scope: 'local' };
+            }
+        }
+        catch {
+            // File doesn't exist
+        }
+    }
+    else if (scope === 'project') {
+        const mcp_path = get_project_mcp_json_path();
+        try {
+            await access(mcp_path);
+            const content = await readFile(mcp_path, 'utf-8');
+            const parsed = JSON.parse(content);
+            const server = parsed.mcpServers?.[name];
+            if (server)
+                return { server, scope: 'project' };
+        }
+        catch {
+            // File doesn't exist
+        }
+    }
+    return null;
+}
+/**
+ * Auto-detect which scope a server lives in.
+ * Searches local → project → user.
+ */
+export async function detect_server_scope(name) {
+    for (const scope of ['local', 'project', 'user']) {
+        const result = await find_server_in_scope(name, scope);
+        if (result)
+            return result;
+    }
+    return null;
+}
 /**
  * Read full Claude config including projects section
  */

package/dist/core/dev-override.js

@@ -1,6 +1,7 @@
-import { access, readFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { atomic_json_write } from '../utils/atomic-write.js';
 import { get_claude_config_path, get_current_project_path, get_dev_overrides_path, get_project_mcp_json_path, } from '../utils/paths.js';
+import { detect_server_scope, find_server_in_scope, } from './config.js';
 const EMPTY_OVERRIDES = {
     version: 1,
     overrides: {},
@@ -17,62 +18,6 @@ export async function read_dev_overrides() {
 async function write_dev_overrides(data) {
     await atomic_json_write(get_dev_overrides_path(), () => data);
 }
-/**
- * Read full config for a given scope and return the server entry if found.
- * Returns { config, server, scope } or null.
- */
-async function find_server_in_scope(name, scope) {
-    if (scope === 'user' || scope === 'local') {
-        const config_path = get_claude_config_path();
-        try {
-            await access(config_path);
-            const content = await readFile(config_path, 'utf-8');
-            const parsed = JSON.parse(content);
-            if (scope === 'user') {
-                const server = parsed.mcpServers?.[name];
-                if (server)
-                    return { server, scope: 'user' };
-            }
-            else {
-                // local scope: projects[cwd].mcpServers
-                const cwd = get_current_project_path();
-                const server = parsed.projects?.[cwd]?.mcpServers?.[name];
-                if (server)
-                    return { server, scope: 'local' };
-            }
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    else if (scope === 'project') {
-        const mcp_path = get_project_mcp_json_path();
-        try {
-            await access(mcp_path);
-            const content = await readFile(mcp_path, 'utf-8');
-            const parsed = JSON.parse(content);
-            const server = parsed.mcpServers?.[name];
-            if (server)
-                return { server, scope: 'project' };
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    return null;
-}
-/**
- * Auto-detect which scope a server lives in.
- * Searches local → project → user.
- */
-async function detect_server_scope(name) {
-    for (const scope of ['local', 'project', 'user']) {
-        const result = await find_server_in_scope(name, scope);
-        if (result)
-            return result;
-    }
-    return null;
-}
 /**
  * Write a server config into the appropriate scope config file.
  */

package/dist/index.js

@@ -165,6 +165,7 @@ async function main() {
         return;
     }
     intro('MCPick - MCP Server Configuration Manager');
+    log.info('CLI: mcpick <command> --help | Commands: list, add, clone, enable, disable, remove, get, dev, profile, plugins, hooks, backup, restore');
     while (true) {
         try {
             const action = await select({
@@ -295,6 +296,7 @@ const SUBCOMMANDS = new Set([
     'remove',
     'add',
     'add-json',
+    'clone',
     'get',
     'reset-project-choices',
     'hooks',

package/dist/utils/claude-cli.js

@@ -34,9 +34,11 @@ function build_add_command(server, scope) {
     const parts = ['claude', 'mcp', 'add'];
     // Server name
     parts.push(shell_escape(server.name));
-    // Transport type
+    // Transport type (only specify if non-default)
     const transport = server.type || 'stdio';
-    parts.push('--transport', transport);
+    if (transport !== 'stdio') {
+        parts.push('--transport', transport);
+    }
     // Scope
     parts.push('--scope', scope);
     // Handle different transport types

package/dist/utils/redact.js

@@ -0,0 +1,28 @@
+/**
+ * Redact sensitive values (env, headers) from a server config.
+ * Shows key names but replaces values with "***".
+ */
+export function redact_server_base(server) {
+    const redacted = { ...server };
+    if ('env' in redacted && redacted.env) {
+        redacted.env = redact_record(redacted.env);
+    }
+    if ('headers' in redacted && redacted.headers) {
+        redacted.headers = redact_record(redacted.headers);
+    }
+    return redacted;
+}
+export function redact_server(server) {
+    return {
+        ...redact_server_base(server),
+        name: server.name,
+    };
+}
+function redact_record(record) {
+    const redacted = {};
+    for (const key of Object.keys(record)) {
+        redacted[key] = '***';
+    }
+    return redacted;
+}
+//# sourceMappingURL=redact.js.map

package/package.json

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