MCP配置管理工具

npm install mcp-config-ts

npx mcp-config-ts validate

import {
  loadConfig,
  saveConfig,
  validateConfig,
  addServer,
  removeServer,
  getServer,
  listServers,
  createManager,
} from 'mcp-config-ts';

// Load a config file (synchronous)
const config = loadConfig('.mcp.json');

// Validate the config
const result = await validateConfig(config, { level: 3 });
console.log(result.valid);            // true or false
console.log(result.completenessScore); // 0-100

// Add a server (mutates config in place)
addServer(config, 'my-server', {
  type: 'stdio',
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir'],
});

// Save the config (synchronous, creates parent dirs automatically)
saveConfig(config);

// Remove a server
removeServer(config, 'my-server');

// List all server names (sorted alphabetically)
const names = listServers(config); // ['filesystem', 'github', ...]

// Get a single server entry
const entry = getServer(config, 'github'); // ServerEntry | undefined

const config = loadConfig('/path/to/project/.mcp.json');
console.log(config.filePath);  // absolute path
console.log(config.servers);   // Record<string, ServerEntry>

addServer(config, 'new-server', { type: 'stdio', command: 'node', args: ['server.js'] });
saveConfig(config); // writes to config.filePath

interface ValidationResult {
  valid: boolean;             // true only when no error-severity checks fail
  configPath: string;         // path to the validated config file
  checks: ValidationCheck[];  // individual check results
  summary: {
    total: number;
    passed: number;
    failed: number;
    warnings: number;
  };
  completenessScore: number;  // 0-100
}

const result = await validateConfig(config, { level: 2 });
if (!result.valid) {
  for (const check of result.checks.filter(c => !c.passed)) {
    console.error(`[${check.severity}] ${check.id}: ${check.message}`);
  }
}

const manager = createManager({ configPath: '.mcp.json' });
await manager.load();

manager.add('github', {
  type: 'stdio',
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-github'],
  env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN! },
});

const result = await manager.validate();
console.log(result.completenessScore);

await manager.save();

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "remote-api": {
      "url": "https://mcp.example.com/api",
      "headers": {
        "Authorization": "Bearer token"
      }
    }
  }
}

import { ConfigNotFoundError, ConfigParseError, MCPConfigError } from 'mcp-config-ts';

try {
  loadConfig('/missing/.mcp.json');
} catch (err) {
  if (err instanceof ConfigNotFoundError) {
    console.error(err.code);       // 'CONFIG_NOT_FOUND'
    console.error(err.configPath); // '/missing/.mcp.json'
  }
}

try {
  loadConfig('/bad-json/.mcp.json');
} catch (err) {
  if (err instanceof ConfigParseError) {
    console.error(err.code);       // 'CONFIG_PARSE_ERROR'
    console.error(err.configPath); // '/bad-json/.mcp.json'
    console.error(err.parseError); // original SyntaxError, if available
  }
}

try {
  // any mcp-config-ts operation
} catch (err) {
  if (err instanceof MCPConfigError) {
    console.error(`[${err.code}] ${err.message}`);
  }
}

// Original file: { "theme": "dark", "mcpServers": { ... } }
const config = loadConfig('claude_desktop_config.json');
addServer(config, 'new-server', { type: 'stdio', command: 'node', args: ['srv.js'] });
saveConfig(config);
// Written file still contains "theme": "dark"

const manager = createManager({ configPath: '.mcp.json' });
await manager.load();

// Check before mutating
if (!manager.has('github')) {
  manager.add('github', {
    type: 'stdio',
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-github'],
    env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN! },
  });
}

// Validate before saving
const result = await manager.validate({ level: 3 });
if (result.valid) {
  await manager.save();
} else {
  console.error('Validation failed:', result.summary);
}

import { loadConfig, validateConfig } from 'mcp-config-ts';

const config = loadConfig('.mcp.json');
const result = await validateConfig(config, { level: 3 });

if (!result.valid) {
  console.error(`Validation failed (score: ${result.completenessScore}/100)`);
  for (const check of result.checks.filter(c => !c.passed)) {
    console.error(`  [${check.severity}] ${check.id}: ${check.message}`);
  }
  process.exit(1);
}

import { saveConfig } from 'mcp-config-ts';
import type { MCPConfig } from 'mcp-config-ts';

const config: MCPConfig = {
  servers: {
    filesystem: {
      type: 'stdio',
      command: 'npx',
      args: ['-y', '@modelcontextprotocol/server-filesystem', '/workspace'],
    },
    github: {
      type: 'stdio',
      command: 'npx',
      args: ['-y', '@modelcontextprotocol/server-github'],
      env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN! },
    },
  },
  filePath: '/path/to/project/.mcp.json',
};

saveConfig(config);

mcp-config validate [--config <path>] [--level <1-3>] [--format json]
    Validate the MCP config file. Exits with code 1 if validation fails.

mcp-config add <name> [--command <cmd>] [--args <args...>] [--url <url>] [--env KEY=VAL]
    Add a server to the config. Supports registry lookup by name.

mcp-config list [--all] [--format json]
    List servers in the config. Use --all to scan all known config locations.

mcp-config sync <source> <target> [--strategy skip|overwrite|merge-env] [--dry-run]
    Sync servers from one config to another.

mcp-config search <query> [--npm] [--limit <n>]
    Search for MCP servers in the built-in registry and npm.

mcp-config doctor [--check-npm] [--check-env] [--format json]
    Run comprehensive diagnostics on the config.

mcp-config init [--with <servers...>] [--force]
    Create a new .mcp.json config file.

import type {
  MCPConfig,
  StdioServerEntry,
  HttpServerEntry,
  ServerEntry,
  ValidationCheck,
  ValidationResult,
  SyncOptions,
  SyncResult,
  ServerInfo,
  DiscoverOptions,
  ManagerOptions,
  ConfigManager,
  RegistryEntry,
} from 'mcp-config-ts';