cdk-serverless 3.2.0 → 3.3.0

package/lib/lambda/handler.js

@@ -152,6 +152,16 @@ const createHttpHandler = (handler) => {
     };
 };
 exports.createHttpHandler = createHttpHandler;
+/**
+ * Looks up a header value case-insensitively.
+ * HTTP header names are case-insensitive per RFC 9110 §5.1.
+ */
+function headerValue(headers, name) {
+    if (!headers)
+        return undefined;
+    const key = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());
+    return key ? headers[key] : undefined;
+}
 /**
  * This function takes an event object representing an API Gateway Proxy event
  * with a Cognito authorizer, and extracts and parses the request body, if present.
@@ -167,7 +177,7 @@ function parseBody(event) {
         body = buff.toString('utf8');
     }
     // If the request body is in JSON format, parse it into a JavaScript object
-    if (event.headers && event.headers['content-type']?.includes('application/json')) {
+    if (headerValue(event.headers, 'content-type')?.includes('application/json')) {
         return JSON.parse(body ?? '{}');
     }
     // If the request body is not present or not in JSON format, return it as-is
@@ -180,9 +190,10 @@ function parseBody(event) {
  * @returns An object containing the CORS headers.
  */
 function corsHeader(event) {
+    const origin = headerValue(event?.headers, 'origin');
     return {
-        'Access-Control-Allow-Origin': event?.headers?.origin ?? '*', // Allow requests from the origin header, or allow any origin if not present
-        'Access-Control-Allow-Credentials': event?.headers?.origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present
+        'Access-Control-Allow-Origin': origin ?? '*', // Allow requests from the origin header, or allow any origin if not present
+        'Access-Control-Allow-Credentials': origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present
         'Access-Control-Allow-Methods': '*', // Allow any HTTP method
         'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers
     };
@@ -221,4 +232,4 @@ const createAppSyncHandler = (handler) => {
     };
 };
 exports.createAppSyncHandler = createAppSyncHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/lambda/handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { env } from 'process';\nimport logger, { LambdaLog } from 'lambda-log';\nimport {\n  ApiGatewayv1CognitoAuthorizer,\n  ApiGatewayv1JwtAuthorizer,\n  AppSyncCognitoAuthorizer,\n  CognitoAuthorizer,\n  JwtAuthorizer,\n} from './auth';\nimport * as errors from './errors';\n\n\n/////////////////////////////////\n/// HTTP Api\n/////////////////////////////////\n\n/**\n * An object containing the properties for an HTTP response.\n */\nexport interface HttpResponseContext {\n  statusCode?: number;\n  headers: { [name: string]: string };\n  json: boolean;\n}\n\n/**\n * An object containing the properties for an HTTP request handler.\n */\nexport interface HttpHandlerContext {\n  event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  response: HttpResponseContext;\n  auth: JwtAuthorizer;\n}\n\n/**\n * A type definition for an HTTP handler.\n */\nexport type HttpHandler<T, R> = (\n  context: HttpHandlerContext,\n  body: T,\n) => Promise<R>;\n\n/**\n * An object containing the properties for an OpenAPI operation.\n */\nexport interface Operation {\n  responses: {\n    [statusCode: number]: {\n      content: {\n        'application/json': any;\n      };\n    } | any;\n  };\n}\n\n/**\n * A type definition for an API Gateway v1 request handler.\n */\nexport type APIGatewayv1Handler =\n  AWSLambda.Handler<AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, AWSLambda.APIGatewayProxyResult | undefined>;\n\n/**\n * An object containing the properties for an OpenAPI operation with a request body.\n */\nexport interface OperationWithRequestBody extends Operation {\n  requestBody: { content: { 'application/json': any } };\n}\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body.\n */\nexport const createOpenApiHandlerWithRequestBody = <OP extends OperationWithRequestBody, SC extends number = 200>(handler: HttpHandler<OP['requestBody']['content']['application/json'], OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body and no response.\n */\nexport const createOpenApiHandlerWithRequestBodyNoResponse = <OP extends OperationWithRequestBody>(handler: HttpHandler<OP['requestBody']['content']['application/json'], void>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation.\n */\nexport const createOpenApiHandler = <OP extends Operation, SC extends number = 200>(handler: HttpHandler<any, OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * Create an authorizer for the authentication method chosen (JWT or Cognito).\n */\nconst createAuthorizer = (event: AWSLambda.APIGatewayProxyEventBase<AWSLambda.APIGatewayProxyCognitoAuthorizer>, log: LambdaLog) => {\n  // If Cognito is used, USER_POOL_ID is injected into the function's environment. Currently assumes JWT otherwise.\n  if (env.USER_POOL_ID) {\n    return new ApiGatewayv1CognitoAuthorizer(event, log);\n  } else {\n    // This might need to get more sophisticated if more authorization methods need to be supported.\n    return new ApiGatewayv1JwtAuthorizer(event, 'admin', log);\n  }\n};\n\n/**\n * A factory function that creates an HTTP request handler.\n */\nexport const createHttpHandler =\n  <T, R>(handler: HttpHandler<T, R>): APIGatewayv1Handler => {\n    return async (event, context) => {\n      // Create an object to hold the context for this HTTP request\n      const auth = createAuthorizer(event, logger as unknown as logger.LambdaLog);\n      const ctx: HttpHandlerContext = {\n        event,\n        auth,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        response: { headers: {}, json: true },\n      };\n      // Add the request ID to the logging metadata, and enable debug logging if the DEBUG environment variable is set to \"true\"\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // Log the event object for debugging purposes\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // Authenticate the user using the Cognito authorizer\n        await ctx.auth.authenticate();\n\n        // Call the user-defined handler function, passing in the request context object and the parsed request body\n        const res = await handler(ctx, parseBody(event));\n\n        // Construct and return the HTTP response\n        return {\n          statusCode: ctx.response.statusCode ?? (res ? 200 : 204),\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: res ? (ctx.response.json ? JSON.stringify(res) : res) : '',\n        };\n      } catch (error: any) {\n        // Handle any errors that occur during request processing\n\n        // If the error is an instance of HttpError, return an HTTP response with the error status code and message\n        if (error instanceof errors.HttpError) {\n          return {\n            statusCode: error.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: error.message,\n          };\n        }\n        // If the error is a Boom error (from the hapi.js framework), return an HTTP response with the error status code and payload\n        if (error.isBoom) {\n          return {\n            statusCode: error.output.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...error.output.headers,\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: JSON.stringify(error.output.payload),\n          };\n        }\n        // For all other types of errors, log the error and return a 500 status code with the error message\n        ctx.logger.error(error);\n        return {\n          statusCode: ctx.response.statusCode ?? 500,\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: error.toString(),\n        };\n      }\n    };\n  };\n\n/**\n * This function takes an event object representing an API Gateway Proxy event\n * with a Cognito authorizer, and extracts and parses the request body, if present.\n *\n * @param event The API Gateway Proxy event with a Cognito authorizer\n * @returns The parsed request body\n */\nfunction parseBody<T>(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): T {\n  let body = event.body;\n\n  // If the request body is base64-encoded, decode it\n  if (event.body && event.isBase64Encoded) {\n    const buff = Buffer.from(event.body!, 'base64');\n    body = buff.toString('utf8');\n  }\n\n  // If the request body is in JSON format, parse it into a JavaScript object\n  if (event.headers && event.headers['content-type']?.includes('application/json')) {\n    return JSON.parse(body ?? '{}');\n  }\n\n  // If the request body is not present or not in JSON format, return it as-is\n  return body as any;\n}\n\n\n/**\n * Returns the CORS headers to be included in the API Gateway response.\n *\n * @param event - The API Gateway event object.\n * @returns An object containing the CORS headers.\n */\nfunction corsHeader(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): { [name: string]: string } {\n  return {\n    'Access-Control-Allow-Origin': event?.headers?.origin ?? '*', // Allow requests from the origin header, or allow any origin if not present\n    'Access-Control-Allow-Credentials': event?.headers?.origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present\n    'Access-Control-Allow-Methods': '*', // Allow any HTTP method\n    'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers\n  };\n}\n\n/////////////////////////////////\n/// AppSync\n/////////////////////////////////\n\n/**\n * The context for the AppSync resolver function.\n * Contains information about the event, lambda context, logger, and Cognito authorizer.\n */\nexport interface AppSyncHandlerContext<T> {\n  event: AWSLambda.AppSyncResolverEvent<T>;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  cognitoAuth: CognitoAuthorizer;\n}\n\n/**\n * A function that handles an AppSync resolver event.\n * Receives the context object and returns the response.\n */\nexport type AppSyncHandler<T, R> = (\n  context: AppSyncHandlerContext<T>,\n) => Promise<R>;\n\n/**\n * Creates an AppSync resolver handler from the given AppSyncHandler.\n * Returns a function that can be used as an AppSync resolver.\n *\n * @param handler The AppSyncHandler to use as the resolver.\n */\nexport const createAppSyncHandler =\n  <T, R>(handler: AppSyncHandler<T, R>): AWSLambda.AppSyncResolverHandler<T, R> => {\n    return async (event, context) => {\n      const ctx: AppSyncHandlerContext<T> = {\n        event,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        cognitoAuth: new AppSyncCognitoAuthorizer(event),\n      };\n\n      // set the meta information in logger\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      // set the debug flag for logger\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // log the received event\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // authenticate the incoming request\n        await ctx.cognitoAuth.authenticate();\n        // invoke the handler function with the context\n        return await handler(ctx);\n      } catch (error: any) {\n        // log the error and throw it again\n        ctx.logger.error(error);\n        throw error;\n      }\n    };\n  };\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/lambda/handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { env } from 'process';\nimport logger, { LambdaLog } from 'lambda-log';\nimport {\n  ApiGatewayv1CognitoAuthorizer,\n  ApiGatewayv1JwtAuthorizer,\n  AppSyncCognitoAuthorizer,\n  CognitoAuthorizer,\n  JwtAuthorizer,\n} from './auth';\nimport * as errors from './errors';\n\n\n/////////////////////////////////\n/// HTTP Api\n/////////////////////////////////\n\n/**\n * An object containing the properties for an HTTP response.\n */\nexport interface HttpResponseContext {\n  statusCode?: number;\n  headers: { [name: string]: string };\n  json: boolean;\n}\n\n/**\n * An object containing the properties for an HTTP request handler.\n */\nexport interface HttpHandlerContext {\n  event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  response: HttpResponseContext;\n  auth: JwtAuthorizer;\n}\n\n/**\n * A type definition for an HTTP handler.\n */\nexport type HttpHandler<T, R> = (\n  context: HttpHandlerContext,\n  body: T,\n) => Promise<R>;\n\n/**\n * An object containing the properties for an OpenAPI operation.\n */\nexport interface Operation {\n  responses: {\n    [statusCode: number]: {\n      content: {\n        'application/json': any;\n      };\n    } | any;\n  };\n}\n\n/**\n * A type definition for an API Gateway v1 request handler.\n */\nexport type APIGatewayv1Handler =\n  AWSLambda.Handler<AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, AWSLambda.APIGatewayProxyResult | undefined>;\n\n/**\n * An object containing the properties for an OpenAPI operation with a request body.\n */\nexport interface OperationWithRequestBody extends Operation {\n  requestBody: { content: { 'application/json': any } };\n}\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body.\n */\nexport const createOpenApiHandlerWithRequestBody = <OP extends OperationWithRequestBody, SC extends number = 200>(handler: HttpHandler<OP['requestBody']['content']['application/json'], OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body and no response.\n */\nexport const createOpenApiHandlerWithRequestBodyNoResponse = <OP extends OperationWithRequestBody>(handler: HttpHandler<OP['requestBody']['content']['application/json'], void>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * A factory function that creates an HTTP request handler for an OpenAPI operation.\n */\nexport const createOpenApiHandler = <OP extends Operation, SC extends number = 200>(handler: HttpHandler<any, OP['responses'][SC]['content']['application/json']>): APIGatewayv1Handler => {\n  return createHttpHandler(handler);\n};\n\n/**\n * Create an authorizer for the authentication method chosen (JWT or Cognito).\n */\nconst createAuthorizer = (event: AWSLambda.APIGatewayProxyEventBase<AWSLambda.APIGatewayProxyCognitoAuthorizer>, log: LambdaLog) => {\n  // If Cognito is used, USER_POOL_ID is injected into the function's environment. Currently assumes JWT otherwise.\n  if (env.USER_POOL_ID) {\n    return new ApiGatewayv1CognitoAuthorizer(event, log);\n  } else {\n    // This might need to get more sophisticated if more authorization methods need to be supported.\n    return new ApiGatewayv1JwtAuthorizer(event, 'admin', log);\n  }\n};\n\n/**\n * A factory function that creates an HTTP request handler.\n */\nexport const createHttpHandler =\n  <T, R>(handler: HttpHandler<T, R>): APIGatewayv1Handler => {\n    return async (event, context) => {\n      // Create an object to hold the context for this HTTP request\n      const auth = createAuthorizer(event, logger as unknown as logger.LambdaLog);\n      const ctx: HttpHandlerContext = {\n        event,\n        auth,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        response: { headers: {}, json: true },\n      };\n      // Add the request ID to the logging metadata, and enable debug logging if the DEBUG environment variable is set to \"true\"\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // Log the event object for debugging purposes\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // Authenticate the user using the Cognito authorizer\n        await ctx.auth.authenticate();\n\n        // Call the user-defined handler function, passing in the request context object and the parsed request body\n        const res = await handler(ctx, parseBody(event));\n\n        // Construct and return the HTTP response\n        return {\n          statusCode: ctx.response.statusCode ?? (res ? 200 : 204),\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: res ? (ctx.response.json ? JSON.stringify(res) : res) : '',\n        };\n      } catch (error: any) {\n        // Handle any errors that occur during request processing\n\n        // If the error is an instance of HttpError, return an HTTP response with the error status code and message\n        if (error instanceof errors.HttpError) {\n          return {\n            statusCode: error.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: error.message,\n          };\n        }\n        // If the error is a Boom error (from the hapi.js framework), return an HTTP response with the error status code and payload\n        if (error.isBoom) {\n          return {\n            statusCode: error.output.statusCode,\n            headers: {\n              'Content-Type': 'application/json',\n              ...error.output.headers,\n              ...corsHeader(event),\n              ...ctx.response.headers,\n            },\n            body: JSON.stringify(error.output.payload),\n          };\n        }\n        // For all other types of errors, log the error and return a 500 status code with the error message\n        ctx.logger.error(error);\n        return {\n          statusCode: ctx.response.statusCode ?? 500,\n          headers: {\n            'Content-Type': 'application/json',\n            ...corsHeader(event),\n            ...ctx.response.headers,\n          },\n          body: error.toString(),\n        };\n      }\n    };\n  };\n\n/**\n * Looks up a header value case-insensitively.\n * HTTP header names are case-insensitive per RFC 9110 §5.1.\n */\nfunction headerValue(headers: Record<string, string | undefined> | null | undefined, name: string): string | undefined {\n  if (!headers) return undefined;\n  const key = Object.keys(headers).find(k => k.toLowerCase() === name.toLowerCase());\n  return key ? headers[key] : undefined;\n}\n\n/**\n * This function takes an event object representing an API Gateway Proxy event\n * with a Cognito authorizer, and extracts and parses the request body, if present.\n *\n * @param event The API Gateway Proxy event with a Cognito authorizer\n * @returns The parsed request body\n */\nfunction parseBody<T>(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): T {\n  let body = event.body;\n\n  // If the request body is base64-encoded, decode it\n  if (event.body && event.isBase64Encoded) {\n    const buff = Buffer.from(event.body!, 'base64');\n    body = buff.toString('utf8');\n  }\n\n  // If the request body is in JSON format, parse it into a JavaScript object\n  if (headerValue(event.headers, 'content-type')?.includes('application/json')) {\n    return JSON.parse(body ?? '{}');\n  }\n\n  // If the request body is not present or not in JSON format, return it as-is\n  return body as any;\n}\n\n\n/**\n * Returns the CORS headers to be included in the API Gateway response.\n *\n * @param event - The API Gateway event object.\n * @returns An object containing the CORS headers.\n */\nfunction corsHeader(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent): { [name: string]: string } {\n  const origin = headerValue(event?.headers, 'origin');\n  return {\n    'Access-Control-Allow-Origin': origin ?? '*', // Allow requests from the origin header, or allow any origin if not present\n    'Access-Control-Allow-Credentials': origin ? 'true' : 'false', // Include cookies in cross-origin requests if the origin header is present\n    'Access-Control-Allow-Methods': '*', // Allow any HTTP method\n    'Access-Control-Allow-Headers': 'Authorization, *', // Allow the Authorization header and any other headers\n  };\n}\n\n/////////////////////////////////\n/// AppSync\n/////////////////////////////////\n\n/**\n * The context for the AppSync resolver function.\n * Contains information about the event, lambda context, logger, and Cognito authorizer.\n */\nexport interface AppSyncHandlerContext<T> {\n  event: AWSLambda.AppSyncResolverEvent<T>;\n  lambdaContext: AWSLambda.Context;\n  logger: logger.LambdaLog;\n  cognitoAuth: CognitoAuthorizer;\n}\n\n/**\n * A function that handles an AppSync resolver event.\n * Receives the context object and returns the response.\n */\nexport type AppSyncHandler<T, R> = (\n  context: AppSyncHandlerContext<T>,\n) => Promise<R>;\n\n/**\n * Creates an AppSync resolver handler from the given AppSyncHandler.\n * Returns a function that can be used as an AppSync resolver.\n *\n * @param handler The AppSyncHandler to use as the resolver.\n */\nexport const createAppSyncHandler =\n  <T, R>(handler: AppSyncHandler<T, R>): AWSLambda.AppSyncResolverHandler<T, R> => {\n    return async (event, context) => {\n      const ctx: AppSyncHandlerContext<T> = {\n        event,\n        lambdaContext: context,\n        logger: logger as unknown as logger.LambdaLog,\n        cognitoAuth: new AppSyncCognitoAuthorizer(event),\n      };\n\n      // set the meta information in logger\n      ctx.logger.options.meta.requestId = context.awsRequestId;\n      // set the debug flag for logger\n      ctx.logger.options.debug = process.env.DEBUG === 'true';\n\n      // log the received event\n      ctx.logger.debug(JSON.stringify(event));\n\n      try {\n        // authenticate the incoming request\n        await ctx.cognitoAuth.authenticate();\n        // invoke the handler function with the context\n        return await handler(ctx);\n      } catch (error: any) {\n        // log the error and throw it again\n        ctx.logger.error(error);\n        throw error;\n      }\n    };\n  };\n\n"]}

