github-to-mcp-monorepo 1.0.0

package/apps/web/app/api/playground/v2/disconnect/route.ts

@@ -0,0 +1,88 @@
+/**
+ * Disconnect API Route
+ *
+ * POST /api/playground/v2/disconnect
+ * Closes an MCP server connection and cleans up the session.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  handleApiError,
+  createSuccessResponse,
+  SessionExpiredError,
+  validateSessionId,
+  applyMiddleware,
+  corsPreflightResponse,
+  createLogContext,
+  SessionManager,
+  withRequestId,
+} from '@/lib/api';
+import type { DisconnectResponseData } from '@/lib/api';
+
+const PATH = '/api/playground/v2/disconnect';
+
+/**
+ * Handle CORS preflight request
+ */
+export async function OPTIONS(): Promise<NextResponse> {
+  return corsPreflightResponse({ methods: ['POST', 'OPTIONS'] });
+}
+
+/**
+ * POST /api/playground/v2/disconnect
+ *
+ * Closes an MCP server connection.
+ *
+ * Request body:
+ * - sessionId: string (required) - The session ID to disconnect
+ *
+ * Response:
+ * - success: boolean
+ * - data: { disconnected: boolean }
+ */
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request);
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('POST', PATH, context.requestId, context.clientId);
+
+  try {
+    const body = await request.json();
+    const sessionId = validateSessionId(body);
+
+    const sessionManager = SessionManager.getInstance();
+
+    // Check if session exists
+    const session = await sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new SessionExpiredError(
+        `Session not found or already expired: ${sessionId}`,
+        sessionId
+      );
+    }
+
+    // Delete the session
+    const deleted = await sessionManager.deleteSession(sessionId);
+
+    const responseData: DisconnectResponseData = {
+      disconnected: deleted,
+    };
+
+    log.log(200, sessionId);
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}

package/apps/web/app/api/playground/v2/health/route.ts

