github-to-mcp-monorepo 1.0.0

package/apps/web/app/api/export-docker/route.ts

@@ -0,0 +1,284 @@
+/**
+ * @fileoverview API route to export Docker configuration
+ * POST /api/export-docker
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+
+export interface ExportDockerRequest {
+  language: 'typescript' | 'python';
+  serverName?: string;
+  port?: number;
+  envVars?: Record<string, string>;
+  includeHealthcheck?: boolean;
+  multiStage?: boolean;
+}
+
+export interface DockerConfig {
+  dockerfile: string;
+  dockerCompose: string;
+  dockerignore: string;
+  buildScript: string;
+  claudeConfig: string;
+}
+
+export interface ExportDockerResponse {
+  success: boolean;
+  config?: DockerConfig;
+  error?: string;
+}
+
+/**
+ * Docker configuration templates
+ */
+const DOCKER_TEMPLATES = {
+  typescript: {
+    dockerfile: (options: { multiStage: boolean; includeHealthcheck: boolean }) => {
+      if (options.multiStage) {
+        return `# TypeScript MCP Server Dockerfile (Multi-stage)
+FROM node:20-slim AS builder
+
+WORKDIR /app
+
+# Install dependencies
+COPY package*.json ./
+RUN npm ci
+
+# Copy source and build
+COPY . .
+RUN npm run build
+
+# Production image
+FROM node:20-slim
+
+WORKDIR /app
+
+# Copy built files and production dependencies
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package*.json ./
+RUN npm ci --only=production
+
+# Security: Run as non-root user
+USER node
+
+${options.includeHealthcheck ? `# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+    CMD node -e "console.log('healthy')" || exit 1
+
+` : ''}# Run the server
+CMD ["node", "dist/index.js"]
+`;
+      }
+      return `# TypeScript MCP Server Dockerfile
+FROM node:20-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Copy source
+COPY . .
+
+# Build TypeScript
+RUN npm run build
+
+${options.includeHealthcheck ? `# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+    CMD node -e "console.log('healthy')" || exit 1
+
+` : ''}# Run the server
+CMD ["node", "dist/index.js"]
+`;
+    },
+    dockerignore: `node_modules
+npm-debug.log
+.git
+.gitignore
+.env
+*.md
+dist
+coverage
+.nyc_output
+*.test.ts
+*.spec.ts
+__tests__
+`,
+  },
+  python: {
+    dockerfile: (options: { includeHealthcheck: boolean }) => `# Python MCP Server Dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY . .
+
+# Security: Run as non-root user
+RUN useradd -m -r mcpuser && chown -R mcpuser:mcpuser /app
+USER mcpuser
+
+${options.includeHealthcheck ? `# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+    CMD python -c "print('healthy')" || exit 1
+
+` : ''}# Run the server
+CMD ["python", "-m", "mcp_server"]
+`,
+    dockerignore: `__pycache__
+*.py[cod]
+*$py.class
+*.so
+.Python
+.git
+.gitignore
+.env
+venv/
+ENV/
+*.md
+.pytest_cache/
+.coverage
+htmlcov/
+dist/
+build/
+*.egg-info/
+`,
+  },
+};
+
+function generateDockerCompose(
+  serverName: string,
+  port?: number,
+  envVars?: Record<string, string>
+): string {
+  const envLines = envVars
+    ? Object.entries(envVars)
+        .map(([key, value]) => `      - ${key}=${value}`)
+        .join('\n')
+    : '      - NODE_ENV=production';
+
+  const portSection = port
+    ? `    ports:
+      - "${port}:${port}"
+`
+    : '';
+
+  return `version: '3.8'
+
+services:
+  ${serverName}:
+    build: .
+    environment:
+${envLines}
+${portSection}    volumes:
+      - ./config:/app/config:ro
+    restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "3"
+`;
+}
+
+function generateBuildScript(serverName: string): string {
+  return `#!/bin/bash
+# Build and run the MCP server in Docker
+set -e
+
+echo "Building Docker image..."
+docker build -t ${serverName} .
+
+echo "Image built successfully!"
+echo ""
+echo "To run the MCP server:"
+echo "  docker run -it --rm ${serverName}"
+echo ""
+echo "Or with docker-compose:"
+echo "  docker-compose up -d"
+`;
+}
+
+function generateClaudeConfig(serverName: string): string {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        [serverName]: {
+          command: 'docker',
+          args: ['run', '-i', '--rm', serverName],
+        },
+      },
+    },
+    null,
+    2
+  );
+}
+
+export async function POST(request: NextRequest): Promise<NextResponse<ExportDockerResponse>> {
+  try {
+    const body = await request.json() as ExportDockerRequest;
+
+    // Validate request
+    if (!body.language || !['typescript', 'python'].includes(body.language)) {
+      return NextResponse.json(
+        { success: false, error: 'Language must be "typescript" or "python"' },
+        { status: 400 }
+      );
+    }
+
+    const serverName = body.serverName || 'mcp-server';
+    const includeHealthcheck = body.includeHealthcheck ?? false;
+    const multiStage = body.multiStage ?? true;
+
+    const template = DOCKER_TEMPLATES[body.language];
+    
+    const dockerfile = body.language === 'typescript'
+      ? template.dockerfile({ multiStage, includeHealthcheck })
+      : (template as typeof DOCKER_TEMPLATES.python).dockerfile({ includeHealthcheck });
+
+    const config: DockerConfig = {
+      dockerfile,
+      dockerCompose: generateDockerCompose(serverName, body.port, body.envVars),
+      dockerignore: template.dockerignore,
+      buildScript: generateBuildScript(serverName),
+      claudeConfig: generateClaudeConfig(serverName),
+    };
+
+    return NextResponse.json({
+      success: true,
+      config,
+    });
+  } catch (error) {
+    console.error('Docker config generation error:', error);
+    
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'Docker config generation failed',
+      },
+      { status: 500 }
+    );
+  }
+}
+
+// Support OPTIONS for CORS preflight
+export async function OPTIONS(): Promise<NextResponse> {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  });
+}

