github-to-mcp-monorepo 1.0.0

package/packages/registry/src/popular/twilio.json

@@ -0,0 +1,40 @@
+{
+  "id": "twilio-mcp",
+  "name": "Twilio",
+  "description": "Twilio API - send SMS, make calls, and manage communication services",
+  "sourceRepo": "twilio/twilio-node",
+  "sourceUrl": "https://github.com/twilio/twilio-node",
+  "version": "1.0.0",
+  "sourceVersion": "v5.0.0",
+  "toolCount": 8,
+  "tools": [
+    { "name": "send_sms", "description": "Send an SMS message", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "list_messages", "description": "List sent/received messages", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "get_message", "description": "Get a message by SID", "source": "openapi", "paramCount": 1, "requiresAuth": true },
+    { "name": "make_call", "description": "Initiate a phone call", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "list_calls", "description": "List call records", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "list_phone_numbers", "description": "List available phone numbers", "source": "openapi", "paramCount": 3, "requiresAuth": true },
+    { "name": "lookup_phone_number", "description": "Lookup phone number details", "source": "openapi", "paramCount": 2, "requiresAuth": true },
+    { "name": "send_whatsapp", "description": "Send a WhatsApp message", "source": "openapi", "paramCount": 3, "requiresAuth": true }
+  ],
+  "categories": ["communication", "sms", "api"],
+  "tags": ["twilio", "sms", "voice", "calls", "whatsapp", "messaging"],
+  "popularity": 9840,
+  "lastUpdated": "2026-01-15T00:00:00.000Z",
+  "createdAt": "2025-06-01T00:00:00.000Z",
+  "generatedCode": {
+    "typescript": "import { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\nimport { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';\n\nconst TWILIO_ACCOUNT_SID = process.env.TWILIO_ACCOUNT_SID;\nconst TWILIO_AUTH_TOKEN = process.env.TWILIO_AUTH_TOKEN;\n\nif (!TWILIO_ACCOUNT_SID || !TWILIO_AUTH_TOKEN) {\n  console.error('Error: TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN environment variables are required');\n  process.exit(1);\n}\n\nconst server = new Server({ name: 'twilio-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });\n\nasync function twilioRequest(endpoint: string, method: string = 'GET', body?: Record<string, string>) {\n  const auth = Buffer.from(`${TWILIO_ACCOUNT_SID}:${TWILIO_AUTH_TOKEN}`).toString('base64');\n  const response = await fetch(`https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}${endpoint}`, {\n    method,\n    headers: {\n      'Authorization': `Basic ${auth}`,\n      'Content-Type': 'application/x-www-form-urlencoded',\n    },\n    body: body ? new URLSearchParams(body).toString() : undefined,\n  });\n  if (!response.ok) {\n    const error = await response.json();\n    throw new Error(error.message || 'Twilio API error');\n  }\n  return response.json();\n}\n\nconst tools = [\n  { name: 'send_sms', description: 'Send an SMS', inputSchema: { type: 'object', properties: { to: { type: 'string' }, from: { type: 'string' }, body: { type: 'string' }, status_callback: { type: 'string' } }, required: ['to', 'from', 'body'] } },\n  { name: 'list_messages', description: 'List messages', inputSchema: { type: 'object', properties: { to: { type: 'string' }, from: { type: 'string' }, date_sent: { type: 'string' }, page_size: { type: 'number' } } } },\n  { name: 'get_message', description: 'Get a message', inputSchema: { type: 'object', properties: { message_sid: { type: 'string' } }, required: ['message_sid'] } },\n  { name: 'make_call', description: 'Make a call', inputSchema: { type: 'object', properties: { to: { type: 'string' }, from: { type: 'string' }, url: { type: 'string' }, twiml: { type: 'string' } }, required: ['to', 'from'] } },\n  { name: 'list_calls', description: 'List calls', inputSchema: { type: 'object', properties: { to: { type: 'string' }, from: { type: 'string' }, status: { type: 'string' }, page_size: { type: 'number' } } } },\n  { name: 'list_phone_numbers', description: 'List phone numbers', inputSchema: { type: 'object', properties: { country_code: { type: 'string' }, type: { type: 'string' }, page_size: { type: 'number' } } } },\n  { name: 'send_whatsapp', description: 'Send WhatsApp message', inputSchema: { type: 'object', properties: { to: { type: 'string', description: 'WhatsApp number with whatsapp: prefix' }, from: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'from', 'body'] } },\n];\n\nserver.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));\n\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n  try {\n    let result;\n    const a = args as Record<string, string>;\n    switch (name) {\n      case 'send_sms': result = await twilioRequest('/Messages.json', 'POST', { To: a.to, From: a.from, Body: a.body }); break;\n      case 'list_messages': result = await twilioRequest('/Messages.json'); break;\n      case 'get_message': result = await twilioRequest(`/Messages/${a.message_sid}.json`); break;\n      case 'make_call': result = await twilioRequest('/Calls.json', 'POST', { To: a.to, From: a.from, Url: a.url || '', Twiml: a.twiml || '' }); break;\n      case 'list_calls': result = await twilioRequest('/Calls.json'); break;\n      case 'list_phone_numbers': result = await twilioRequest('/IncomingPhoneNumbers.json'); break;\n      case 'send_whatsapp': result = await twilioRequest('/Messages.json', 'POST', { To: a.to, From: a.from, Body: a.body }); break;\n      default: throw new Error(`Unknown tool: ${name}`);\n    }\n    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };\n  } catch (error) {\n    return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };\n  }\n});\n\nasync function main() {\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n}\n\nmain().catch(console.error);\n"
+  },
+  "configs": {
+    "claude": { "mcpServers": { "twilio": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "TWILIO_ACCOUNT_SID": "${TWILIO_ACCOUNT_SID}", "TWILIO_AUTH_TOKEN": "${TWILIO_AUTH_TOKEN}" } } } },
+    "cursor": { "mcpServers": { "twilio": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "TWILIO_ACCOUNT_SID": "${TWILIO_ACCOUNT_SID}", "TWILIO_AUTH_TOKEN": "${TWILIO_AUTH_TOKEN}" } } } },
+    "vscode": { "mcpServers": { "twilio": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "TWILIO_ACCOUNT_SID": "${TWILIO_ACCOUNT_SID}", "TWILIO_AUTH_TOKEN": "${TWILIO_AUTH_TOKEN}" } } } }
+  },
+  "quality": { "overall": 85, "schemaCompleteness": 86, "documentation": 84, "examples": 82, "authHandling": 88, "parameterTypes": 85 },
+  "auth": [{ "type": "http", "scheme": "basic", "envVar": "TWILIO_ACCOUNT_SID", "instructions": "Get your credentials from https://console.twilio.com" }],
+  "docsUrl": "https://www.twilio.com/docs",
+  "apiDocsUrl": "https://www.twilio.com/docs/api",
+  "iconUrl": "https://www.twilio.com/favicon.ico",
+  "verified": true,
+  "author": "github-to-mcp"
+}