@@ -0,0 +1,80 @@
+/**
+ * Health API Route
+ *
+ * GET /api/playground/v2/health - Get API health status
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  handleApiError,
+  createSuccessResponse,
+  corsPreflightResponse,
+  createLogContext,
+  SessionManager,
+  withRequestId,
+  NO_RATE_LIMIT,
+  applyMiddleware,
+} from '@/lib/api';
+import type { HealthResponseData } from '@/lib/api';
+
+const PATH = '/api/playground/v2/health';
+const startTime = Date.now();
+
+/**
+ * Handle CORS preflight request
+ */
+export async function OPTIONS(): Promise<NextResponse> {
+  return corsPreflightResponse({ methods: ['GET', 'OPTIONS'] });
+}
+
+/**
+ * GET /api/playground/v2/health
+ *
+ * Returns health status of the playground API.
+ *
+ * Response:
+ * - success: boolean
+ * - data: { status: string, version: string, uptime: number, sessions: { active: number } }
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: NO_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('GET', PATH, context.requestId, context.clientId);
+
+  try {
+    const sessionManager = SessionManager.getInstance();
+    const sessions = await sessionManager.listSessions();
+    const activeSessions = sessions.length;
+
+    const uptime = Math.floor((Date.now() - startTime) / 1000);
+
+    const responseData: HealthResponseData = {
+      status: 'healthy',
+      version: '2.0.0',
+      uptime,
+      sessions: {
+        active: activeSessions,
+      },
+      timestamp: new Date().toISOString(),
+    };
+
+    log.log(200, undefined, undefined, { activeSessions, uptime });
+
+    return createSuccessResponse(responseData, 200, {
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+      // Don't cache health checks
+      'Cache-Control': 'no-store, no-cache, must-revalidate',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}

package/apps/web/app/api/playground/v2/prompts/route.ts

@@ -0,0 +1,160 @@
+/**
+ * Prompts API Route
+ *
+ * GET /api/playground/v2/prompts - List all prompts
+ * POST /api/playground/v2/prompts - Get a prompt
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  handleApiError,
+  createSuccessResponse,
+  SessionExpiredError,
+  McpExecutionError,
+  NotFoundError,
+  validatePromptGet,
+  validateSessionIdFromQuery,
+  applyMiddleware,
+  corsPreflightResponse,
+  createLogContext,
+  SessionManager,
+  withRequestId,
+  RELAXED_RATE_LIMIT,
+} from '@/lib/api';
+import type { PromptsListResponseData, PromptGetResponseData } from '@/lib/api';
+
+const PATH = '/api/playground/v2/prompts';
+
+/**
+ * Handle CORS preflight request
+ */
+export async function OPTIONS(): Promise<NextResponse> {
+  return corsPreflightResponse({ methods: ['GET', 'POST', 'OPTIONS'] });
+}
+
+/**
+ * GET /api/playground/v2/prompts
+ *
+ * Lists all available prompts for a session.
+ *
+ * Query parameters:
+ * - sessionId: string (required) - The session ID
+ *
+ * Response:
+ * - success: boolean
+ * - data: { prompts: McpPrompt[] }
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: RELAXED_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('GET', PATH, context.requestId, context.clientId);
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const sessionId = validateSessionIdFromQuery(searchParams);
+
+    const sessionManager = SessionManager.getInstance();
+
+    const session = await sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new SessionExpiredError(
+        `Session not found or expired: ${sessionId}`,
+        sessionId
+      );
+    }
+
+    const prompts = await sessionManager.listPrompts(sessionId);
+
+    const responseData: PromptsListResponseData = { prompts };
+
+    log.log(200, sessionId);
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}
+
+/**
+ * POST /api/playground/v2/prompts
+ *
+ * Gets a prompt with optional arguments.
+ *
+ * Request body:
+ * - sessionId: string (required) - The session ID
+ * - name: string (required) - Name of the prompt to get
+ * - args: object (optional) - Prompt arguments
+ *
+ * Response:
+ * - success: boolean
+ * - data: { description?: string, messages: McpPromptMessage[] }
+ */
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: RELAXED_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('POST', PATH, context.requestId, context.clientId);
+
+  try {
+    const body = await request.json();
+    const { sessionId, name, args } = validatePromptGet(body);
+
+    const sessionManager = SessionManager.getInstance();
+
+    const session = await sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new SessionExpiredError(
+        `Session not found or expired: ${sessionId}`,
+        sessionId
+      );
+    }
+
+    let result;
+
+    try {
+      result = await sessionManager.getPrompt(sessionId, name, args);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('not found')) {
+        throw new NotFoundError(`Prompt not found: ${name}`, 'prompt');
+      }
+      throw new McpExecutionError(
+        `Prompt retrieval failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        { executionType: 'prompt', name }
+      );
+    }
+
+    const responseData: PromptGetResponseData = {
+      description: result.description,
+      messages: result.messages,
+    };
+
+    log.log(200, sessionId, undefined, { promptName: name });
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}

package/apps/web/app/api/playground/v2/resources/route.ts

@@ -0,0 +1,159 @@
+/**
+ * Resources API Route
+ *
+ * GET /api/playground/v2/resources - List all resources
+ * POST /api/playground/v2/resources - Read a resource
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  handleApiError,
+  createSuccessResponse,
+  SessionExpiredError,
+  McpExecutionError,
+  NotFoundError,
+  validateResourceRead,
+  validateSessionIdFromQuery,
+  applyMiddleware,
+  corsPreflightResponse,
+  createLogContext,
+  SessionManager,
+  withRequestId,
+  RELAXED_RATE_LIMIT,
+} from '@/lib/api';
+import type { ResourcesListResponseData, ResourceReadResponseData } from '@/lib/api';
+
+const PATH = '/api/playground/v2/resources';
+
+/**
+ * Handle CORS preflight request
+ */
+export async function OPTIONS(): Promise<NextResponse> {
+  return corsPreflightResponse({ methods: ['GET', 'POST', 'OPTIONS'] });
+}
+
+/**
+ * GET /api/playground/v2/resources
+ *
+ * Lists all available resources for a session.
+ *
+ * Query parameters:
+ * - sessionId: string (required) - The session ID
+ *
+ * Response:
+ * - success: boolean
+ * - data: { resources: McpResource[], resourceTemplates?: McpResourceTemplate[] }
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: RELAXED_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('GET', PATH, context.requestId, context.clientId);
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const sessionId = validateSessionIdFromQuery(searchParams);
+
+    const sessionManager = SessionManager.getInstance();
+
+    const session = await sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new SessionExpiredError(
+        `Session not found or expired: ${sessionId}`,
+        sessionId
+      );
+    }
+
+    const { resources, resourceTemplates } = await sessionManager.listResources(sessionId);
+
+    const responseData: ResourcesListResponseData = {
+      resources,
+      resourceTemplates,
+    };
+
+    log.log(200, sessionId);
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}
+
+/**
+ * POST /api/playground/v2/resources
+ *
+ * Reads a resource.
+ *
+ * Request body:
+ * - sessionId: string (required) - The session ID
+ * - uri: string (required) - URI of the resource to read
+ *
+ * Response:
+ * - success: boolean
+ * - data: { contents: McpResourceContents[] }
+ */
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: RELAXED_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('POST', PATH, context.requestId, context.clientId);
+
+  try {
+    const body = await request.json();
+    const { sessionId, uri } = validateResourceRead(body);
+
+    const sessionManager = SessionManager.getInstance();
+
+    const session = await sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new SessionExpiredError(
+        `Session not found or expired: ${sessionId}`,
+        sessionId
+      );
+    }
+
+    let contents;
+
+    try {
+      contents = await sessionManager.readResource(sessionId, uri);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('not found')) {
+        throw new NotFoundError(`Resource not found: ${uri}`, 'resource');
+      }
+      throw new McpExecutionError(
+        `Resource read failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        { executionType: 'resource', name: uri }
+      );
+    }
+
+    const responseData: ResourceReadResponseData = { contents };
+
+    log.log(200, sessionId, undefined, { uri });
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}

package/apps/web/app/api/playground/v2/sessions/route.ts