package/apps/web/app/api/generate-openapi/route.ts

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview API route to generate OpenAPI spec from uploaded code
+ * POST /api/generate-openapi
+ */
+
+// @ts-nocheck - Temporarily disabled due to missing openapi-parser types
+import { NextRequest, NextResponse } from 'next/server';
+import { generateOpenApiFromCodeWithDetails } from '@github-to-mcp/openapi-parser';
+import type { FileContent, GeneratorOptions } from '@github-to-mcp/openapi-parser';
+
+export interface GenerateOpenApiRequest {
+  files: Array<{
+    path: string;
+    content: string;
+    language?: 'typescript' | 'javascript' | 'python';
+  }>;
+  options?: GeneratorOptions;
+  format?: 'json' | 'yaml' | 'both';
+}
+
+export interface GenerateOpenApiResponse {
+  success: boolean;
+  spec?: object;
+  json?: string;
+  yaml?: string;
+  analysis?: {
+    framework: string;
+    routesCount: number;
+    schemasCount: number;
+    warnings: string[];
+    errors: string[];
+  };
+  error?: string;
+}
+
+export async function POST(request: NextRequest): Promise<NextResponse<GenerateOpenApiResponse>> {
+  try {
+    const body = await request.json() as GenerateOpenApiRequest;
+
+    // Validate request
+    if (!body.files || !Array.isArray(body.files) || body.files.length === 0) {
+      return NextResponse.json(
+        { success: false, error: 'Files array is required and must not be empty' },
+        { status: 400 }
+      );
+    }
+
+    // Validate each file
+    for (const file of body.files) {
+      if (!file.path || typeof file.path !== 'string') {
+        return NextResponse.json(
+          { success: false, error: 'Each file must have a path' },
+          { status: 400 }
+        );
+      }
+      if (!file.content || typeof file.content !== 'string') {
+        return NextResponse.json(
+          { success: false, error: 'Each file must have content' },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Convert to FileContent format
+    const files: FileContent[] = body.files.map(f => ({
+      path: f.path,
+      content: f.content,
+      language: f.language,
+    }));
+
+    // Generate OpenAPI spec
+    const result = await generateOpenApiFromCodeWithDetails(files, body.options || {});
+
+    const format = body.format || 'json';
+    const response: GenerateOpenApiResponse = {
+      success: true,
+      analysis: {
+        framework: result.analysis.framework,
+        routesCount: result.analysis.routes.length,
+        schemasCount: Object.keys(result.analysis.schemas).length,
+        warnings: result.analysis.warnings,
+        errors: result.analysis.errors,
+      },
+    };
+
+    if (format === 'json' || format === 'both') {
+      response.spec = result.spec;
+      response.json = result.json;
+    }
+
+    if (format === 'yaml' || format === 'both') {
+      response.yaml = result.yaml;
+    }
+
+    return NextResponse.json(response);
+  } catch (error) {
+    console.error('OpenAPI generation error:', error);
+    
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : 'OpenAPI generation failed',
+      },
+      { status: 500 }
+    );
+  }
+}
+
+// Support OPTIONS for CORS preflight
+export async function OPTIONS(): Promise<NextResponse> {
+  return new NextResponse(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+    },
+  });
+}

package/apps/web/app/api/mcp/[serverId]/route.ts