package/lib/mcp-auth/config.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Configuration for the MCP OAuth façade.
+ * Service-agnostic: works with any OAuth2/OIDC provider that exposes
+ * a standard authorize + token endpoint.
+ */
+export interface McpAuthConfig {
+    /** The API domain serving as the OAuth issuer (e.g. 'api.example.com') */
+    readonly apiDomain: string;
+    /**
+     * The upstream OAuth authorize endpoint URL.
+     * The authorize handler proxies requests here (302 redirect).
+     * Example: 'https://auth.example.com/oauth2/authorize'
+     */
+    readonly authorizeEndpoint: string;
+    /**
+     * The upstream OAuth token endpoint URL.
+     * The token handler proxies requests here.
+     * Example: 'https://auth.example.com/oauth2/token'
+     */
+    readonly tokenEndpoint: string;
+    /** Allowed redirect URIs for dynamic client registration */
+    readonly allowedRedirectUris: string[];
+    /** The pre-provisioned OAuth client ID returned by registration */
+    readonly clientId: string;
+    /** MCP server info for the initialize response */
+    readonly serverInfo: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /** Supported MCP protocol versions */
+    readonly protocolVersions: string[];
+    /** OAuth scopes to advertise in discovery metadata */
+    readonly scopes?: string[];
+    /**
+     * Parameters to strip from authorize/token requests before proxying.
+     * Defaults to ['resource'] (RFC 8707 not supported by most providers).
+     */
+    readonly stripParameters?: string[];
+}