@@ -0,0 +1,184 @@
+/**
+ * Sessions API Route
+ *
+ * GET /api/playground/v2/sessions - List active sessions
+ * DELETE /api/playground/v2/sessions - Remove a session
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  handleApiError,
+  createSuccessResponse,
+  ValidationError,
+  SessionExpiredError,
+  applyMiddleware,
+  corsPreflightResponse,
+  createLogContext,
+  SessionManager,
+  withRequestId,
+  DEFAULT_RATE_LIMIT,
+  RELAXED_RATE_LIMIT,
+} from '@/lib/api';
+import type { SessionsListResponseData, DisconnectResponseData } from '@/lib/api';
+
+const PATH = '/api/playground/v2/sessions';
+
+/**
+ * Handle CORS preflight request
+ */
+export async function OPTIONS(): Promise<NextResponse> {
+  return corsPreflightResponse({ methods: ['GET', 'DELETE', 'OPTIONS'] });
+}
+
+/**
+ * GET /api/playground/v2/sessions
+ *
+ * Lists all active sessions.
+ *
+ * Query parameters:
+ * - clientId: string (optional) - Filter by client ID
+ *
+ * Response:
+ * - success: boolean
+ * - data: { sessions: SessionInfo[], count: number }
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: RELAXED_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('GET', PATH, context.requestId, context.clientId);
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const clientId = searchParams.get('clientId');
+
+    const sessionManager = SessionManager.getInstance();
+    let sessions = await sessionManager.listSessions();
+
+    // Filter by clientId if provided
+    if (clientId) {
+      sessions = sessions.filter((s) => s.clientId === clientId);
+    }
+
+    const responseData: SessionsListResponseData = {
+      sessions,
+      count: sessions.length,
+    };
+
+    log.log(200, undefined, undefined, { sessionCount: sessions.length });
+
+    return createSuccessResponse(responseData, 200, {
+      ...context.rateLimitHeaders,
+      ...withRequestId({}, context.requestId),
+      'Access-Control-Allow-Origin': '*',
+    });
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}
+
+/**
+ * DELETE /api/playground/v2/sessions
+ *
+ * Removes a session by ID or all sessions for a client.
+ *
+ * Query parameters:
+ * - sessionId: string (optional) - Specific session to remove
+ * - clientId: string (optional) - Remove all sessions for this client
+ *
+ * At least one of sessionId or clientId must be provided.
+ *
+ * Response:
+ * - success: boolean
+ * - data: { disconnected: boolean, sessionId?: string, removedCount?: number }
+ */
+export async function DELETE(request: NextRequest): Promise<NextResponse> {
+  const middleware = await applyMiddleware(request, { rateLimit: DEFAULT_RATE_LIMIT });
+  if ('response' in middleware) {
+    return middleware.response;
+  }
+
+  const { context } = middleware;
+  const log = createLogContext('DELETE', PATH, context.requestId, context.clientId);
+
+  try {
+    const { searchParams } = new URL(request.url);
+    const sessionId = searchParams.get('sessionId');
+    const clientId = searchParams.get('clientId');
+
+    if (!sessionId && !clientId) {
+      throw new ValidationError(
+        'Either sessionId or clientId is required',
+        'query'
+      );
+    }
+
+    const sessionManager = SessionManager.getInstance();
+
+    if (sessionId) {
+      // Remove specific session
+      const session = await sessionManager.getSession(sessionId);
+      if (!session) {
+        throw new SessionExpiredError(
+          `Session not found or expired: ${sessionId}`,
+          sessionId
+        );
+      }
+
+      const success = await sessionManager.deleteSession(sessionId);
+
+      const responseData: DisconnectResponseData = {
+        disconnected: success,
+        sessionId,
+      };
+
+      log.log(200, sessionId);
+
+      return createSuccessResponse(responseData, 200, {
+        ...context.rateLimitHeaders,
+        ...withRequestId({}, context.requestId),
+        'Access-Control-Allow-Origin': '*',
+      });
+    } else if (clientId) {
+      // Remove all sessions for this client
+      const allSessions = await sessionManager.listSessions();
+      const sessions = allSessions.filter((s) => s.clientId === clientId);
+      let removedCount = 0;
+
+      for (const session of sessions) {
+        const success = await sessionManager.deleteSession(session.id);
+        if (success) removedCount++;
+      }
+
+      const responseData = {
+        disconnected: removedCount > 0,
+        removedCount,
+        clientId,
+      };
+
+      log.log(200, undefined, undefined, { removedCount });
+
+      return createSuccessResponse(responseData, 200, {
+        ...context.rateLimitHeaders,
+        ...withRequestId({}, context.requestId),
+        'Access-Control-Allow-Origin': '*',
+      });
+    }
+
+    // Should never reach here due to validation above
+    throw new ValidationError('Invalid request parameters', 'query');
+  } catch (error) {
+    const status = error instanceof Error && 'statusCode' in error
+      ? (error as { statusCode: number }).statusCode
+      : 500;
+    log.log(status, undefined, error instanceof Error ? error.message : 'Unknown error');
+    return handleApiError(error);
+  }
+}