mcpick 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # mcpick
 
+## 0.0.7
+
+### Patch Changes
+
+- fb70e88: add profiles feature
+
+## 0.0.6
+
+### Patch Changes
+
+- 413ff07: Add CLAUDE_CONFIG_DIR support for custom config locations
+
 ## 0.0.5
 
 ### Patch Changes

package/README.md

@@ -74,6 +74,8 @@ McPick provides an intuitive CLI menu to:
 │  ○ Backup config
 │  ○ Add MCP server
 │  ○ Restore from backup
+│  ○ Load profile
+│  ○ Save profile
 │  ○ Exit
 └
 ```
@@ -98,14 +100,56 @@ McPick provides an intuitive CLI menu to:
 - **Easy restoration**: Restore from any previous backup with a simple
   menu
 
+### Profiles
+
+Load predefined sets of MCP servers instantly:
+
+```bash
+# Apply a profile
+mcpick --profile database
+mcpick -p database
+
+# Save current config as a profile
+mcpick --save-profile mysetup
+mcpick -s mysetup
+
+# List available profiles
+mcpick --list-profiles
+mcpick -l
+```
+
+Profiles are stored in `~/.claude/mcpick/profiles/`. You can also
+create them manually:
+
+```json
+// ~/.claude/mcpick/profiles/database.json
+{
+	"mcp-sqlite-tools": {
+		"type": "stdio",
+		"command": "npx",
+		"args": ["-y", "mcp-sqlite-tools"]
+	}
+}
+```
+
+Or use full format with `mcpServers` wrapper:
+
+```json
+{
+  "mcpServers": {
+    "server-name": { ... }
+  }
+}
+```
+
 ### Typical Workflow
 
-1. **Before a coding session**: Run MCPick and enable only relevant
-   servers (e.g., just database tools for DB work)
+1. **Before a coding session**: Run `mcpick -p <profile>` or use the
+   interactive menu to enable relevant servers
 2. **Launch Claude Code**: Run `claude` to start with your configured
    servers
-3. **Switch contexts**: Re-run MCPick to enable different servers for
-   different tasks
+3. **Switch contexts**: Run `mcpick -p <other-profile>` to quickly
+   switch server sets
 
 ### Adding New Servers
 
@@ -142,6 +186,7 @@ MCPick works with the standard Claude Code configuration format:
 - **MCPick Registry**: `~/.claude/mcpick/servers.json` (MCPick's
   server database)
 - **Backups**: `~/.claude/mcpick/backups/` (MCP configuration backups)
+- **Profiles**: `~/.claude/mcpick/profiles/` (predefined server sets)
 
 > **Note**: If your MCP servers do not appear in MCPick, ensure they
 > are configured at the global level in Claude Code
@@ -169,8 +214,6 @@ McPick is actively being developed with new features planned. See the
   [claude-code-settings-schema](https://github.com/spences10/claude-code-settings-schema)
 - **Permissions Management** - Interactive tool permission
   configuration with presets (Safe Mode, Dev Mode, Review Mode)
-- **Configuration Profiles** - Save and switch between complete
-  configuration snapshots for different workflows
 
 Have ideas for other features?
 [Open an issue](https://github.com/spences10/mcpick/issues) or check

package/dist/core/profile.js

@@ -0,0 +1,70 @@
+import { access, readFile, readdir, writeFile, } from 'node:fs/promises';
+import { ensure_directory_exists, get_profile_path, get_profiles_dir, } from '../utils/paths.js';
+import { read_claude_config } from './config.js';
+import { validate_claude_config } from './validation.js';
+export async function load_profile(name) {
+    const profile_path = get_profile_path(name);
+    try {
+        await access(profile_path);
+        const content = await readFile(profile_path, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Profile can be either full ClaudeConfig format or just mcpServers object
+        if (parsed.mcpServers) {
+            return validate_claude_config(parsed);
+        }
+        // If it's just a servers object, wrap it
+        return validate_claude_config({ mcpServers: parsed });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            throw new Error(`Profile '${name}' not found at ${profile_path}`);
+        }
+        throw error;
+    }
+}
+export async function list_profiles() {
+    const profiles_dir = get_profiles_dir();
+    try {
+        await access(profiles_dir);
+        const files = await readdir(profiles_dir);
+        const json_files = files.filter((f) => f.endsWith('.json'));
+        const profiles = [];
+        for (const file of json_files) {
+            try {
+                const path = get_profile_path(file);
+                const content = await readFile(path, 'utf-8');
+                const parsed = JSON.parse(content);
+                const servers = parsed.mcpServers || parsed;
+                profiles.push({
+                    name: file.replace('.json', ''),
+                    path,
+                    serverCount: Object.keys(servers).length,
+                });
+            }
+            catch {
+                // Skip invalid profiles
+            }
+        }
+        return profiles;
+    }
+    catch {
+        return [];
+    }
+}
+export async function save_profile(name) {
+    const config = await read_claude_config();
+    const servers = config.mcpServers || {};
+    const server_count = Object.keys(servers).length;
+    if (server_count === 0) {
+        throw new Error('No MCP servers configured to save');
+    }
+    const profiles_dir = get_profiles_dir();
+    await ensure_directory_exists(profiles_dir);
+    const profile_path = get_profile_path(name);
+    const content = JSON.stringify({ mcpServers: servers }, null, 2);
+    await writeFile(profile_path, content, 'utf-8');
+    return server_count;
+}
+//# sourceMappingURL=profile.js.map

package/dist/index.js

@@ -1,10 +1,136 @@
 #!/usr/bin/env node
-import { cancel, intro, isCancel, outro, select, } from '@clack/prompts';
+import { cancel, intro, isCancel, log, outro, select, text, } from '@clack/prompts';
 import { add_server } from './commands/add-server.js';
 import { backup_config } from './commands/backup.js';
 import { edit_config } from './commands/edit-config.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';
+function parse_args() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--profile' || args[i] === '-p') {
+            result.profile = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--save-profile' || args[i] === '-s') {
+            result.saveProfile = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--list-profiles' || args[i] === '-l') {
+            result.listProfiles = true;
+        }
+    }
+    return result;
+}
+async function apply_profile(name) {
+    intro(`MCPick - Loading profile: ${name}`);
+    try {
+        const profile_config = await load_profile(name);
+        await write_claude_config(profile_config);
+        const server_count = Object.keys(profile_config.mcpServers || {}).length;
+        log.success(`Profile '${name}' applied (${server_count} servers)`);
+        outro('Done!');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            cancel(error.message);
+        }
+        else {
+            cancel('Failed to load profile');
+        }
+        process.exit(1);
+    }
+}
+async function show_profiles() {
+    intro('MCPick - Available Profiles');
+    const profiles = await list_profiles();
+    if (profiles.length === 0) {
+        log.warn('No profiles found in ~/.claude/mcpick/profiles/');
+        log.info('Create .json files there to use profiles');
+    }
+    else {
+        for (const p of profiles) {
+            log.info(`${p.name} (${p.serverCount} servers)`);
+        }
+    }
+    outro('');
+}
+async function create_profile(name) {
+    intro(`MCPick - Saving profile: ${name}`);
+    try {
+        const server_count = await save_profile(name);
+        log.success(`Profile '${name}' saved (${server_count} servers)`);
+        outro('Done!');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            cancel(error.message);
+        }
+        else {
+            cancel('Failed to save profile');
+        }
+        process.exit(1);
+    }
+}
+async function handle_load_profile() {
+    const profiles = await list_profiles();
+    if (profiles.length === 0) {
+        log.warn('No profiles found');
+        log.info('Save a profile first or create one in ~/.claude/mcpick/profiles/');
+        return;
+    }
+    const profile_name = await select({
+        message: 'Select a profile to load:',
+        options: profiles.map((p) => ({
+            value: p.name,
+            label: p.name,
+            hint: `${p.serverCount} servers`,
+        })),
+    });
+    if (isCancel(profile_name))
+        return;
+    const profile_config = await load_profile(profile_name);
+    await write_claude_config(profile_config);
+    const server_count = Object.keys(profile_config.mcpServers || {}).length;
+    log.success(`Profile '${profile_name}' applied (${server_count} servers)`);
+}
+async function handle_save_profile() {
+    const name = await text({
+        message: 'Profile name:',
+        placeholder: 'e.g. database, web-dev, minimal',
+        validate: (value) => {
+            if (!value || value.trim().length === 0) {
+                return 'Profile name is required';
+            }
+            if (!/^[\w-]+$/.test(value)) {
+                return 'Use only letters, numbers, underscores, hyphens';
+            }
+        },
+    });
+    if (isCancel(name))
+        return;
+    const server_count = await save_profile(name);
+    log.success(`Profile '${name}' saved (${server_count} servers)`);
+}
 async function main() {
+    const args = parse_args();
+    // Handle --list-profiles
+    if (args.listProfiles) {
+        await show_profiles();
+        return;
+    }
+    // Handle --save-profile <name>
+    if (args.saveProfile) {
+        await create_profile(args.saveProfile);
+        return;
+    }
+    // Handle --profile <name>
+    if (args.profile) {
+        await apply_profile(args.profile);
+        return;
+    }
     intro('MCPick - MCP Server Configuration Manager');
     while (true) {
         try {
@@ -31,6 +157,16 @@ async function main() {
                         label: 'Restore from backup',
                         hint: 'Restore from a previous backup',
                     },
+                    {
+                        value: 'load-profile',
+                        label: 'Load profile',
+                        hint: 'Apply a saved profile',
+                    },
+                    {
+                        value: 'save-profile',
+                        label: 'Save profile',
+                        hint: 'Save current config as profile',
+                    },
                     {
                         value: 'exit',
                         label: 'Exit',
@@ -55,6 +191,12 @@ async function main() {
                 case 'restore':
                     await restore_config();
                     break;
+                case 'load-profile':
+                    await handle_load_profile();
+                    break;
+                case 'save-profile':
+                    await handle_save_profile();
+                    break;
                 case 'exit':
                     outro('Goodbye!');
                     process.exit(0);

package/dist/utils/paths.js

@@ -1,11 +1,32 @@
+import { existsSync } from 'node:fs';
 import { access, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+export function get_base_dir() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR;
+    if (configDir && configDir.length > 0 && existsSync(configDir)) {
+        return {
+            baseDir: configDir,
+            parentDir: dirname(configDir),
+            coLocatedConfig: true,
+        };
+    }
+    const defaultDir = join(homedir(), '.claude');
+    return {
+        baseDir: defaultDir,
+        parentDir: dirname(defaultDir),
+        coLocatedConfig: false,
+    };
+}
 export function get_claude_config_path() {
-    return join(homedir(), '.claude.json');
+    const { baseDir, parentDir, coLocatedConfig } = get_base_dir();
+    if (coLocatedConfig) {
+        return join(baseDir, '.claude.json');
+    }
+    return join(parentDir, '.claude.json');
 }
 export function get_mcpick_dir() {
-    return join(homedir(), '.claude', 'mcpick');
+    return join(get_base_dir().baseDir, 'mcpick');
 }
 export function get_server_registry_path() {
     return join(get_mcpick_dir(), 'servers.json');
@@ -13,6 +34,14 @@ export function get_server_registry_path() {
 export function get_backups_dir() {
     return join(get_mcpick_dir(), 'backups');
 }
+export function get_profiles_dir() {
+    return join(get_mcpick_dir(), 'profiles');
+}
+export function get_profile_path(name) {
+    // Allow .json extension or add it
+    const filename = name.endsWith('.json') ? name : `${name}.json`;
+    return join(get_profiles_dir(), filename);
+}
 export function get_backup_filename() {
     const now = new Date();
     const year = now.getFullYear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcpick",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Dynamic MCP server configuration manager for Claude Code",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,12 +21,12 @@
   "license": "MIT",
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "valibot": "^1.1.0"
+    "valibot": "^1.2.0"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.29.7",
-    "@types/node": "^24.7.0",
-    "prettier": "^3.6.2",
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^24.10.1",
+    "prettier": "^3.7.4",
     "typescript": "^5.9.3"
   },
   "scripts": {