package/packages/registry/src/popular/vercel.json

@@ -0,0 +1,40 @@
+{
+  "id": "vercel-mcp",
+  "name": "Vercel",
+  "description": "Vercel API - manage deployments, domains, projects, and serverless functions",
+  "sourceRepo": "vercel/vercel",
+  "sourceUrl": "https://github.com/vercel/vercel",
+  "version": "1.0.0",
+  "sourceVersion": "v33.0.0",
+  "toolCount": 8,
+  "tools": [
+    { "name": "list_deployments", "description": "List all deployments", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "get_deployment", "description": "Get deployment details", "source": "openapi", "paramCount": 1, "requiresAuth": true },
+    { "name": "create_deployment", "description": "Create a new deployment", "source": "openapi", "paramCount": 4, "requiresAuth": true },
+    { "name": "list_projects", "description": "List all projects", "source": "openapi", "paramCount": 2, "requiresAuth": true },
+    { "name": "get_project", "description": "Get project details", "source": "openapi", "paramCount": 1, "requiresAuth": true },
+    { "name": "list_domains", "description": "List all domains", "source": "openapi", "paramCount": 2, "requiresAuth": true },
+    { "name": "add_domain", "description": "Add a domain to a project", "source": "openapi", "paramCount": 2, "requiresAuth": true },
+    { "name": "get_env_vars", "description": "Get environment variables", "source": "openapi", "paramCount": 1, "requiresAuth": true }
+  ],
+  "categories": ["deployment", "hosting", "api"],
+  "tags": ["vercel", "deployment", "serverless", "hosting", "nextjs"],
+  "popularity": 8920,
+  "lastUpdated": "2026-01-15T00:00:00.000Z",
+  "createdAt": "2025-06-01T00:00:00.000Z",
+  "generatedCode": {
+    "typescript": "import { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\nimport { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';\n\nconst VERCEL_TOKEN = process.env.VERCEL_TOKEN;\nconst VERCEL_BASE_URL = 'https://api.vercel.com';\n\nif (!VERCEL_TOKEN) {\n  console.error('Error: VERCEL_TOKEN environment variable is required');\n  process.exit(1);\n}\n\nconst server = new Server({ name: 'vercel-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });\n\nasync function vercelRequest(endpoint: string, method: string = 'GET', body?: unknown) {\n  const response = await fetch(`${VERCEL_BASE_URL}${endpoint}`, {\n    method,\n    headers: {\n      'Authorization': `Bearer ${VERCEL_TOKEN}`,\n      'Content-Type': 'application/json',\n    },\n    body: body ? JSON.stringify(body) : undefined,\n  });\n  if (!response.ok) {\n    const error = await response.json();\n    throw new Error(error.error?.message || 'Vercel API error');\n  }\n  return response.json();\n}\n\nconst tools = [\n  { name: 'list_deployments', description: 'List deployments', inputSchema: { type: 'object', properties: { projectId: { type: 'string' }, limit: { type: 'number' }, state: { type: 'string' }, target: { type: 'string' } } } },\n  { name: 'get_deployment', description: 'Get deployment', inputSchema: { type: 'object', properties: { deploymentId: { type: 'string' } }, required: ['deploymentId'] } },\n  { name: 'list_projects', description: 'List projects', inputSchema: { type: 'object', properties: { limit: { type: 'number' }, search: { type: 'string' } } } },\n  { name: 'get_project', description: 'Get project', inputSchema: { type: 'object', properties: { projectId: { type: 'string' } }, required: ['projectId'] } },\n  { name: 'list_domains', description: 'List domains', inputSchema: { type: 'object', properties: { projectId: { type: 'string' }, limit: { type: 'number' } } } },\n  { name: 'add_domain', description: 'Add domain', inputSchema: { type: 'object', properties: { projectId: { type: 'string' }, domain: { type: 'string' } }, required: ['projectId', 'domain'] } },\n  { name: 'get_env_vars', description: 'Get env vars', inputSchema: { type: 'object', properties: { projectId: { type: 'string' } }, required: ['projectId'] } },\n];\n\nserver.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));\n\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n  try {\n    let result;\n    const a = args as Record<string, unknown>;\n    switch (name) {\n      case 'list_deployments': result = await vercelRequest(`/v6/deployments${a.projectId ? `?projectId=${a.projectId}` : ''}`); break;\n      case 'get_deployment': result = await vercelRequest(`/v13/deployments/${a.deploymentId}`); break;\n      case 'list_projects': result = await vercelRequest('/v9/projects'); break;\n      case 'get_project': result = await vercelRequest(`/v9/projects/${a.projectId}`); break;\n      case 'list_domains': result = await vercelRequest(`/v5/projects/${a.projectId}/domains`); break;\n      case 'add_domain': result = await vercelRequest(`/v10/projects/${a.projectId}/domains`, 'POST', { name: a.domain }); break;\n      case 'get_env_vars': result = await vercelRequest(`/v9/projects/${a.projectId}/env`); break;\n      default: throw new Error(`Unknown tool: ${name}`);\n    }\n    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };\n  } catch (error) {\n    return { content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };\n  }\n});\n\nasync function main() {\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n}\n\nmain().catch(console.error);\n"
+  },
+  "configs": {
+    "claude": { "mcpServers": { "vercel": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "VERCEL_TOKEN": "${VERCEL_TOKEN}" } } } },
+    "cursor": { "mcpServers": { "vercel": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "VERCEL_TOKEN": "${VERCEL_TOKEN}" } } } },
+    "vscode": { "mcpServers": { "vercel": { "command": "npx", "args": ["tsx", "index.ts"], "env": { "VERCEL_TOKEN": "${VERCEL_TOKEN}" } } } }
+  },
+  "quality": { "overall": 84, "schemaCompleteness": 85, "documentation": 82, "examples": 80, "authHandling": 88, "parameterTypes": 85 },
+  "auth": [{ "type": "http", "scheme": "bearer", "envVar": "VERCEL_TOKEN", "instructions": "Create a token at https://vercel.com/account/tokens" }],
+  "docsUrl": "https://vercel.com/docs",
+  "apiDocsUrl": "https://vercel.com/docs/rest-api",
+  "iconUrl": "https://vercel.com/favicon.ico",
+  "verified": true,
+  "author": "github-to-mcp"
+}