@@ -0,0 +1,263 @@
+/**
+ * Cloud MCP Server Endpoint - HTTP/SSE Transport
+ * @copyright 2024-2026 nirholas
+ * @license MIT
+ * 
+ * This is the actual MCP server that runs in the cloud.
+ * It receives MCP protocol messages via HTTP POST and returns responses.
+ * 
+ * Supports:
+ * - tools/list - List available tools
+ * - tools/call - Execute a tool
+ * - initialize - Initialize connection
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+
+export const runtime = 'edge';
+
+interface McpRequest {
+  jsonrpc: '2.0';
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface McpResponse {
+  jsonrpc: '2.0';
+  id: string | number;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+// In production, this would load from database
+// For demo, we'll parse from request headers or mock data
+async function getServerConfig(serverId: string, apiKey?: string): Promise<{
+  name: string;
+  tools: Array<{
+    name: string;
+    description: string;
+    inputSchema: object;
+  }>;
+} | null> {
+  // Demo: Return mock tools for testing
+  // In production: Load from database, verify API key
+  
+  return {
+    name: `mcp-server-${serverId}`,
+    tools: [
+      {
+        name: 'echo',
+        description: 'Echo back the input message',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            message: { type: 'string', description: 'Message to echo' },
+          },
+          required: ['message'],
+        },
+      },
+      {
+        name: 'get_time',
+        description: 'Get the current server time',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+    ],
+  };
+}
+
+// Execute a tool (in production, this would run sandboxed code)
+async function executeTool(
+  toolName: string, 
+  args: Record<string, unknown>,
+  serverId: string
+): Promise<{ result?: unknown; error?: string }> {
+  // Demo implementations
+  switch (toolName) {
+    case 'echo':
+      return { result: { message: args.message, echoed: true } };
+    
+    case 'get_time':
+      return { 
+        result: { 
+          time: new Date().toISOString(),
+          timezone: 'UTC',
+          serverId,
+        } 
+      };
+    
+    default:
+      return { error: `Unknown tool: ${toolName}` };
+  }
+}
+
+/**
+ * POST /api/mcp/[serverId] - Handle MCP protocol requests
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ serverId: string }> }
+): Promise<NextResponse<McpResponse>> {
+  const { serverId } = await params;
+  const startTime = Date.now();
+
+  try {
+    // Get API key from header
+    const apiKey = request.headers.get('Authorization')?.replace('Bearer ', '');
+    
+    // Load server config
+    const config = await getServerConfig(serverId, apiKey);
+    if (!config) {
+      return NextResponse.json({
+        jsonrpc: '2.0',
+        id: 0,
+        error: {
+          code: -32001,
+          message: 'Server not found or unauthorized',
+        },
+      }, { status: 404 });
+    }
+
+    // Parse MCP request
+    const body = await request.json() as McpRequest;
+    
+    // Handle different MCP methods
+    switch (body.method) {
+      case 'initialize': {
+        return NextResponse.json({
+          jsonrpc: '2.0',
+          id: body.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: {
+              name: config.name,
+              version: '1.0.0',
+            },
+            capabilities: {
+              tools: {},
+            },
+          },
+        });
+      }
+
+      case 'tools/list': {
+        return NextResponse.json({
+          jsonrpc: '2.0',
+          id: body.id,
+          result: {
+            tools: config.tools.map(t => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema,
+            })),
+          },
+        });
+      }
+
+      case 'tools/call': {
+        const toolParams = body.params as { name: string; arguments: Record<string, unknown> } | undefined;
+        if (!toolParams?.name) {
+          return NextResponse.json({
+            jsonrpc: '2.0',
+            id: body.id,
+            error: {
+              code: -32602,
+              message: 'Missing tool name',
+            },
+          }, { status: 400 });
+        }
+
+        const { result, error } = await executeTool(
+          toolParams.name, 
+          toolParams.arguments || {},
+          serverId
+        );
+
+        if (error) {
+          return NextResponse.json({
+            jsonrpc: '2.0',
+            id: body.id,
+            result: {
+              content: [{ type: 'text', text: `Error: ${error}` }],
+              isError: true,
+            },
+          });
+        }
+
+        return NextResponse.json({
+          jsonrpc: '2.0',
+          id: body.id,
+          result: {
+            content: [{
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            }],
+          },
+        });
+      }
+
+      case 'notifications/initialized': {
+        // Acknowledgment, no response needed
+        return NextResponse.json({
+          jsonrpc: '2.0',
+          id: body.id,
+          result: {},
+        });
+      }
+
+      default: {
+        return NextResponse.json({
+          jsonrpc: '2.0',
+          id: body.id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${body.method}`,
+          },
+        }, { status: 400 });
+      }
+    }
+  } catch (error) {
+    console.error(`MCP error for server ${serverId}:`, error);
+    return NextResponse.json({
+      jsonrpc: '2.0',
+      id: 0,
+      error: {
+        code: -32603,
+        message: error instanceof Error ? error.message : 'Internal error',
+      },
+    }, { status: 500 });
+  }
+}
+
+/**
+ * GET /api/mcp/[serverId] - Server info endpoint
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ serverId: string }> }
+): Promise<NextResponse> {
+  const { serverId } = await params;
+  const config = await getServerConfig(serverId);
+  
+  if (!config) {
+    return NextResponse.json({ error: 'Server not found' }, { status: 404 });
+  }
+
+  return NextResponse.json({
+    name: config.name,
+    serverId,
+    status: 'active',
+    toolCount: config.tools.length,
+    tools: config.tools.map(t => t.name),
+    endpoint: `${process.env.NEXT_PUBLIC_APP_URL || ''}/api/mcp/${serverId}`,
+    protocol: 'MCP 2024-11-05',
+    transport: 'HTTP/POST',
+  });
+}