package/lib/mcp-auth/config.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/authorization-server.d.ts

@@ -0,0 +1,7 @@
+import type { McpAuthConfig } from '../config';
+import type { McpOAuthHandler } from './types';
+/**
+ * Factory for the `/.well-known/oauth-authorization-server` endpoint (RFC 8414).
+ * Returns OAuth server metadata with all endpoint URLs pointing to the API domain.
+ */
+export declare function createAuthorizationServerHandler(config: McpAuthConfig): McpOAuthHandler;

package/lib/mcp-auth/handlers/authorization-server.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthorizationServerHandler = createAuthorizationServerHandler;
+/**
+ * Factory for the `/.well-known/oauth-authorization-server` endpoint (RFC 8414).
+ * Returns OAuth server metadata with all endpoint URLs pointing to the API domain.
+ */
+function createAuthorizationServerHandler(config) {
+    return async (event) => {
+        console.log(JSON.stringify({
+            event: 'oauth-authorization-server',
+            method: event.httpMethod,
+            path: event.path,
+        }));
+        const scopes = config.scopes ?? ['openid', 'email', 'profile'];
+        const body = {
+            issuer: `https://${config.apiDomain}`,
+            authorization_endpoint: `https://${config.apiDomain}/oauth/authorize`,
+            token_endpoint: `https://${config.apiDomain}/oauth/token`,
+            registration_endpoint: `https://${config.apiDomain}/oauth/register`,
+            scopes_supported: scopes,
+            response_types_supported: ['code'],
+            grant_types_supported: ['authorization_code', 'refresh_token'],
+            code_challenge_methods_supported: ['S256'],
+            token_endpoint_auth_methods_supported: ['none'],
+        };
+        return {
+            statusCode: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/authorize.d.ts

@@ -0,0 +1,8 @@
+import type { McpAuthConfig } from '../config';
+import type { McpOAuthHandler } from './types';
+/**
+ * Factory for the `/oauth/authorize` proxy endpoint.
+ * Strips configured parameters (default: 'resource') before redirecting
+ * to the upstream authorization endpoint.
+ */
+export declare function createAuthorizeHandler(config: McpAuthConfig): McpOAuthHandler;

package/lib/mcp-auth/handlers/authorize.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthorizeHandler = createAuthorizeHandler;
+/**
+ * Factory for the `/oauth/authorize` proxy endpoint.
+ * Strips configured parameters (default: 'resource') before redirecting
+ * to the upstream authorization endpoint.
+ */
+function createAuthorizeHandler(config) {
+    return async (event) => {
+        const params = new URLSearchParams(event.queryStringParameters);
+        // Strip unsupported parameters (e.g. RFC 8707 'resource')
+        const stripParams = config.stripParameters ?? ['resource'];
+        for (const param of stripParams) {
+            params.delete(param);
+        }
+        const upstreamUrl = `${config.authorizeEndpoint}?${params.toString()}`;
+        console.log(JSON.stringify({
+            event: 'oauth-authorize-proxy',
+            upstreamUrl,
+            strippedParams: stripParams.filter(p => event.queryStringParameters?.[p]),
+        }));
+        return {
+            statusCode: 302,
+            headers: {
+                'Location': upstreamUrl,
+                'Cache-Control': 'no-cache, no-store',
+            },
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './authorize';
+export * from './authorization-server';
+export * from './protected-resource';
+export * from './register';
+export * from './token';
+export * from './validate-redirect-uris';

package/lib/mcp-auth/handlers/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./authorize"), exports);
+__exportStar(require("./authorization-server"), exports);
+__exportStar(require("./protected-resource"), exports);
+__exportStar(require("./register"), exports);
+__exportStar(require("./token"), exports);
+__exportStar(require("./validate-redirect-uris"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWNwLWF1dGgvaGFuZGxlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4Qiw4Q0FBNEI7QUFDNUIseURBQXVDO0FBQ3ZDLHVEQUFxQztBQUNyQyw2Q0FBMkI7QUFDM0IsMENBQXdCO0FBQ3hCLDJEQUF5QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemUnO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uLXNlcnZlcic7XG5leHBvcnQgKiBmcm9tICcuL3Byb3RlY3RlZC1yZXNvdXJjZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlZ2lzdGVyJztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW4nO1xuZXhwb3J0ICogZnJvbSAnLi92YWxpZGF0ZS1yZWRpcmVjdC11cmlzJztcbiJdfQ==

package/lib/mcp-auth/handlers/protected-resource.d.ts

@@ -0,0 +1,7 @@
+import type { McpAuthConfig } from '../config';
+import type { McpOAuthHandler } from './types';
+/**
+ * Factory for the `/.well-known/oauth-protected-resource` endpoint (RFC 9728).
+ * Returns the resource identifier and authorization servers.
+ */
+export declare function createProtectedResourceHandler(config: McpAuthConfig): McpOAuthHandler;

package/lib/mcp-auth/handlers/protected-resource.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProtectedResourceHandler = createProtectedResourceHandler;
+/**
+ * Factory for the `/.well-known/oauth-protected-resource` endpoint (RFC 9728).
+ * Returns the resource identifier and authorization servers.
+ */
+function createProtectedResourceHandler(config) {
+    return async (event) => {
+        console.log(JSON.stringify({
+            event: 'oauth-protected-resource',
+            method: event.httpMethod,
+            path: event.path,
+        }));
+        const body = {
+            resource: `https://${config.apiDomain}/mcp`,
+            authorization_servers: [`https://${config.apiDomain}`],
+        };
+        return {
+            statusCode: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/register.d.ts

@@ -0,0 +1,7 @@
+import type { McpAuthConfig } from '../config';
+import type { McpOAuthHandler } from './types';
+/**
+ * Factory for the `/oauth/register` endpoint (RFC 7591 simplified).
+ * Validates redirect URIs against the allowlist and returns the pre-provisioned client_id.
+ */
+export declare function createRegisterHandler(config: McpAuthConfig): McpOAuthHandler;

package/lib/mcp-auth/handlers/register.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegisterHandler = createRegisterHandler;
+const validate_redirect_uris_1 = require("./validate-redirect-uris");
+/**
+ * Factory for the `/oauth/register` endpoint (RFC 7591 simplified).
+ * Validates redirect URIs against the allowlist and returns the pre-provisioned client_id.
+ */
+function createRegisterHandler(config) {
+    return async (event) => {
+        console.log(JSON.stringify({
+            event: 'register-oauth-client',
+            method: event.httpMethod,
+            path: event.path,
+        }));
+        // Parse body
+        const rawBody = event.isBase64Encoded
+            ? Buffer.from(event.body ?? '', 'base64').toString('utf-8')
+            : (event.body ?? '');
+        let data;
+        try {
+            data = typeof rawBody === 'string' ? JSON.parse(rawBody) : rawBody;
+        }
+        catch {
+            return {
+                statusCode: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'invalid_request', error_description: 'Malformed JSON body' }),
+            };
+        }
+        if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+            return {
+                statusCode: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'invalid_request', error_description: 'Request body must be a JSON object' }),
+            };
+        }
+        const redirectUris = data.redirect_uris;
+        const clientName = data.client_name ?? 'MCP Connector';
+        if (!redirectUris || !Array.isArray(redirectUris) || redirectUris.length === 0) {
+            return {
+                statusCode: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'invalid_request', error_description: 'redirect_uris is required' }),
+            };
+        }
+        if (!(0, validate_redirect_uris_1.validateRedirectUris)(redirectUris, config.allowedRedirectUris)) {
+            return {
+                statusCode: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'invalid_redirect_uri', error_description: 'One or more redirect_uris are not allowed' }),
+            };
+        }
+        const response = {
+            client_id: config.clientId,
+            client_name: clientName,
+            redirect_uris: redirectUris,
+            token_endpoint_auth_method: 'none',
+        };
+        console.log(JSON.stringify({ event: 'register-oauth-client-response', status: 201, body: response }));
+        return {
+            statusCode: 201,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(response),
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/token.d.ts

@@ -0,0 +1,8 @@
+import type { McpAuthConfig } from '../config';
+import type { McpOAuthHandler } from './types';
+/**
+ * Factory for the `/oauth/token` proxy endpoint.
+ * Forwards token exchange to the upstream token endpoint,
+ * stripping configured parameters from the request body.
+ */
+export declare function createTokenHandler(config: McpAuthConfig): McpOAuthHandler;

package/lib/mcp-auth/handlers/token.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTokenHandler = createTokenHandler;
+const ALLOWED_GRANT_TYPES = ['authorization_code', 'refresh_token'];
+/**
+ * Factory for the `/oauth/token` proxy endpoint.
+ * Forwards token exchange to the upstream token endpoint,
+ * stripping configured parameters from the request body.
+ */
+function createTokenHandler(config) {
+    return async (event) => {
+        const tokenUrl = config.tokenEndpoint;
+        // Decode body if base64-encoded
+        const rawBody = event.isBase64Encoded
+            ? Buffer.from(event.body ?? '', 'base64').toString('utf-8')
+            : (event.body ?? '');
+        // Parse form-encoded body and strip unsupported parameters
+        const params = new URLSearchParams(rawBody);
+        const stripParamsList = config.stripParameters ?? ['resource'];
+        for (const param of stripParamsList) {
+            params.delete(param);
+        }
+        // Validate grant_type
+        const grantType = params.get('grant_type');
+        if (!grantType || !ALLOWED_GRANT_TYPES.includes(grantType)) {
+            return {
+                statusCode: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'unsupported_grant_type', error_description: `grant_type must be one of: ${ALLOWED_GRANT_TYPES.join(', ')}` }),
+            };
+        }
+        const body = params.toString();
+        console.log(JSON.stringify({
+            event: 'oauth-token-proxy',
+            tokenUrl,
+            grantType,
+        }));
+        let responseBody;
+        let statusCode;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        try {
+            const response = await fetch(tokenUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body,
+                signal: controller.signal,
+            });
+            responseBody = await response.text();
+            statusCode = response.status;
+        }
+        catch (err) {
+            console.log(JSON.stringify({ event: 'oauth-token-proxy-error', error: err.message }));
+            return {
+                statusCode: 502,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: 'upstream_error', error_description: 'Token endpoint unreachable' }),
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        console.log(JSON.stringify({
+            event: 'oauth-token-proxy-response',
+            status: statusCode,
+        }));
+        return {
+            statusCode,
+            headers: { 'Content-Type': 'application/json' },
+            body: responseBody,
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp-auth/handlers/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A generic Lambda-like handler: receives an event (simplified) and returns
+ * a response with statusCode, headers, and body.
+ */
+export interface McpOAuthResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body?: string;
+}
+export interface McpOAuthEvent {
+    httpMethod: string;
+    path: string;
+    headers: Record<string, string | undefined>;
+    queryStringParameters: Record<string, string | undefined> | null;
+    body: string | null;
+    isBase64Encoded: boolean;
+}
+/**
+ * Handler function signature returned by all factories.
+ */
+export type McpOAuthHandler = (event: McpOAuthEvent) => Promise<McpOAuthResponse>;

package/lib/mcp-auth/handlers/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWNwLWF1dGgvaGFuZGxlcnMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQSBnZW5lcmljIExhbWJkYS1saWtlIGhhbmRsZXI6IHJlY2VpdmVzIGFuIGV2ZW50IChzaW1wbGlmaWVkKSBhbmQgcmV0dXJuc1xuICogYSByZXNwb25zZSB3aXRoIHN0YXR1c0NvZGUsIGhlYWRlcnMsIGFuZCBib2R5LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIE1jcE9BdXRoUmVzcG9uc2Uge1xuICBzdGF0dXNDb2RlOiBudW1iZXI7XG4gIGhlYWRlcnM6IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG4gIGJvZHk/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWNwT0F1dGhFdmVudCB7XG4gIGh0dHBNZXRob2Q6IHN0cmluZztcbiAgcGF0aDogc3RyaW5nO1xuICBoZWFkZXJzOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCB1bmRlZmluZWQ+O1xuICBxdWVyeVN0cmluZ1BhcmFtZXRlcnM6IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IHVuZGVmaW5lZD4gfCBudWxsO1xuICBib2R5OiBzdHJpbmcgfCBudWxsO1xuICBpc0Jhc2U2NEVuY29kZWQ6IGJvb2xlYW47XG59XG5cbi8qKlxuICogSGFuZGxlciBmdW5jdGlvbiBzaWduYXR1cmUgcmV0dXJuZWQgYnkgYWxsIGZhY3Rvcmllcy5cbiAqL1xuZXhwb3J0IHR5cGUgTWNwT0F1dGhIYW5kbGVyID0gKGV2ZW50OiBNY3BPQXV0aEV2ZW50KSA9PiBQcm9taXNlPE1jcE9BdXRoUmVzcG9uc2U+O1xuIl19

package/lib/mcp-auth/handlers/validate-redirect-uris.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default allowlisted redirect URIs for MCP connector registration.
+ * These cover the most common MCP-compatible clients.
+ */
+export declare const DEFAULT_ALLOWED_REDIRECT_URIS: readonly string[];
+/**
+ * Returns true if every URI in the list is on the allowlist.
+ * Uses the provided allowlist or falls back to the default.
+ */
+export declare function validateRedirectUris(uris: string[], allowlist?: readonly string[]): boolean;

package/lib/mcp-auth/handlers/validate-redirect-uris.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ALLOWED_REDIRECT_URIS = void 0;
+exports.validateRedirectUris = validateRedirectUris;
+/**
+ * Default allowlisted redirect URIs for MCP connector registration.
+ * These cover the most common MCP-compatible clients.
+ */
+exports.DEFAULT_ALLOWED_REDIRECT_URIS = [
+    'https://claude.ai/oauth/callback',
+    'https://claude.ai/api/mcp/auth_callback',
+    'https://chatgpt.com/oauth/callback',
+];
+/**
+ * Returns true if every URI in the list is on the allowlist.
+ * Uses the provided allowlist or falls back to the default.
+ */
+function validateRedirectUris(uris, allowlist) {
+    const list = allowlist ?? exports.DEFAULT_ALLOWED_REDIRECT_URIS;
+    return uris.every(uri => list.includes(uri));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtcmVkaXJlY3QtdXJpcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tY3AtYXV0aC9oYW5kbGVycy92YWxpZGF0ZS1yZWRpcmVjdC11cmlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQWNBLG9EQUdDO0FBakJEOzs7R0FHRztBQUNVLFFBQUEsNkJBQTZCLEdBQXNCO0lBQzlELGtDQUFrQztJQUNsQyx5Q0FBeUM7SUFDekMsb0NBQW9DO0NBQ3JDLENBQUM7QUFFRjs7O0dBR0c7QUFDSCxTQUFnQixvQkFBb0IsQ0FBQyxJQUFjLEVBQUUsU0FBNkI7SUFDaEYsTUFBTSxJQUFJLEdBQUcsU0FBUyxJQUFJLHFDQUE2QixDQUFDO0lBQ3hELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUMvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZWZhdWx0IGFsbG93bGlzdGVkIHJlZGlyZWN0IFVSSXMgZm9yIE1DUCBjb25uZWN0b3IgcmVnaXN0cmF0aW9uLlxuICogVGhlc2UgY292ZXIgdGhlIG1vc3QgY29tbW9uIE1DUC1jb21wYXRpYmxlIGNsaWVudHMuXG4gKi9cbmV4cG9ydCBjb25zdCBERUZBVUxUX0FMTE9XRURfUkVESVJFQ1RfVVJJUzogcmVhZG9ubHkgc3RyaW5nW10gPSBbXG4gICdodHRwczovL2NsYXVkZS5haS9vYXV0aC9jYWxsYmFjaycsXG4gICdodHRwczovL2NsYXVkZS5haS9hcGkvbWNwL2F1dGhfY2FsbGJhY2snLFxuICAnaHR0cHM6Ly9jaGF0Z3B0LmNvbS9vYXV0aC9jYWxsYmFjaycsXG5dO1xuXG4vKipcbiAqIFJldHVybnMgdHJ1ZSBpZiBldmVyeSBVUkkgaW4gdGhlIGxpc3QgaXMgb24gdGhlIGFsbG93bGlzdC5cbiAqIFVzZXMgdGhlIHByb3ZpZGVkIGFsbG93bGlzdCBvciBmYWxscyBiYWNrIHRvIHRoZSBkZWZhdWx0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gdmFsaWRhdGVSZWRpcmVjdFVyaXModXJpczogc3RyaW5nW10sIGFsbG93bGlzdD86IHJlYWRvbmx5IHN0cmluZ1tdKTogYm9vbGVhbiB7XG4gIGNvbnN0IGxpc3QgPSBhbGxvd2xpc3QgPz8gREVGQVVMVF9BTExPV0VEX1JFRElSRUNUX1VSSVM7XG4gIHJldHVybiB1cmlzLmV2ZXJ5KHVyaSA9PiBsaXN0LmluY2x1ZGVzKHVyaSkpO1xufVxuIl19

package/lib/mcp-auth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './handlers';
+export * from './mcp';