package/packages/registry/src/registry.ts

@@ -0,0 +1,492 @@
+/**
+ * @fileoverview Main MCP Registry class
+ * @copyright Copyright (c) 2024-2026 nirholas
+ * @license Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import type {
+  RegistryEntry,
+  RegistryEntrySummary,
+  ListOptions,
+  ListResult,
+  InstallOptions,
+  InstallResult,
+  UpdateInfo,
+  StorageAdapter,
+  RegistryStats,
+} from './types';
+import { FileStorage } from './storage';
+import { RegistryUpdater } from './updater';
+
+/**
+ * Options for the MCP Registry
+ */
+export interface McpRegistryOptions {
+  /** Custom storage adapter */
+  storage?: StorageAdapter;
+  /** GitHub token for updates */
+  githubToken?: string;
+  /** Custom data directory */
+  dataDir?: string;
+}
+
+/**
+ * MCP Registry - manage pre-converted MCP servers
+ */
+export class McpRegistry {
+  private storage: StorageAdapter;
+  private updater: RegistryUpdater;
+  private options: McpRegistryOptions;
+
+  constructor(options: McpRegistryOptions = {}) {
+    this.options = options;
+    this.storage = options.storage || new FileStorage(options.dataDir);
+    this.updater = new RegistryUpdater(this.storage, {
+      githubToken: options.githubToken,
+    });
+  }
+
+  /**
+   * List all available MCP servers
+   */
+  async list(options?: ListOptions): Promise<ListResult> {
+    return this.storage.list(options);
+  }
+
+  /**
+   * Get a specific registry entry by ID
+   */
+  async get(id: string): Promise<RegistryEntry | null> {
+    return this.storage.get(id);
+  }
+
+  /**
+   * Search registry entries
+   */
+  async search(query: string): Promise<RegistryEntrySummary[]> {
+    return this.storage.search(query);
+  }
+
+  /**
+   * Get all available categories
+   */
+  async getCategories(): Promise<string[]> {
+    return this.storage.getCategories();
+  }
+
+  /**
+   * Install an MCP server to a target IDE/tool
+   */
+  async install(id: string, options: InstallOptions): Promise<InstallResult> {
+    const entry = await this.storage.get(id);
+    
+    if (!entry) {
+      return {
+        success: false,
+        error: `Registry entry '${id}' not found`,
+      };
+    }
+
+    try {
+      switch (options.target) {
+        case 'claude':
+          return await this.installToClaude(entry, options);
+        case 'cursor':
+          return await this.installToCursor(entry, options);
+        case 'vscode':
+          return await this.installToVSCode(entry, options);
+        case 'file':
+          return await this.installToFile(entry, options);
+        default:
+          return {
+            success: false,
+            error: `Unknown target: ${options.target}`,
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Installation failed',
+      };
+    }
+  }
+
+  /**
+   * Install to Claude Desktop
+   */
+  private async installToClaude(entry: RegistryEntry, options: InstallOptions): Promise<InstallResult> {
+    const configPath = this.getClaudeConfigPath();
+    
+    if (!configPath) {
+      return {
+        success: false,
+        error: 'Could not determine Claude Desktop config path',
+      };
+    }
+
+    // Read existing config
+    let config: { mcpServers?: Record<string, unknown> } = {};
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      config = JSON.parse(content);
+    } catch {
+      // Config doesn't exist yet
+    }
+
+    // Check if already installed
+    if (config.mcpServers?.[entry.id] && !options.overwrite) {
+      return {
+        success: false,
+        error: `${entry.name} is already installed. Use --overwrite to replace.`,
+      };
+    }
+
+    // Create server directory
+    const serverDir = path.join(path.dirname(configPath), 'mcp-servers', entry.id);
+    await fs.mkdir(serverDir, { recursive: true });
+
+    // Write server code
+    const language = options.language || 'typescript';
+    const code = language === 'python' && entry.generatedCode.python
+      ? entry.generatedCode.python
+      : entry.generatedCode.typescript;
+    
+    const ext = language === 'python' ? 'py' : 'ts';
+    const serverFile = path.join(serverDir, `index.${ext}`);
+    await fs.writeFile(serverFile, code, 'utf-8');
+
+    // Update config
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers[entry.id] = {
+      ...entry.configs.claude.mcpServers[Object.keys(entry.configs.claude.mcpServers)[0]],
+      ...(options.env && { env: { ...entry.configs.claude.mcpServers[Object.keys(entry.configs.claude.mcpServers)[0]]?.env, ...options.env } }),
+    };
+
+    // Write updated config
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    // Increment popularity
+    await this.incrementPopularity(entry.id);
+
+    return {
+      success: true,
+      path: serverDir,
+      instructions: [
+        `Installed ${entry.name} MCP server to ${serverDir}`,
+        'Restart Claude Desktop to activate the new server',
+        entry.auth.length > 0 
+          ? `Set environment variable: ${entry.auth[0].envVar || 'API_KEY'}`
+          : '',
+      ].filter(Boolean),
+    };
+  }
+
+  /**
+   * Install to Cursor
+   */
+  private async installToCursor(entry: RegistryEntry, options: InstallOptions): Promise<InstallResult> {
+    const configPath = this.getCursorConfigPath();
+    
+    if (!configPath) {
+      return {
+        success: false,
+        error: 'Could not determine Cursor config path',
+      };
+    }
+
+    // Similar to Claude installation
+    let config: { mcpServers?: Record<string, unknown> } = {};
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      config = JSON.parse(content);
+    } catch {
+      // Config doesn't exist yet
+    }
+
+    if (config.mcpServers?.[entry.id] && !options.overwrite) {
+      return {
+        success: false,
+        error: `${entry.name} is already installed. Use --overwrite to replace.`,
+      };
+    }
+
+    const serverDir = path.join(path.dirname(configPath), 'mcp-servers', entry.id);
+    await fs.mkdir(serverDir, { recursive: true });
+
+    const language = options.language || 'typescript';
+    const code = language === 'python' && entry.generatedCode.python
+      ? entry.generatedCode.python
+      : entry.generatedCode.typescript;
+    
+    const ext = language === 'python' ? 'py' : 'ts';
+    const serverFile = path.join(serverDir, `index.${ext}`);
+    await fs.writeFile(serverFile, code, 'utf-8');
+
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers[entry.id] = {
+      ...entry.configs.cursor.mcpServers[Object.keys(entry.configs.cursor.mcpServers)[0]],
+      ...(options.env && { env: { ...entry.configs.cursor.mcpServers[Object.keys(entry.configs.cursor.mcpServers)[0]]?.env, ...options.env } }),
+    };
+
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    await this.incrementPopularity(entry.id);
+
+    return {
+      success: true,
+      path: serverDir,
+      instructions: [
+        `Installed ${entry.name} MCP server to ${serverDir}`,
+        'Restart Cursor to activate the new server',
+      ],
+    };
+  }
+
+  /**
+   * Install to VS Code
+   */
+  private async installToVSCode(entry: RegistryEntry, options: InstallOptions): Promise<InstallResult> {
+    // VS Code uses workspace-level .vscode/mcp.json
+    const workspaceDir = process.cwd();
+    const configPath = path.join(workspaceDir, '.vscode', 'mcp.json');
+
+    let config: { servers?: Record<string, unknown> } = {};
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      config = JSON.parse(content);
+    } catch {
+      // Config doesn't exist yet
+    }
+
+    if (config.servers?.[entry.id] && !options.overwrite) {
+      return {
+        success: false,
+        error: `${entry.name} is already installed. Use --overwrite to replace.`,
+      };
+    }
+
+    const serverDir = path.join(workspaceDir, '.mcp-servers', entry.id);
+    await fs.mkdir(serverDir, { recursive: true });
+
+    const language = options.language || 'typescript';
+    const code = language === 'python' && entry.generatedCode.python
+      ? entry.generatedCode.python
+      : entry.generatedCode.typescript;
+    
+    const ext = language === 'python' ? 'py' : 'ts';
+    const serverFile = path.join(serverDir, `index.${ext}`);
+    await fs.writeFile(serverFile, code, 'utf-8');
+
+    config.servers = config.servers || {};
+    config.servers[entry.id] = entry.configs.vscode.mcpServers[Object.keys(entry.configs.vscode.mcpServers)[0]];
+
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    await this.incrementPopularity(entry.id);
+
+    return {
+      success: true,
+      path: serverDir,
+      instructions: [
+        `Installed ${entry.name} MCP server to ${serverDir}`,
+        'Reload VS Code window to activate',
+      ],
+    };
+  }
+
+  /**
+   * Install to a file (for manual setup)
+   */
+  private async installToFile(entry: RegistryEntry, options: InstallOptions): Promise<InstallResult> {
+    const outputDir = options.outputDir || path.join(process.cwd(), entry.id);
+    await fs.mkdir(outputDir, { recursive: true });
+
+    const language = options.language || 'typescript';
+    const code = language === 'python' && entry.generatedCode.python
+      ? entry.generatedCode.python
+      : entry.generatedCode.typescript;
+    
+    const ext = language === 'python' ? 'py' : 'ts';
+    const serverFile = path.join(outputDir, `index.${ext}`);
+    await fs.writeFile(serverFile, code, 'utf-8');
+
+    // Write package.json for TypeScript
+    if (language === 'typescript') {
+      const packageJson = {
+        name: entry.id,
+        version: '1.0.0',
+        description: `MCP server for ${entry.name}`,
+        type: 'module',
+        main: 'index.ts',
+        scripts: {
+          start: 'npx tsx index.ts',
+          build: 'npx tsc',
+        },
+        dependencies: {
+          '@modelcontextprotocol/sdk': '^1.0.0',
+        },
+        devDependencies: {
+          typescript: '^5.0.0',
+          tsx: '^4.0.0',
+        },
+      };
+      await fs.writeFile(
+        path.join(outputDir, 'package.json'),
+        JSON.stringify(packageJson, null, 2),
+        'utf-8'
+      );
+    }
+
+    // Write config examples
+    await fs.writeFile(
+      path.join(outputDir, 'claude-config.json'),
+      JSON.stringify(entry.configs.claude, null, 2),
+      'utf-8'
+    );
+
+    await this.incrementPopularity(entry.id);
+
+    return {
+      success: true,
+      path: outputDir,
+      instructions: [
+        `Generated ${entry.name} MCP server at ${outputDir}`,
+        language === 'typescript' ? 'Run: npm install && npm start' : `Run: python ${serverFile}`,
+        'Copy config from claude-config.json to your IDE config',
+      ],
+    };
+  }
+
+  /**
+   * Check for updates
+   */
+  async checkUpdates(): Promise<UpdateInfo[]> {
+    return this.updater.checkAllForUpdates();
+  }
+
+  /**
+   * Check if a specific entry has updates
+   */
+  async checkUpdate(id: string): Promise<UpdateInfo | null> {
+    return this.updater.checkForUpdates(id);
+  }
+
+  /**
+   * Publish a new entry to the registry
+   */
+  async publish(entry: RegistryEntry): Promise<void> {
+    // Validate entry
+    this.validateEntry(entry);
+    
+    // Set timestamps
+    const now = new Date().toISOString();
+    entry.createdAt = entry.createdAt || now;
+    entry.lastUpdated = now;
+    
+    await this.storage.save(entry);
+  }
+
+  /**
+   * Get registry statistics
+   */
+  async getStats(): Promise<RegistryStats> {
+    const result = await this.storage.list({ limit: 1000 });
+    const categories = await this.storage.getCategories();
+    
+    const categoryCount = new Map<string, number>();
+    let totalTools = 0;
+    let totalDownloads = 0;
+
+    for (const entry of result.entries) {
+      totalTools += entry.toolCount;
+      totalDownloads += entry.popularity;
+      for (const cat of entry.categories) {
+        categoryCount.set(cat, (categoryCount.get(cat) || 0) + 1);
+      }
+    }
+
+    const sorted = [...result.entries].sort((a, b) => b.popularity - a.popularity);
+    const recent = [...result.entries].sort(
+      (a, b) => new Date(b.lastUpdated).getTime() - new Date(a.lastUpdated).getTime()
+    );
+
+    return {
+      totalEntries: result.total,
+      totalTools,
+      totalDownloads,
+      categories: categories.map(name => ({
+        name,
+        count: categoryCount.get(name) || 0,
+      })),
+      topEntries: sorted.slice(0, 10),
+      recentlyUpdated: recent.slice(0, 10),
+    };
+  }
+
+  /**
+   * Validate a registry entry
+   */
+  private validateEntry(entry: RegistryEntry): void {
+    if (!entry.id || !/^[a-z0-9-]+$/.test(entry.id)) {
+      throw new Error('Invalid entry ID (must be lowercase alphanumeric with dashes)');
+    }
+    if (!entry.name) throw new Error('Entry name is required');
+    if (!entry.sourceRepo) throw new Error('Source repo is required');
+    if (!entry.generatedCode?.typescript) throw new Error('TypeScript code is required');
+  }
+
+  /**
+   * Increment popularity counter
+   */
+  private async incrementPopularity(id: string): Promise<void> {
+    const entry = await this.storage.get(id);
+    if (entry) {
+      entry.popularity += 1;
+      await this.storage.save(entry);
+    }
+  }
+
+  /**
+   * Get Claude Desktop config path
+   */
+  private getClaudeConfigPath(): string | null {
+    const platform = os.platform();
+    const home = os.homedir();
+
+    switch (platform) {
+      case 'darwin':
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      case 'win32':
+        return path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+      case 'linux':
+        return path.join(home, '.config', 'claude', 'claude_desktop_config.json');
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Get Cursor config path
+   */
+  private getCursorConfigPath(): string | null {
+    const platform = os.platform();
+    const home = os.homedir();
+
+    switch (platform) {
+      case 'darwin':
+        return path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'mcp.json');
+      case 'win32':
+        return path.join(home, 'AppData', 'Roaming', 'Cursor', 'User', 'globalStorage', 'mcp.json');
+      case 'linux':
+        return path.join(home, '.config', 'Cursor', 'User', 'globalStorage', 'mcp.json');
+      default:
+        return null;
+    }
+  }
+}