dotai-cli 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotai-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Unified CLI for AI coding assistants - manage skills and MCP servers across Claude Code, Gemini CLI, Cursor, VS Code, and more",
   "main": "src/index.js",
   "type": "module",

package/src/commands/create.js

@@ -2,23 +2,76 @@ import chalk from 'chalk';
 import Enquirer from 'enquirer';
 const { prompt } = Enquirer;
 import ora from 'ora';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import { platform } from 'os';
+import fs from 'fs-extra';
+import readline from 'readline';
 import { createSkill } from '../lib/skills.js';
 
+/**
+ * Read multiline input from stdin until two empty lines or Ctrl+D
+ * Handles large paste operations properly by buffering input
+ */
+async function readMultilineInput() {
+  return new Promise((resolve) => {
+    const lines = [];
+    let emptyLineCount = 0;
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: process.stdin.isTTY,
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      if (line === '') {
+        emptyLineCount++;
+        if (emptyLineCount >= 2) {
+          rl.close();
+          return;
+        }
+      } else {
+        emptyLineCount = 0;
+      }
+      lines.push(line);
+    });
+
+    rl.on('close', () => {
+      // Remove trailing empty lines
+      while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+      }
+      const lineCount = lines.length;
+      if (lineCount > 0) {
+        console.log(chalk.green(`✓ Pasted ${lineCount} lines`));
+      }
+      resolve(lines.join('\n'));
+    });
+
+    // Handle SIGINT (Ctrl+C) gracefully
+    rl.on('SIGINT', () => {
+      rl.close();
+    });
+
+    // Handle errors
+    rl.on('error', (err) => {
+      console.error(chalk.red(`Input error: ${err.message}`));
+      rl.close();
+    });
+  });
+}
+
 /**
  * Get the command to open a file in default editor
  */
 function getEditorCommand() {
-  // Check for $EDITOR environment variable first
   if (process.env.EDITOR) {
     return process.env.EDITOR;
   }
-
-  // Fall back to platform defaults
   switch (platform()) {
     case 'darwin':
-      return 'open -t'; // Opens in default text editor on Mac
+      return 'open -t';
     case 'win32':
       return 'notepad';
     default:
@@ -34,11 +87,42 @@ function openInEditor(filePath) {
   const parts = editor.split(' ');
   const cmd = parts[0];
   const args = [...parts.slice(1), filePath];
+  return spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+}
+
+/**
+ * Copy text to clipboard (cross-platform)
+ */
+function copyToClipboard(text) {
+  try {
+    if (platform() === 'darwin') {
+      execSync('pbcopy', { input: text });
+    } else if (platform() === 'win32') {
+      execSync('clip', { input: text });
+    } else {
+      // Linux - try xclip or xsel
+      try {
+        execSync('xclip -selection clipboard', { input: text });
+      } catch {
+        execSync('xsel --clipboard --input', { input: text });
+      }
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Generate AI prompt for skill creation
+ */
+function generateAIPrompt(skillName, description, details) {
+  return `Create a SKILL.md for: ${skillName}
+${description}
+${details}
 
-  return spawn(cmd, args, {
-    detached: true,
-    stdio: 'ignore'
-  }).unref();
+Format: YAML frontmatter (name, description) + markdown instructions.
+Keep it short and actionable (under 100 lines).`;
 }
 
 export async function createCommand(name, options) {
@@ -49,33 +133,19 @@ export async function createCommand(name, options) {
 
   // Interactive mode if name not provided
   if (!skillName) {
-    const answers = await prompt([
-      {
-        type: 'input',
-        name: 'name',
-        message: 'Skill name (lowercase, hyphens allowed):',
-        validate: (value) => {
-          if (!value) return 'Name is required';
-          if (!/^[a-z0-9-]+$/.test(value)) {
-            return 'Name must be lowercase with hyphens only';
-          }
-          return true;
-        }
-      },
-      {
-        type: 'input',
-        name: 'description',
-        message: 'Short description for auto-discovery (max 200 chars):',
-        validate: (value) => {
-          if (!value) return 'Description is required';
-          if (value.length > 200) return 'Description must be 200 characters or less';
-          return true;
+    const { name } = await prompt({
+      type: 'input',
+      name: 'name',
+      message: 'Skill name (lowercase, hyphens allowed):',
+      validate: (value) => {
+        if (!value) return 'Name is required';
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return 'Name must be lowercase with hyphens only';
         }
+        return true;
       }
-    ]);
-
-    skillName = answers.name;
-    description = answers.description;
+    });
+    skillName = name;
   }
 
   // Validate inputs
@@ -84,11 +154,85 @@ export async function createCommand(name, options) {
     process.exit(1);
   }
 
+  // Use provided description or generate from name
   if (!description) {
-    console.error(chalk.red('Error: Description is required (use -d or --description)'));
-    process.exit(1);
+    description = skillName.replace(/-/g, ' ');
   }
 
+  // Ask how they want to create instructions
+  const { method } = await prompt({
+    type: 'select',
+    name: 'method',
+    message: 'How do you want to write the skill instructions?',
+    choices: [
+      { name: 'ai', message: '🤖 Generate with AI (ChatGPT, Claude, Gemini, etc)' },
+      { name: 'manual', message: '✏️  Write manually (opens editor with template)' }
+    ]
+  });
+
+  if (method === 'ai') {
+    const { details } = await prompt({
+      type: 'input',
+      name: 'details',
+      message: 'What should this skill do?'
+    });
+
+    const aiPrompt = generateAIPrompt(skillName, description, details || '');
+
+    // Try to copy to clipboard
+    const copied = copyToClipboard(aiPrompt);
+
+    if (copied) {
+      console.log(chalk.green('\n✓ Prompt copied to clipboard!\n'));
+    } else {
+      console.log(chalk.yellow('\nPrompt:\n'));
+      console.log(chalk.dim('─'.repeat(40)));
+      console.log(aiPrompt);
+      console.log(chalk.dim('─'.repeat(40)));
+    }
+
+    console.log('Paste into any AI (ChatGPT, Claude, Gemini, etc), then paste the result here.\n');
+
+    const { hasContent } = await prompt({
+      type: 'confirm',
+      name: 'hasContent',
+      message: 'Ready to paste AI-generated content?',
+      initial: false
+    });
+
+    if (hasContent) {
+      console.log(chalk.dim('\nPaste content, then press Enter twice:\n'));
+
+      // Read multiline input using readline
+      const content = await readMultilineInput();
+
+      if (content && content.trim()) {
+        const spinner = ora('Creating skill...').start();
+        try {
+          const result = await createSkill(skillName, description, '');
+          // Write the pasted content directly
+          await fs.writeFile(result.skillMdPath, content.trim(), 'utf-8');
+          spinner.succeed(chalk.green(`Skill '${skillName}' created!`));
+          console.log(chalk.dim(`Location: ${result.path}`));
+          console.log(chalk.yellow('\nInstall with:'));
+          console.log(`  ${chalk.cyan(`dotai skill install ${skillName}`)}\n`);
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed: ${err.message}`));
+        }
+      } else {
+        console.log(chalk.yellow('\nNo content provided. Creating with template instead...'));
+        await createWithTemplate(skillName, description);
+      }
+    } else {
+      console.log(chalk.dim(`\nRun again when ready: ${chalk.cyan(`dotai skill create ${skillName}`)}\n`));
+    }
+  } else {
+    // Manual creation
+    await createWithTemplate(skillName, description);
+  }
+}
+
+async function createWithTemplate(skillName, description) {
   const spinner = ora('Creating skill...').start();
 
   try {
@@ -97,7 +241,6 @@ export async function createCommand(name, options) {
 
     console.log(chalk.dim(`\nLocation: ${result.path}`));
 
-    // Ask if user wants to open in editor
     const { openEditor } = await prompt({
       type: 'confirm',
       name: 'openEditor',

package/src/commands/mcp.js

@@ -0,0 +1,310 @@
+import chalk from 'chalk';
+import Enquirer from 'enquirer';
+const { prompt } = Enquirer;
+import ora from 'ora';
+import {
+  addMcpServer,
+  removeMcpServer,
+  listMcpServers,
+  syncMcpToAllProviders,
+  getMcpInstallStatus,
+  getMcpConfigPath
+} from '../lib/mcp.js';
+import { mcpProviders, getMcpProviderIds } from '../providers/mcp.js';
+
+/**
+ * Add an MCP server
+ */
+export async function mcpAddCommand(options) {
+  console.log(chalk.bold('\n➕ Add MCP Server\n'));
+
+  const answers = await prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Server name (e.g., github, filesystem):',
+      validate: (value) => {
+        if (!value) return 'Name is required';
+        if (!/^[a-z0-9-_]+$/i.test(value)) {
+          return 'Name must be alphanumeric with hyphens/underscores';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'select',
+      name: 'type',
+      message: 'Server type:',
+      choices: [
+        { name: 'stdio', message: 'stdio - Local command (most common)' },
+        { name: 'sse', message: 'sse - Server-sent events (remote)' },
+        { name: 'http', message: 'http - HTTP endpoint (remote)' }
+      ]
+    }
+  ]);
+
+  let serverConfig = {};
+
+  if (answers.type === 'stdio') {
+    const stdioAnswers = await prompt([
+      {
+        type: 'input',
+        name: 'command',
+        message: 'Command (e.g., npx, node, python):',
+        validate: (value) => value ? true : 'Command is required'
+      },
+      {
+        type: 'input',
+        name: 'args',
+        message: 'Arguments (comma-separated, e.g., -y,@modelcontextprotocol/server-github):',
+      },
+      {
+        type: 'input',
+        name: 'env',
+        message: 'Environment variables (KEY=value,KEY2=value2):',
+      }
+    ]);
+
+    serverConfig = {
+      command: stdioAnswers.command,
+      args: stdioAnswers.args ? stdioAnswers.args.split(',').map(a => a.trim()) : []
+    };
+
+    if (stdioAnswers.env) {
+      serverConfig.env = {};
+      stdioAnswers.env.split(',').forEach(pair => {
+        const [key, ...valueParts] = pair.split('=');
+        if (key && valueParts.length > 0) {
+          serverConfig.env[key.trim()] = valueParts.join('=').trim();
+        }
+      });
+    }
+  } else {
+    // SSE or HTTP
+    const remoteAnswers = await prompt([
+      {
+        type: 'input',
+        name: 'url',
+        message: 'Server URL:',
+        validate: (value) => value ? true : 'URL is required'
+      },
+      {
+        type: 'input',
+        name: 'headers',
+        message: 'Headers (KEY=value,KEY2=value2):',
+      }
+    ]);
+
+    serverConfig = {
+      url: remoteAnswers.url
+    };
+
+    if (remoteAnswers.headers) {
+      serverConfig.headers = {};
+      remoteAnswers.headers.split(',').forEach(pair => {
+        const [key, ...valueParts] = pair.split('=');
+        if (key && valueParts.length > 0) {
+          serverConfig.headers[key.trim()] = valueParts.join('=').trim();
+        }
+      });
+    }
+  }
+
+  const spinner = ora('Adding MCP server...').start();
+
+  try {
+    await addMcpServer(answers.name, serverConfig);
+    spinner.succeed(chalk.green(`Added '${answers.name}'`));
+
+    console.log(chalk.dim(`\nStored in: ${getMcpConfigPath()}`));
+
+    const { syncNow } = await prompt({
+      type: 'confirm',
+      name: 'syncNow',
+      message: 'Sync to all providers now?',
+      initial: true
+    });
+
+    if (syncNow) {
+      await mcpSyncCommand({});
+    } else {
+      console.log(chalk.yellow(`\nRun ${chalk.cyan('dotai mcp sync')} to deploy to all apps\n`));
+    }
+
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed: ${err.message}`));
+  }
+}
+
+/**
+ * List MCP servers
+ */
+export async function mcpListCommand(options) {
+  console.log(chalk.bold('\n📋 MCP Servers\n'));
+
+  const servers = await listMcpServers();
+  const serverNames = Object.keys(servers);
+
+  if (serverNames.length === 0) {
+    console.log(chalk.yellow('No MCP servers configured.'));
+    console.log(`\nAdd one with: ${chalk.cyan('dotai mcp add')}\n`);
+    return;
+  }
+
+  for (const name of serverNames) {
+    const config = servers[name];
+    console.log(chalk.bold.white(name));
+
+    if (config.command) {
+      console.log(chalk.dim(`  Command: ${config.command} ${(config.args || []).join(' ')}`));
+    }
+    if (config.url) {
+      console.log(chalk.dim(`  URL: ${config.url}`));
+    }
+
+    if (options.verbose) {
+      const status = await getMcpInstallStatus(name);
+      const installed = Object.entries(status)
+        .filter(([_, s]) => s.installed)
+        .map(([_, s]) => s.name);
+
+      if (installed.length > 0) {
+        console.log(chalk.green(`  Synced to: ${installed.join(', ')}`));
+      } else {
+        console.log(chalk.yellow('  Not synced yet'));
+      }
+    }
+
+    console.log('');
+  }
+
+  console.log(chalk.dim(`Total: ${serverNames.length} server(s)`));
+  console.log(chalk.dim(`Config: ${getMcpConfigPath()}\n`));
+
+  if (!options.verbose) {
+    console.log(chalk.dim(`Use ${chalk.cyan('dotai mcp list -v')} to see sync status\n`));
+  }
+}
+
+/**
+ * Sync MCP servers to all providers
+ */
+export async function mcpSyncCommand(options) {
+  console.log(chalk.bold('\n🔄 Sync MCP Servers\n'));
+
+  const servers = await listMcpServers();
+  const serverCount = Object.keys(servers).length;
+
+  if (serverCount === 0) {
+    console.log(chalk.yellow('No MCP servers to sync.'));
+    console.log(`\nAdd one with: ${chalk.cyan('dotai mcp add')}\n`);
+    return;
+  }
+
+  // Determine target providers
+  let targetProviders = options.providers
+    ? options.providers.split(',').map(p => p.trim())
+    : getMcpProviderIds();
+
+  console.log(chalk.dim(`Syncing ${serverCount} server(s) to ${targetProviders.length} app(s)...\n`));
+
+  const results = await syncMcpToAllProviders(targetProviders);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const result of results) {
+    const provider = mcpProviders[result.providerId];
+    if (result.success && result.synced > 0) {
+      successCount++;
+      console.log(chalk.green(`  ✓ ${provider.name}`));
+      console.log(chalk.dim(`    ${result.path}`));
+    } else if (result.success && result.synced === 0) {
+      console.log(chalk.dim(`  - ${provider.name} (no servers)`));
+    } else {
+      failCount++;
+      console.log(chalk.red(`  ✗ ${provider.name}: ${result.error}`));
+    }
+  }
+
+  console.log('');
+  if (successCount > 0) {
+    console.log(chalk.green(`Synced to ${successCount} app(s)`));
+  }
+  if (failCount > 0) {
+    console.log(chalk.red(`Failed for ${failCount} app(s)`));
+  }
+  console.log('');
+}
+
+/**
+ * Remove an MCP server
+ */
+export async function mcpRemoveCommand(serverName, options) {
+  console.log(chalk.bold('\n🗑️  Remove MCP Server\n'));
+
+  // If no name provided, show picker
+  if (!serverName) {
+    const servers = await listMcpServers();
+    const serverNames = Object.keys(servers);
+
+    if (serverNames.length === 0) {
+      console.log(chalk.yellow('No MCP servers configured.'));
+      return;
+    }
+
+    const answer = await prompt({
+      type: 'select',
+      name: 'server',
+      message: 'Select server to remove:',
+      choices: serverNames.map(name => ({
+        name,
+        message: `${name} - ${servers[name].command || servers[name].url || 'configured'}`
+      }))
+    });
+    serverName = answer.server;
+  }
+
+  // Confirm
+  if (!options.yes) {
+    const { confirm } = await prompt({
+      type: 'confirm',
+      name: 'confirm',
+      message: `Remove '${serverName}' from central config?`,
+      initial: false
+    });
+
+    if (!confirm) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+  }
+
+  const removed = await removeMcpServer(serverName);
+
+  if (removed) {
+    console.log(chalk.green(`\n✓ Removed '${serverName}' from central config`));
+    console.log(chalk.yellow('\nNote: This does not remove from already-synced providers.'));
+    console.log(chalk.dim('Run sync again to update providers, or manually remove from each app.\n'));
+  } else {
+    console.log(chalk.red(`Server '${serverName}' not found`));
+  }
+}
+
+/**
+ * Show MCP providers
+ */
+export async function mcpProvidersCommand() {
+  console.log(chalk.bold('\n🔌 MCP Providers\n'));
+
+  for (const provider of Object.values(mcpProviders)) {
+    console.log(chalk.bold.white(provider.name) + chalk.dim(` (${provider.id})`));
+    console.log(chalk.dim(`  ${provider.description}`));
+    console.log(chalk.dim(`  Config: ${provider.globalPath()}`));
+    console.log(chalk.dim(`  Key: ${provider.configKey}`));
+    if (provider.note) {
+      console.log(chalk.yellow(`  Note: ${provider.note}`));
+    }
+    console.log('');
+  }
+}

package/src/index.js

@@ -10,6 +10,7 @@ import { syncCommand } from './commands/sync.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { configCommand, enableCommand, disableCommand } from './commands/config.js';
 import { openCommand, openRepoCommand } from './commands/open.js';
+import { mcpAddCommand, mcpListCommand, mcpSyncCommand, mcpRemoveCommand, mcpProvidersCommand } from './commands/mcp.js';
 
 const program = new Command();
 
@@ -19,7 +20,7 @@ await initConfig();
 program
   .name('dotai')
   .description('Dotfiles for AI - manage skills & MCP servers across all your AI coding assistants')
-  .version('1.0.0');
+  .version('1.0.1');
 
 // Skill subcommand
 const skill = program.command('skill').description('Manage AI agent skills');
@@ -69,30 +70,42 @@ skill
   .option('-f, --file', 'Open SKILL.md file directly')
   .action(openCommand);
 
-// MCP subcommand (placeholder for now)
-const mcp = program.command('mcp').description('Manage MCP servers (coming soon)');
+// MCP subcommand
+const mcp = program.command('mcp').description('Manage MCP servers across all apps');
 
 mcp
   .command('add')
-  .description('Add an MCP server (coming soon)')
-  .action(() => {
-    console.log(chalk.yellow('\nMCP management coming soon!\n'));
-    console.log(chalk.dim('This will let you configure MCP servers once and sync to:'));
-    console.log(chalk.dim('  • Claude Code    • Claude Desktop   • Cursor'));
-    console.log(chalk.dim('  • VS Code        • Cline            • Windsurf\n'));
-  });
+  .description('Add an MCP server to your config')
+  .action(mcpAddCommand);
 
 mcp
   .command('list')
-  .description('List MCP servers (coming soon)')
-  .action(() => {
-    console.log(chalk.yellow('\nMCP management coming soon!\n'));
-  });
+  .alias('ls')
+  .description('List configured MCP servers')
+  .option('-v, --verbose', 'Show sync status')
+  .action(mcpListCommand);
+
+mcp
+  .command('sync')
+  .description('Sync MCP servers to all apps')
+  .option('-p, --providers <list>', 'Comma-separated list of providers')
+  .action(mcpSyncCommand);
+
+mcp
+  .command('remove [server]')
+  .description('Remove an MCP server')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(mcpRemoveCommand);
+
+mcp
+  .command('providers')
+  .description('List supported MCP apps')
+  .action(mcpProvidersCommand);
 
 // Config commands
 program
   .command('providers')
-  .description('List all supported providers')
+  .description('List all supported skill providers')
   .action(listProvidersCommand);
 
 program
@@ -122,7 +135,7 @@ program.parse();
 if (!process.argv.slice(2).length) {
   console.log(chalk.bold(`
   ╔═══════════════════════════════════════════════════════════╗
-  ║                        dotai v1.0.0                       ║
+  ║                        dotai v1.0.1                       ║
   ║         Dotfiles for AI - Skills & MCP in one place       ║
   ╚═══════════════════════════════════════════════════════════╝
   `));
@@ -133,9 +146,10 @@ if (!process.argv.slice(2).length) {
   console.log(`    ${chalk.cyan('dotai skill list')}           List your skills`);
   console.log(`    ${chalk.cyan('dotai skill sync')}           Sync all skills\n`);
 
-  console.log(chalk.bold('  MCP Servers - coming soon:'));
-  console.log(`    ${chalk.dim('dotai mcp add')}              Add an MCP server`);
-  console.log(`    ${chalk.dim('dotai mcp sync')}             Sync to all apps\n`);
+  console.log(chalk.bold('  MCP Servers - sync across Claude, Cursor, VS Code & more:'));
+  console.log(`    ${chalk.cyan('dotai mcp add')}              Add an MCP server`);
+  console.log(`    ${chalk.cyan('dotai mcp list')}             List your servers`);
+  console.log(`    ${chalk.cyan('dotai mcp sync')}             Sync to all apps\n`);
 
   console.log(chalk.dim('  Run "dotai --help" for all commands\n'));
 }

package/src/lib/mcp.js

@@ -0,0 +1,201 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import { getConfigDir } from './paths.js';
+import { mcpProviders, getMcpProviderIds } from '../providers/mcp.js';
+
+/**
+ * Get the central MCP config file path
+ */
+export function getMcpConfigPath() {
+  return join(getConfigDir(), 'mcp_servers.json');
+}
+
+/**
+ * Load central MCP config
+ */
+export async function loadMcpConfig() {
+  const configPath = getMcpConfigPath();
+
+  if (!await fs.pathExists(configPath)) {
+    return { mcpServers: {} };
+  }
+
+  try {
+    return await fs.readJson(configPath);
+  } catch (err) {
+    return { mcpServers: {} };
+  }
+}
+
+/**
+ * Save central MCP config
+ */
+export async function saveMcpConfig(config) {
+  const configPath = getMcpConfigPath();
+  await fs.ensureDir(getConfigDir());
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+/**
+ * Add an MCP server to central config
+ */
+export async function addMcpServer(name, serverConfig) {
+  const config = await loadMcpConfig();
+  config.mcpServers[name] = serverConfig;
+  await saveMcpConfig(config);
+  return config;
+}
+
+/**
+ * Remove an MCP server from central config
+ */
+export async function removeMcpServer(name) {
+  const config = await loadMcpConfig();
+  if (config.mcpServers[name]) {
+    delete config.mcpServers[name];
+    await saveMcpConfig(config);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * List all MCP servers in central config
+ */
+export async function listMcpServers() {
+  const config = await loadMcpConfig();
+  return config.mcpServers || {};
+}
+
+/**
+ * Read a provider's MCP config file
+ */
+export async function readProviderMcpConfig(providerId) {
+  const provider = mcpProviders[providerId];
+  if (!provider) return null;
+
+  const configPath = provider.globalPath();
+
+  if (!await fs.pathExists(configPath)) {
+    return { [provider.configKey]: {} };
+  }
+
+  try {
+    const content = await fs.readJson(configPath);
+    return content;
+  } catch (err) {
+    return { [provider.configKey]: {} };
+  }
+}
+
+/**
+ * Write to a provider's MCP config file
+ */
+export async function writeProviderMcpConfig(providerId, servers) {
+  const provider = mcpProviders[providerId];
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerId}`);
+  }
+
+  const configPath = provider.globalPath();
+  const configKey = provider.configKey;
+
+  // Ensure directory exists
+  await fs.ensureDir(join(configPath, '..'));
+
+  // Read existing config to preserve other settings
+  let existingConfig = {};
+  if (await fs.pathExists(configPath)) {
+    try {
+      existingConfig = await fs.readJson(configPath);
+    } catch (err) {
+      existingConfig = {};
+    }
+  }
+
+  // Merge MCP servers
+  existingConfig[configKey] = {
+    ...(existingConfig[configKey] || {}),
+    ...servers
+  };
+
+  await fs.writeJson(configPath, existingConfig, { spaces: 2 });
+  return configPath;
+}
+
+/**
+ * Sync all MCP servers to a specific provider
+ */
+export async function syncMcpToProvider(providerId) {
+  const provider = mcpProviders[providerId];
+  if (!provider) {
+    throw new Error(`Unknown provider: ${providerId}`);
+  }
+
+  const servers = await listMcpServers();
+
+  if (Object.keys(servers).length === 0) {
+    return { synced: 0, path: null };
+  }
+
+  const configPath = await writeProviderMcpConfig(providerId, servers);
+
+  return {
+    synced: Object.keys(servers).length,
+    path: configPath
+  };
+}
+
+/**
+ * Sync all MCP servers to all enabled providers
+ */
+export async function syncMcpToAllProviders(providerIds = null) {
+  const targetProviders = providerIds || getMcpProviderIds();
+  const results = [];
+
+  for (const providerId of targetProviders) {
+    try {
+      const result = await syncMcpToProvider(providerId);
+      results.push({
+        providerId,
+        success: true,
+        ...result
+      });
+    } catch (err) {
+      results.push({
+        providerId,
+        success: false,
+        error: err.message
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get MCP server installation status across providers
+ */
+export async function getMcpInstallStatus(serverName) {
+  const status = {};
+
+  for (const [providerId, provider] of Object.entries(mcpProviders)) {
+    try {
+      const config = await readProviderMcpConfig(providerId);
+      const servers = config[provider.configKey] || {};
+      status[providerId] = {
+        name: provider.name,
+        installed: !!servers[serverName],
+        path: provider.globalPath()
+      };
+    } catch (err) {
+      status[providerId] = {
+        name: provider.name,
+        installed: false,
+        error: err.message
+      };
+    }
+  }
+
+  return status;
+}