feat(cli): add manifest generator from existing MCP configs

Add mcp-manifest-generate CLI tool to reverse-engineer manifests from Claude Code settings.json. Infers install methods from command patterns (npx→npm, uvx→pip, .exe→dotnet-tool). Converts --flag args to typed config entries (--api-key→secret). Supports --probe flag to run MCP handshake for real server name/version. Add interactive --init wizard mode. Update schema with additional validation rules. Add comprehensive CLI help and examples to README
2026-04-04 18:53:06 -04:00
parent 33b623fe68
commit 9507dc6e68
6 changed files with 716 additions and 9 deletions
--- a/bin/generate.js
+++ b/bin/generate.js
@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { readSettings, generateManifest } from '../src/generate.js';
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+${BOLD}mcp-manifest-generate${RESET} — Generate mcp-manifest.json from existing MCP server configs
+
+${BOLD}Usage:${RESET}
+  mcp-manifest-generate                              List servers in default settings
+  mcp-manifest-generate --server <name>              Generate manifest for a specific server
+  mcp-manifest-generate --init                       Interactive wizard (from scratch)
+  mcp-manifest-generate --from-settings <path>       Use a specific settings file
+  mcp-manifest-generate --server <name> --probe      Also run MCP handshake for server info
+  mcp-manifest-generate --server <name> -o <file>    Write manifest to file
+  mcp-manifest-generate --all                        Generate manifests for all servers
+
+${BOLD}Examples:${RESET}
+  mcp-manifest-generate --init
+  mcp-manifest-generate --server ironlicensing
+  mcp-manifest-generate --from-settings ~/.claude/settings.json --server gitcaddy --probe
+  mcp-manifest-generate --server ironlicensing -o mcp-manifest.json
+  mcp-manifest-generate --all -o manifests/
+
+${BOLD}Options:${RESET}
+  --init                  Interactive wizard to create a manifest from scratch
+  --from-settings <path>  Path to settings.json (default: ~/.claude/settings.json)
+  --server <name>         Server name to generate manifest for
+  --all                   Generate manifests for all servers
+  --probe                 Run MCP initialize handshake for server name/version
+  -o, --output <path>     Output file or directory
+  --json                  Output raw JSON (no colors/decoration)
+  --help                  Show this help
+`);
+  process.exit(0);
+}
+
+function getArg(name) {
+  const idx = args.indexOf(name);
+  return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+
+const settingsPath = getArg('--from-settings')
+  || join(homedir(), '.claude', 'settings.json');
+const serverName = getArg('--server');
+const outputPath = getArg('-o') || getArg('--output');
+const doProbe = args.includes('--probe');
+const doAll = args.includes('--all');
+const doInit = args.includes('--init');
+const jsonOnly = args.includes('--json');
+
+async function run() {
+  // Init wizard mode
+  if (doInit) {
+    await runInitWizard();
+    return;
+  }
+
+  // Load settings
+  if (!existsSync(settingsPath)) {
+    console.error(`${RED}Settings file not found: ${settingsPath}${RESET}`);
+    console.error(`${DIM}Default location: ~/.claude/settings.json${RESET}`);
+    process.exit(1);
+  }
+
+  let servers;
+  try {
+    servers = readSettings(settingsPath);
+  } catch (e) {
+    console.error(`${RED}Failed to read settings: ${e.message}${RESET}`);
+    process.exit(1);
+  }
+
+  const serverNames = Object.keys(servers);
+  if (serverNames.length === 0) {
+    console.error(`${YELLOW}No MCP servers found in ${settingsPath}${RESET}`);
+    process.exit(1);
+  }
+
+  // List mode — no --server or --all specified
+  if (!serverName && !doAll) {
+    console.log(`\n${BOLD}MCP servers in ${DIM}${settingsPath}${RESET}\n`);
+    for (const name of serverNames) {
+      const entry = servers[name];
+      const cmd = entry.command || '(no command)';
+      const argCount = (entry.args || []).length;
+      const envCount = Object.keys(entry.env || {}).length;
+      console.log(`  ${CYAN}${name}${RESET}`);
+      console.log(`    command: ${cmd}`);
+      if (argCount > 0) console.log(`    args: ${argCount} argument(s)`);
+      if (envCount > 0) console.log(`    env: ${envCount} variable(s)`);
+      console.log('');
+    }
+    console.log(`${DIM}Use --server <name> to generate a manifest, or --all for all servers${RESET}\n`);
+    process.exit(0);
+  }
+
+  // Generate for specific server
+  if (serverName) {
+    if (!servers[serverName]) {
+      console.error(`${RED}Server "${serverName}" not found. Available: ${serverNames.join(', ')}${RESET}`);
+      process.exit(1);
+    }
+
+    const manifest = await generateManifest(serverName, servers[serverName], { probe: doProbe });
+    outputManifest(manifest, serverName, outputPath, jsonOnly);
+    return;
+  }
+
+  // Generate for all servers
+  if (doAll) {
+    for (const name of serverNames) {
+      if (!jsonOnly) console.log(`\n${BOLD}Generating: ${CYAN}${name}${RESET}`);
+      const manifest = await generateManifest(name, servers[name], { probe: doProbe });
+      const outPath = outputPath ? join(outputPath, `${name}.mcp-manifest.json`) : null;
+      outputManifest(manifest, name, outPath, jsonOnly);
+    }
+    return;
+  }
+}
+
+function outputManifest(manifest, name, outPath, jsonOnly) {
+  const json = JSON.stringify(manifest, null, 2);
+
+  if (outPath) {
+    // Ensure directory exists for --all mode
+    const dir = outPath.endsWith('.json') ? undefined : outPath;
+    if (dir) {
+      try { mkdirSync(dir, { recursive: true }); } catch {}
+    }
+    const filePath = outPath.endsWith('.json') ? outPath : join(outPath, `${name}.mcp-manifest.json`);
+    writeFileSync(filePath, json + '\n');
+    if (!jsonOnly) console.log(`${GREEN}✓${RESET} Written to ${filePath}`);
+    return;
+  }
+
+  if (jsonOnly) {
+    console.log(json);
+    return;
+  }
+
+  console.log(`\n${BOLD}Generated mcp-manifest.json for "${name}":${RESET}\n`);
+  // Colorize JSON output
+  const colorized = json
+    .replace(/"([^"]+)":/g, `"${CYAN}$1${RESET}":`)
+    .replace(/: "([^"]+)"/g, `: "${GREEN}$1${RESET}"`)
+    .replace(/: (\d+)/g, `: ${YELLOW}$1${RESET}`);
+  console.log(colorized);
+  console.log(`\n${DIM}Review and edit the TODO fields, then save as mcp-manifest.json${RESET}`);
+  console.log(`${DIM}Validate with: mcp-manifest-validate ./mcp-manifest.json${RESET}\n`);
+}
+
+
+async function runInitWizard() {
+  const { createInterface } = await import('readline');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q, def) => new Promise(resolve => {
+    const prompt = def ? `${q} ${DIM}(${def})${RESET}: ` : `${q}: `;
+    rl.question(prompt, answer => resolve(answer.trim() || def || ''));
+  });
+
+  console.log(`\n${BOLD}MCP Manifest Generator${RESET}`);
+  console.log(`${DIM}Create a new mcp-manifest.json interactively\n${RESET}`);
+
+  // Server info
+  console.log(`${BOLD}Server Info${RESET}`);
+  const name = await ask('  Server name (lowercase, hyphens)', '');
+  const displayName = await ask('  Display name', name.split('-').map(w => w[0]?.toUpperCase() + w.slice(1)).join(' '));
+  const description = await ask('  Description', '');
+  const version = await ask('  Version', '1.0.0');
+  const author = await ask('  Author/organization', '');
+
+  // Install
+  console.log(`\n${BOLD}Installation${RESET}`);
+  console.log(`  ${DIM}Methods: npm, pip, dotnet-tool, cargo, binary, docker${RESET}`);
+  const method = await ask('  Install method', 'npm');
+  const pkg = await ask('  Package name', name);
+  const command = await ask('  Command after install', name);
+  const source = await ask('  Custom registry URL (optional)', '');
+
+  // Transport
+  console.log(`\n${BOLD}Transport${RESET}`);
+  console.log(`  ${DIM}Options: stdio, sse, streamable-http${RESET}`);
+  const transport = await ask('  Transport', 'stdio');
+  let endpoint = '';
+  if (transport !== 'stdio') {
+    endpoint = await ask('  Endpoint URL', '');
+  }
+
+  // Config
+  console.log(`\n${BOLD}Configuration${RESET}`);
+  console.log(`  ${DIM}Add config parameters your server needs. Empty name to finish.${RESET}`);
+  const config = [];
+  while (true) {
+    const key = await ask(`  Config key (empty to finish)`, '');
+    if (!key) break;
+    console.log(`    ${DIM}Types: string, secret, url, path, boolean, number${RESET}`);
+    const type = await ask(`    Type`, 'string');
+    const configDesc = await ask(`    Description`, '');
+    const required = (await ask(`    Required? (y/n)`, 'n')).toLowerCase() === 'y';
+    const envVar = await ask(`    Environment variable (optional)`, '');
+    const arg = await ask(`    CLI argument (optional, e.g. --api-key)`, '');
+    const promptText = await ask(`    User prompt text`, configDesc || key);
+
+    const entry = { key, description: configDesc, type, required, prompt: promptText };
+    if (envVar) entry.env_var = envVar;
+    if (arg) entry.arg = arg;
+    config.push(entry);
+  }
+
+  // Scope
+  console.log(`\n${BOLD}Scope${RESET}`);
+  const scope = await ask('  Scope (global, project, both)', 'global');
+
+  rl.close();
+
+  // Build manifest
+  const manifest = {
+    $schema: 'https://mcp-manifest.dev/schema/v0.1.json',
+    version: '0.1',
+    server: {
+      name,
+      displayName,
+      description,
+      version,
+      ...(author && { author })
+    },
+    install: [{
+      method,
+      package: pkg,
+      command,
+      ...(source && { source }),
+      priority: 0
+    }],
+    transport,
+    ...(endpoint && { endpoint }),
+    ...(config.length > 0 && { config }),
+    scopes: [scope],
+    settings_template: {
+      command,
+      args: config.filter(c => c.arg).flatMap(c => [c.arg, `\${${c.key}}`])
+    }
+  };
+
+  const json = JSON.stringify(manifest, null, 2);
+
+  if (outputPath) {
+    writeFileSync(outputPath, json + '\n');
+    console.log(`\n${GREEN}✓${RESET} Written to ${outputPath}`);
+  } else {
+    console.log(`\n${BOLD}Generated mcp-manifest.json:${RESET}\n`);
+    console.log(json);
+    console.log(`\n${DIM}Save as mcp-manifest.json and validate with: mcp-manifest-validate ./mcp-manifest.json${RESET}\n`);
+  }
+}
+
+run().catch(err => {
+  console.error(`${RED}Fatal: ${err.message}${RESET}`);
+  process.exit(2);
+});