github-to-mcp-monorepo 1.0.0

package/apps/web/app/api/convert/stream/route.ts

@@ -0,0 +1,198 @@
+/**
+ * Streaming Convert API - Real-time progress updates via Server-Sent Events
+ * @copyright 2024-2026 nirholas
+ * @license MIT
+ */
+
+import { NextRequest } from 'next/server';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+// Progress steps for the streaming response
+const PROGRESS_STEPS = [
+  { id: 'validate', label: 'Validating GitHub URL', description: 'Checking repository accessibility' },
+  { id: 'fetch', label: 'Fetching repository', description: 'Downloading repository metadata' },
+  { id: 'classify', label: 'Classifying repository', description: 'Detecting repo type and structure' },
+  { id: 'readme', label: 'Analyzing README', description: 'Extracting documentation and examples' },
+  { id: 'openapi', label: 'Scanning for OpenAPI specs', description: 'Looking for API definitions' },
+  { id: 'code', label: 'Analyzing code', description: 'Extracting functions and patterns' },
+  { id: 'generate-ts', label: 'Generating TypeScript server', description: 'Creating MCP server code' },
+  { id: 'generate-py', label: 'Generating Python server', description: 'Creating Python alternative' },
+  { id: 'configs', label: 'Creating configurations', description: 'Building platform configs' },
+  { id: 'complete', label: 'Conversion complete', description: 'MCP server ready' },
+];
+
+export async function GET(request: NextRequest) {
+  const url = request.nextUrl.searchParams.get('url');
+
+  if (!url) {
+    return new Response(JSON.stringify({ error: 'GitHub URL is required' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  // Validate GitHub URL
+  const githubPattern = /^https?:\/\/(www\.)?github\.com\/[\w-]+\/[\w.-]+/;
+  if (!githubPattern.test(url)) {
+    return new Response(JSON.stringify({ error: 'Invalid GitHub URL format' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (event: string, data: unknown) => {
+        controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+      };
+
+      try {
+        // Step 1: Validate URL
+        sendEvent('progress', { 
+          step: 'validate', 
+          status: 'in-progress',
+          message: PROGRESS_STEPS[0].label,
+          description: PROGRESS_STEPS[0].description,
+          progress: 5,
+        });
+        await new Promise(resolve => setTimeout(resolve, 300));
+        sendEvent('progress', { step: 'validate', status: 'complete', progress: 10 });
+
+        // Step 2: Fetch repository
+        sendEvent('progress', { 
+          step: 'fetch', 
+          status: 'in-progress',
+          message: PROGRESS_STEPS[1].label,
+          description: PROGRESS_STEPS[1].description,
+          progress: 15,
+        });
+
+        // Import the generator dynamically
+        const { generateFromGithub } = await import('@nirholas/github-to-mcp');
+        
+        // Create a wrapper that will be used for streaming updates
+        let currentProgress = 15;
+        
+        // We'll call the actual generation, but simulate progress steps
+        const progressUpdates = [
+          { step: 'fetch', delay: 500, progress: 20 },
+          { step: 'classify', delay: 800, progress: 30 },
+          { step: 'readme', delay: 600, progress: 40 },
+          { step: 'openapi', delay: 1000, progress: 55 },
+          { step: 'code', delay: 1200, progress: 70 },
+          { step: 'generate-ts', delay: 800, progress: 80 },
+          { step: 'generate-py', delay: 600, progress: 90 },
+          { step: 'configs', delay: 400, progress: 95 },
+        ];
+
+        // Start the actual generation in the background
+        const generationPromise = generateFromGithub(url, {
+          sources: ['readme', 'openapi', 'code'],
+          githubToken: process.env.GITHUB_TOKEN,
+        });
+
+        // Send progress updates while generation is happening
+        for (const update of progressUpdates) {
+          sendEvent('progress', { 
+            step: update.step, 
+            status: 'in-progress',
+            message: PROGRESS_STEPS.find(s => s.id === update.step)?.label || update.step,
+            description: PROGRESS_STEPS.find(s => s.id === update.step)?.description || '',
+            progress: update.progress,
+          });
+          await new Promise(resolve => setTimeout(resolve, update.delay));
+          sendEvent('progress', { step: update.step, status: 'complete', progress: update.progress + 5 });
+        }
+
+        // Wait for actual generation to complete
+        const result = await generationPromise;
+
+        // Generate the MCP server code
+        const code = result.generate();
+        const pythonCode = result.generatePython ? result.generatePython() : '';
+
+        // Generate config snippets
+        const repoName = result.name;
+        
+        const claudeConfig = JSON.stringify({
+          mcpServers: {
+            [repoName]: {
+              command: 'npx',
+              args: ['tsx', `${repoName}-mcp/index.ts`],
+            },
+          },
+        }, null, 2);
+
+        const cursorConfig = JSON.stringify({
+          mcpServers: {
+            [repoName]: {
+              command: 'npx',
+              args: ['tsx', `${repoName}-mcp/index.ts`],
+            },
+          },
+        }, null, 2);
+
+        const claudePythonConfig = JSON.stringify({
+          mcpServers: {
+            [repoName]: {
+              command: 'python',
+              args: ['-m', `${repoName.replace(/-/g, '_')}_mcp`],
+            },
+          },
+        }, null, 2);
+
+        // Send completion
+        sendEvent('progress', { 
+          step: 'complete', 
+          status: 'complete',
+          message: PROGRESS_STEPS[9].label,
+          description: `Successfully extracted ${result.tools.length} tools`,
+          progress: 100,
+        });
+
+        // Send the final result
+        sendEvent('result', {
+          name: result.name,
+          tools: result.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            source: t.source,
+          })),
+          sources: result.sources,
+          classification: result.classification,
+          code,
+          pythonCode,
+          claudeConfig,
+          cursorConfig,
+          claudePythonConfig,
+        });
+
+        sendEvent('done', { success: true });
+        
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'Conversion failed';
+        
+        sendEvent('error', { 
+          error: message,
+          code: message.includes('rate limit') ? 'RATE_LIMIT' : 'CONVERSION_ERROR',
+        });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}

package/apps/web/app/api/deploy/route.ts

@@ -0,0 +1,157 @@
+/**
+ * Deploy API - Create cloud-hosted MCP servers
+ * @copyright 2024-2026 nirholas
+ * @license MIT
+ * 
+ * POST /api/deploy - Deploy a new MCP server
+ * GET /api/deploy - List user's deployed servers
+ * DELETE /api/deploy?id=xxx - Delete a deployed server
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { nanoid } from 'nanoid';
+import type { 
+  DeployRequest, 
+  DeployResponse, 
+  DeployedServer, 
+  ServerListResponse 
+} from '@/types/deploy';
+
+// In production, this would be a database (Vercel KV, Planetscale, etc.)
+// For now, we use in-memory storage with localStorage sync on client
+const STORAGE_KEY = 'github-to-mcp-deployed-servers';
+
+// Generate a secure API key
+function generateApiKey(): string {
+  return `mcp_${nanoid(32)}`;
+}
+
+// Hash API key for storage (simple hash for demo, use bcrypt in production)
+function hashApiKey(key: string): string {
+  // In production, use proper hashing
+  return Buffer.from(key).toString('base64');
+}
+
+// Generate server endpoint URL
+function generateEndpoint(serverId: string): string {
+  const baseUrl = process.env.NEXT_PUBLIC_APP_URL || 'https://github-to-mcp.vercel.app';
+  return `${baseUrl}/api/mcp/${serverId}`;
+}
+
+/**
+ * POST /api/deploy - Deploy a new MCP server
+ */
+export async function POST(request: NextRequest): Promise<NextResponse<DeployResponse>> {
+  try {
+    const body = await request.json() as DeployRequest;
+    
+    // Validate request
+    if (!body.name || !body.code || !body.tools?.length) {
+      return NextResponse.json({
+        success: false,
+        error: 'Missing required fields: name, code, and tools are required',
+      }, { status: 400 });
+    }
+
+    // Generate IDs and keys
+    const serverId = nanoid(12);
+    const apiKey = generateApiKey();
+    const endpoint = generateEndpoint(serverId);
+
+    // Create deployed server record
+    const server: DeployedServer = {
+      id: serverId,
+      name: body.name,
+      description: body.description || `MCP server for ${body.name}`,
+      
+      tools: body.tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+        enabled: true,
+        callCount: 0,
+      })),
+      code: body.code,
+      language: 'typescript',
+      
+      endpoint,
+      status: 'active',
+      region: 'us-east-1',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      
+      sourceRepo: body.sourceRepo,
+      
+      apiKeyHash: hashApiKey(apiKey),
+      rateLimit: {
+        requestsPerMinute: body.rateLimit?.requestsPerMinute || 60,
+        requestsPerDay: body.rateLimit?.requestsPerDay || 10000,
+        enabled: true,
+      },
+      
+      usage: {
+        totalCalls: 0,
+        totalCallsToday: 0,
+        totalCallsThisMonth: 0,
+        successRate: 100,
+        avgLatencyMs: 0,
+        callsByTool: {},
+        callsByDay: [],
+        errors: [],
+      },
+    };
+
+    // In production: Save to database
+    // For demo: Return the server data (client will store in localStorage)
+
+    return NextResponse.json({
+      success: true,
+      server,
+      endpoint,
+      apiKey, // Only returned on creation!
+    });
+  } catch (error) {
+    console.error('Deploy error:', error);
+    return NextResponse.json({
+      success: false,
+      error: error instanceof Error ? error.message : 'Deployment failed',
+    }, { status: 500 });
+  }
+}
+
+/**
+ * GET /api/deploy - List deployed servers
+ * In production, this would fetch from database based on authenticated user
+ */
+export async function GET(request: NextRequest): Promise<NextResponse<ServerListResponse>> {
+  // In production: Fetch from database with auth
+  // For demo: Client manages storage, this is a placeholder
+  
+  return NextResponse.json({
+    servers: [],
+    total: 0,
+    hasMore: false,
+  });
+}
+
+/**
+ * DELETE /api/deploy?id=xxx - Delete a deployed server
+ */
+export async function DELETE(request: NextRequest): Promise<NextResponse> {
+  const { searchParams } = new URL(request.url);
+  const serverId = searchParams.get('id');
+
+  if (!serverId) {
+    return NextResponse.json({
+      success: false,
+      error: 'Server ID is required',
+    }, { status: 400 });
+  }
+
+  // In production: Delete from database with auth verification
+  
+  return NextResponse.json({
+    success: true,
+    message: `Server ${serverId} deleted`,
+  });
+}

package/apps/web/app/api/edge/route.ts

@@ -0,0 +1,308 @@
+/**
+ * Edge API Route for github-to-mcp
+ * 
+ * This route runs on Vercel Edge Runtime for fast, globally distributed processing.
+ * It provides a lightweight version of the MCP generation that works in edge environments.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+
+// Tell Next.js to use edge runtime
+export const runtime = 'edge';
+
+// Edge-compatible types
+interface EdgeResult {
+  repo: string;
+  name: string;
+  tools: Array<{
+    name: string;
+    description: string;
+    inputSchema: object;
+    source: { type: string; file: string };
+    confidence?: number;
+  }>;
+  classification: {
+    type: string;
+    confidence: number;
+    indicators: string[];
+  };
+  metadata: {
+    stars: number;
+    language: string;
+    license?: string;
+    description?: string;
+  };
+  typescript?: string;
+  python?: string;
+}
+
+/**
+ * Parse GitHub URL
+ */
+function parseGithubUrl(url: string): { owner: string; repo: string; branch?: string } {
+  const treeMatch = url.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)/);
+  if (treeMatch) {
+    return {
+      owner: treeMatch[1],
+      repo: treeMatch[2].replace('.git', ''),
+      branch: treeMatch[3]
+    };
+  }
+
+  const simpleMatch = url.match(/github\.com\/([^\/]+)\/([^\/]+)/);
+  if (simpleMatch) {
+    return {
+      owner: simpleMatch[1],
+      repo: simpleMatch[2].replace('.git', ''),
+      branch: 'main'
+    };
+  }
+
+  throw new Error(`Invalid GitHub URL: ${url}`);
+}
+
+/**
+ * Fetch repository metadata from GitHub API
+ */
+async function fetchRepoMetadata(owner: string, repo: string, token?: string) {
+  const headers: Record<string, string> = {
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'github-to-mcp-edge'
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, { headers });
+
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    stars: data.stargazers_count,
+    language: data.language || 'unknown',
+    license: data.license?.spdx_id,
+    description: data.description,
+    defaultBranch: data.default_branch
+  };
+}
+
+/**
+ * Fetch README content
+ */
+async function fetchReadme(owner: string, repo: string, branch?: string, token?: string): Promise<string | null> {
+  const headers: Record<string, string> = {
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'github-to-mcp-edge'
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  const readmeFiles = ['README.md', 'README.MD', 'readme.md'];
+
+  for (const filename of readmeFiles) {
+    try {
+      const url = `https://api.github.com/repos/${owner}/${repo}/contents/${filename}${branch ? `?ref=${branch}` : ''}`;
+      const response = await fetch(url, { headers });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.type === 'file' && data.content) {
+          return atob(data.content.replace(/\n/g, ''));
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Classify repository type
+ */
+function classifyRepo(readme: string | null, language: string) {
+  let type = 'unknown';
+  let confidence = 0.3;
+  const indicators: string[] = [];
+
+  const readmeLower = readme?.toLowerCase() || '';
+
+  if (readmeLower.includes('mcp') || readmeLower.includes('model context protocol')) {
+    type = 'mcp-server';
+    confidence = 0.9;
+    indicators.push('Contains MCP references');
+  } else if (readmeLower.includes('api') || readmeLower.includes('sdk')) {
+    type = 'api-sdk';
+    confidence = 0.7;
+    indicators.push('Contains API/SDK references');
+  } else if (readmeLower.includes('cli') || readmeLower.includes('command line')) {
+    type = 'cli-tool';
+    confidence = 0.7;
+    indicators.push('Contains CLI references');
+  } else if (readmeLower.includes('library') || readmeLower.includes('package')) {
+    type = 'library';
+    confidence = 0.6;
+    indicators.push('Contains library references');
+  }
+
+  indicators.push(`Language: ${language}`);
+
+  return { type, confidence, indicators };
+}
+
+/**
+ * Extract tools from README
+ */
+function extractToolsFromReadme(readme: string): EdgeResult['tools'] {
+  const tools: EdgeResult['tools'] = [];
+
+  // Extract API endpoints
+  const endpointRegex = /(?:GET|POST|PUT|DELETE|PATCH)\s+[`']?([\/\w\-\{\}:]+)[`']?/gi;
+  let match;
+
+  while ((match = endpointRegex.exec(readme)) !== null) {
+    const endpoint = match[1];
+    const method = match[0].split(' ')[0].toUpperCase();
+    const name = endpoint
+      .replace(/[{}]/g, '')
+      .split('/')
+      .filter(p => p && !p.startsWith(':'))
+      .map(p => p.charAt(0).toUpperCase() + p.slice(1))
+      .join('');
+
+    tools.push({
+      name: method.toLowerCase() + name,
+      description: `${method} ${endpoint}`,
+      inputSchema: { type: 'object', properties: {}, required: [] },
+      source: { type: 'readme', file: 'README.md' },
+      confidence: 0.6
+    });
+  }
+
+  return tools;
+}
+
+/**
+ * Generate TypeScript code
+ */
+function generateTypeScript(tools: EdgeResult['tools'], repoName: string, owner: string): string {
+  const safeName = repoName.replace(/[^a-zA-Z0-9]/g, '_');
+
+  const toolDefs = tools.map(t => `  {
+    name: "${t.name}",
+    description: "${t.description.replace(/"/g, '\\"')}",
+    inputSchema: ${JSON.stringify(t.inputSchema)}
+  }`).join(',\n');
+
+  const handlers = tools.map((t, i) =>
+    `${i === 0 ? '' : ' else '}if (name === "${t.name}") {
+      return { content: [{ type: "text", text: "Not implemented: ${t.name}" }] };
+    }`
+  ).join('\n    ');
+
+  return `/**
+ * Auto-generated MCP Server for ${repoName}
+ * Generated by @nirholas/github-to-mcp (Edge)
+ * Repository: https://github.com/${owner}/${repoName}
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+const server = new Server(
+  { name: "${safeName}-mcp", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+const tools = [
+${toolDefs}
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  ${handlers}
+  throw new Error(\`Unknown tool: \${name}\`);
+});
+
+const transport = new StdioServerTransport();
+server.connect(transport);
+`;
+}
+
+/**
+ * POST handler for edge generation
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { url, language = 'typescript' } = body;
+
+    if (!url) {
+      return NextResponse.json(
+        { error: 'Missing required field: url' },
+        { status: 400 }
+      );
+    }
+
+    // Get GitHub token from environment or request
+    const token = process.env.GITHUB_TOKEN || body.token;
+
+    // Parse URL
+    const { owner, repo, branch } = parseGithubUrl(url);
+
+    // Fetch data in parallel
+    const [metadata, readme] = await Promise.all([
+      fetchRepoMetadata(owner, repo, token),
+      fetchReadme(owner, repo, branch, token)
+    ]);
+
+    // Classify and extract
+    const classification = classifyRepo(readme, metadata.language);
+    const tools = readme ? extractToolsFromReadme(readme) : [];
+
+    // Build result
+    const result: EdgeResult = {
+      repo: `${owner}/${repo}`,
+      name: repo,
+      tools,
+      classification,
+      metadata
+    };
+
+    // Generate code
+    if (language === 'typescript' || language === 'both') {
+      result.typescript = generateTypeScript(tools, repo, owner);
+    }
+
+    return NextResponse.json(result);
+
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    return NextResponse.json(
+      { error: message },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET handler for health check
+ */
+export async function GET() {
+  return NextResponse.json({
+    status: 'ok',
+    runtime: 'edge',
+    timestamp: new Date().toISOString()
+  });
+}