cdk-serverless 3.2.1 → 3.3.1

package/lib/constructs/mcp-auth.js

@@ -0,0 +1,127 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpAuth = void 0;
+const path = __importStar(require("node:path"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const func_1 = require("./func");
+/**
+ * CDK construct that creates Lambda functions for the MCP OAuth façade.
+ * Service-agnostic — proxies authorize/token requests to any upstream
+ * OAuth2/OIDC provider.
+ *
+ * Use with `RestApi` by passing `mcpAuth` prop, which auto-injects the
+ * required paths into the OpenAPI spec and wires Lambda integrations.
+ *
+ * @example
+ * const mcpAuth = new McpAuth(this, 'McpAuth', {
+ *   apiDomain: 'api.example.com',
+ *   authorizeEndpoint: 'https://auth.example.com/oauth2/authorize',
+ *   tokenEndpoint: 'https://auth.example.com/oauth2/token',
+ *   allowedRedirectUris: ['https://claude.ai/oauth/callback'],
+ *   clientId: 'my-client-id',
+ *   serverInfo: { name: 'my-mcp-server', version: '1.0.0' },
+ *   stageName: 'dev',
+ * });
+ */
+class McpAuth extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const env = {
+            MCP_API_DOMAIN: props.apiDomain,
+            MCP_AUTHORIZE_ENDPOINT: props.authorizeEndpoint,
+            MCP_TOKEN_ENDPOINT: props.tokenEndpoint,
+            MCP_CLIENT_ID: props.clientId,
+            MCP_SERVER_NAME: props.serverInfo.name,
+            MCP_SERVER_VERSION: props.serverInfo.version,
+            MCP_PROTOCOL_VERSIONS: (props.protocolVersions ?? ['2025-11-25', '2025-03-26', '2024-11-05']).join(','),
+            MCP_SCOPES: (props.scopes ?? ['openid', 'email', 'profile']).join(','),
+            MCP_ALLOWED_REDIRECT_URIS: props.allowedRedirectUris.join(','),
+            MCP_STRIP_PARAMETERS: (props.stripParameters ?? ['resource']).join(','),
+            ...props.additionalEnv,
+        };
+        this.mcpEnvVars = env;
+        const handlersDir = path.join(__dirname, '..', 'mcp-auth', 'lambda-handlers');
+        const baseLambdaOptions = {
+            timeout: aws_cdk_lib_1.Duration.seconds(15),
+            ...props.lambdaOptions,
+        };
+        const protectedResource = new func_1.LambdaFunction(this, 'ProtectedResourceFn', {
+            stageName: props.stageName,
+            entry: path.join(handlersDir, 'protected-resource.handler.js'),
+            description: `[${props.stageName}] MCP OAuth Protected Resource`,
+            additionalEnv: env,
+            lambdaOptions: baseLambdaOptions,
+        });
+        const authorizationServer = new func_1.LambdaFunction(this, 'AuthorizationServerFn', {
+            stageName: props.stageName,
+            entry: path.join(handlersDir, 'authorization-server.handler.js'),
+            description: `[${props.stageName}] MCP OAuth Authorization Server`,
+            additionalEnv: env,
+            lambdaOptions: baseLambdaOptions,
+        });
+        const authorize = new func_1.LambdaFunction(this, 'AuthorizeFn', {
+            stageName: props.stageName,
+            entry: path.join(handlersDir, 'authorize.handler.js'),
+            description: `[${props.stageName}] MCP OAuth Authorize Proxy`,
+            additionalEnv: env,
+            lambdaOptions: baseLambdaOptions,
+        });
+        const token = new func_1.LambdaFunction(this, 'TokenFn', {
+            stageName: props.stageName,
+            entry: path.join(handlersDir, 'token.handler.js'),
+            description: `[${props.stageName}] MCP OAuth Token Proxy`,
+            additionalEnv: env,
+            lambdaOptions: baseLambdaOptions,
+        });
+        const register = new func_1.LambdaFunction(this, 'RegisterFn', {
+            stageName: props.stageName,
+            entry: path.join(handlersDir, 'register.handler.js'),
+            description: `[${props.stageName}] MCP OAuth Register`,
+            additionalEnv: env,
+            lambdaOptions: baseLambdaOptions,
+        });
+        this.functions = {
+            protectedResource,
+            authorizationServer,
+            authorize,
+            token,
+            register,
+        };
+    }
+}
+exports.McpAuth = McpAuth;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-auth.js","sourceRoot":"","sources":["../../src/constructs/mcp-auth.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport { Duration } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { LambdaFunction, LambdaOptions } from './func';\n\n/**\n * Configuration for the MCP Auth CDK construct.\n * Service-agnostic: works with any OAuth2/OIDC provider.\n */\nexport interface McpAuthProps {\n  /**\n   * The API domain that acts as the MCP OAuth issuer.\n   * All OAuth discovery endpoints will reference this domain.\n   * Example: 'api.example.com'\n   */\n  readonly apiDomain: string;\n\n  /**\n   * The upstream OAuth authorize endpoint URL.\n   * The authorize Lambda proxies (302 redirects) to this URL.\n   * Example: 'https://auth.example.com/oauth2/authorize'\n   */\n  readonly authorizeEndpoint: string;\n\n  /**\n   * The upstream OAuth token endpoint URL.\n   * The token Lambda proxies POST requests to this URL.\n   * Example: 'https://auth.example.com/oauth2/token'\n   */\n  readonly tokenEndpoint: string;\n\n  /**\n   * Allowed redirect URIs for dynamic client registration.\n   * Clients registering with URIs not in this list are rejected.\n   */\n  readonly allowedRedirectUris: string[];\n\n  /**\n   * The pre-provisioned OAuth client ID returned by the register endpoint.\n   */\n  readonly clientId: string;\n\n  /**\n   * MCP server info returned in the 'initialize' response.\n   */\n  readonly serverInfo: { readonly name: string; readonly version: string };\n\n  /**\n   * Supported MCP protocol versions (newest first).\n   * @default ['2025-11-25', '2025-03-26', '2024-11-05']\n   */\n  readonly protocolVersions?: string[];\n\n  /**\n   * OAuth scopes to advertise in discovery metadata.\n   * @default ['openid', 'email', 'profile']\n   */\n  readonly scopes?: string[];\n\n  /**\n   * Parameters to strip from authorize/token proxy requests.\n   * @default ['resource']\n   */\n  readonly stripParameters?: string[];\n\n  /**\n   * Additional environment variables to inject into all MCP auth Lambda functions.\n   */\n  readonly additionalEnv?: Record<string, string>;\n\n  /**\n   * Lambda function options for MCP auth handlers.\n   */\n  readonly lambdaOptions?: LambdaOptions;\n\n  /**\n   * Stage name for function naming and tagging.\n   */\n  readonly stageName: string;\n}\n\n/**\n * Provides the Lambda function references for MCP OAuth endpoints.\n * These can be wired into API Gateway (via RestApi integration)\n * or used standalone.\n */\nexport interface McpAuthFunctions {\n  /** GET /.well-known/oauth-protected-resource */\n  readonly protectedResource: LambdaFunction;\n  /** GET /.well-known/oauth-authorization-server */\n  readonly authorizationServer: LambdaFunction;\n  /** GET /oauth/authorize */\n  readonly authorize: LambdaFunction;\n  /** POST /oauth/token */\n  readonly token: LambdaFunction;\n  /** POST /oauth/register */\n  readonly register: LambdaFunction;\n}\n\n/**\n * CDK construct that creates Lambda functions for the MCP OAuth façade.\n * Service-agnostic — proxies authorize/token requests to any upstream\n * OAuth2/OIDC provider.\n *\n * Use with `RestApi` by passing `mcpAuth` prop, which auto-injects the\n * required paths into the OpenAPI spec and wires Lambda integrations.\n *\n * @example\n * const mcpAuth = new McpAuth(this, 'McpAuth', {\n *   apiDomain: 'api.example.com',\n *   authorizeEndpoint: 'https://auth.example.com/oauth2/authorize',\n *   tokenEndpoint: 'https://auth.example.com/oauth2/token',\n *   allowedRedirectUris: ['https://claude.ai/oauth/callback'],\n *   clientId: 'my-client-id',\n *   serverInfo: { name: 'my-mcp-server', version: '1.0.0' },\n *   stageName: 'dev',\n * });\n */\nexport class McpAuth extends Construct {\n\n  /**\n   * The Lambda functions created for the OAuth endpoints.\n   */\n  public readonly functions: McpAuthFunctions;\n\n  /**\n   * The environment variables map that should be injected into the MCP RPC\n   * handler Lambda (if you have one) so it can read MCP config at runtime.\n   */\n  public readonly mcpEnvVars: Record<string, string>;\n\n  constructor(scope: Construct, id: string, props: McpAuthProps) {\n    super(scope, id);\n\n    const env: Record<string, string> = {\n      MCP_API_DOMAIN: props.apiDomain,\n      MCP_AUTHORIZE_ENDPOINT: props.authorizeEndpoint,\n      MCP_TOKEN_ENDPOINT: props.tokenEndpoint,\n      MCP_CLIENT_ID: props.clientId,\n      MCP_SERVER_NAME: props.serverInfo.name,\n      MCP_SERVER_VERSION: props.serverInfo.version,\n      MCP_PROTOCOL_VERSIONS: (props.protocolVersions ?? ['2025-11-25', '2025-03-26', '2024-11-05']).join(','),\n      MCP_SCOPES: (props.scopes ?? ['openid', 'email', 'profile']).join(','),\n      MCP_ALLOWED_REDIRECT_URIS: props.allowedRedirectUris.join(','),\n      MCP_STRIP_PARAMETERS: (props.stripParameters ?? ['resource']).join(','),\n      ...props.additionalEnv,\n    };\n\n    this.mcpEnvVars = env;\n\n    const handlersDir = path.join(__dirname, '..', 'mcp-auth', 'lambda-handlers');\n\n    const baseLambdaOptions: LambdaOptions = {\n      timeout: Duration.seconds(15),\n      ...props.lambdaOptions,\n    };\n\n    const protectedResource = new LambdaFunction(this, 'ProtectedResourceFn', {\n      stageName: props.stageName,\n      entry: path.join(handlersDir, 'protected-resource.handler.js'),\n      description: `[${props.stageName}] MCP OAuth Protected Resource`,\n      additionalEnv: env,\n      lambdaOptions: baseLambdaOptions,\n    });\n\n    const authorizationServer = new LambdaFunction(this, 'AuthorizationServerFn', {\n      stageName: props.stageName,\n      entry: path.join(handlersDir, 'authorization-server.handler.js'),\n      description: `[${props.stageName}] MCP OAuth Authorization Server`,\n      additionalEnv: env,\n      lambdaOptions: baseLambdaOptions,\n    });\n\n    const authorize = new LambdaFunction(this, 'AuthorizeFn', {\n      stageName: props.stageName,\n      entry: path.join(handlersDir, 'authorize.handler.js'),\n      description: `[${props.stageName}] MCP OAuth Authorize Proxy`,\n      additionalEnv: env,\n      lambdaOptions: baseLambdaOptions,\n    });\n\n    const token = new LambdaFunction(this, 'TokenFn', {\n      stageName: props.stageName,\n      entry: path.join(handlersDir, 'token.handler.js'),\n      description: `[${props.stageName}] MCP OAuth Token Proxy`,\n      additionalEnv: env,\n      lambdaOptions: baseLambdaOptions,\n    });\n\n    const register = new LambdaFunction(this, 'RegisterFn', {\n      stageName: props.stageName,\n      entry: path.join(handlersDir, 'register.handler.js'),\n      description: `[${props.stageName}] MCP OAuth Register`,\n      additionalEnv: env,\n      lambdaOptions: baseLambdaOptions,\n    });\n\n    this.functions = {\n      protectedResource,\n      authorizationServer,\n      authorize,\n      token,\n      register,\n    };\n  }\n}\n"]}

package/lib/constructs/mcp-cognito-auth.d.ts

@@ -0,0 +1,110 @@
+import { aws_cognito } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { CognitoAuthentication } from './authentication';
+import { LambdaOptions } from './func';
+import { McpAuth } from './mcp-auth';
+/**
+ * Props for creating an McpAuth backed by a Cognito User Pool.
+ * This is a convenience wrapper — use McpAuth directly for non-Cognito providers.
+ */
+export interface McpCognitoAuthProps {
+    /**
+     * The CognitoAuthentication construct that manages the user pool.
+     * A dedicated user pool client will be created for MCP connectors.
+     */
+    readonly auth: CognitoAuthentication;
+    /**
+     * The API domain that acts as the MCP OAuth issuer.
+     * All discovery endpoints will reference this domain.
+     * Example: 'api.example.com'
+     */
+    readonly apiDomain: string;
+    /**
+     * The Cognito auth domain (custom domain or Cognito-hosted domain).
+     * Authorize and token requests are proxied here.
+     * Example: 'auth.example.com' or 'myapp.auth.eu-central-1.amazoncognito.com'
+     */
+    readonly authDomain: string;
+    /**
+     * Allowed redirect URIs for dynamic client registration.
+     * @default ['https://claude.ai/oauth/callback', 'https://claude.ai/api/mcp/auth_callback', 'https://chatgpt.com/oauth/callback']
+     */
+    readonly allowedRedirectUris?: string[];
+    /**
+     * MCP server info returned in the 'initialize' response.
+     */
+    readonly serverInfo: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /**
+     * Supported MCP protocol versions (newest first).
+     * @default ['2025-11-25', '2025-03-26', '2024-11-05']
+     */
+    readonly protocolVersions?: string[];
+    /**
+     * OAuth scopes to advertise in discovery metadata.
+     * Note: Do NOT include custom resource server scopes here —
+     * Cognito Managed Login v2 requires RFC 8707 resource parameter
+     * for custom scopes which MCP clients cannot supply.
+     * @default ['openid', 'email', 'profile']
+     */
+    readonly scopes?: string[];
+    /**
+     * Additional environment variables for MCP auth Lambda functions.
+     */
+    readonly additionalEnv?: Record<string, string>;
+    /**
+     * Lambda function options for MCP auth handlers.
+     */
+    readonly lambdaOptions?: LambdaOptions;
+    /**
+     * Stage name for function naming and tagging.
+     */
+    readonly stageName: string;
+    /**
+     * Construct ID for the user pool client (affects CloudFormation logical ID).
+     * @default 'mcpConnector'
+     */
+    readonly clientConstructId?: string;
+    /**
+     * Additional OAuth callback URLs to configure on the Cognito client
+     * beyond the allowedRedirectUris. Useful if the Cognito client needs
+     * URLs that aren't in the MCP registration allowlist.
+     */
+    readonly additionalCallbackUrls?: string[];
+}
+/**
+ * Convenience construct that creates an McpAuth backed by Amazon Cognito.
+ *
+ * It creates a dedicated Cognito user pool client configured for the
+ * authorization code + PKCE flow and wires it into the generic McpAuth
+ * construct. Use this when your authentication is managed by Cognito;
+ * use McpAuth directly for other OAuth2/OIDC providers.
+ *
+ * @example
+ * const mcpAuth = new McpCognitoAuth(this, 'McpAuth', {
+ *   auth: cognitoAuthentication,
+ *   apiDomain: 'api.example.com',
+ *   authDomain: 'auth.example.com',
+ *   serverInfo: { name: 'my-mcp-server', version: '1.0.0' },
+ *   stageName: 'dev',
+ * });
+ *
+ * const api = new MyApiRestApi(this, 'Api', {
+ *   mcpAuth: mcpAuth.mcpAuth,
+ *   // ...
+ * });
+ */
+export declare class McpCognitoAuth extends Construct {
+    /**
+     * The underlying service-agnostic McpAuth construct.
+     * Pass this to RestApi's `mcpAuth` prop.
+     */
+    readonly mcpAuth: McpAuth;
+    /**
+     * The Cognito user pool client created for MCP connectors.
+     */
+    readonly userPoolClient: aws_cognito.UserPoolClient;
+    constructor(scope: Construct, id: string, props: McpCognitoAuthProps);
+}

package/lib/constructs/mcp-cognito-auth.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpCognitoAuth = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const mcp_auth_1 = require("./mcp-auth");
+/**
+ * Convenience construct that creates an McpAuth backed by Amazon Cognito.
+ *
+ * It creates a dedicated Cognito user pool client configured for the
+ * authorization code + PKCE flow and wires it into the generic McpAuth
+ * construct. Use this when your authentication is managed by Cognito;
+ * use McpAuth directly for other OAuth2/OIDC providers.
+ *
+ * @example
+ * const mcpAuth = new McpCognitoAuth(this, 'McpAuth', {
+ *   auth: cognitoAuthentication,
+ *   apiDomain: 'api.example.com',
+ *   authDomain: 'auth.example.com',
+ *   serverInfo: { name: 'my-mcp-server', version: '1.0.0' },
+ *   stageName: 'dev',
+ * });
+ *
+ * const api = new MyApiRestApi(this, 'Api', {
+ *   mcpAuth: mcpAuth.mcpAuth,
+ *   // ...
+ * });
+ */
+class McpCognitoAuth extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const clientId = props.clientConstructId ?? 'mcpConnector';
+        const allowedRedirectUris = props.allowedRedirectUris ?? [
+            'https://claude.ai/oauth/callback',
+            'https://claude.ai/api/mcp/auth_callback',
+            'https://chatgpt.com/oauth/callback',
+        ];
+        // Create a Cognito user pool client with auth code grant + PKCE
+        this.userPoolClient = props.auth.addUserPoolClient(clientId, {
+            generateSecret: false,
+            oAuth: {
+                flows: {
+                    authorizationCodeGrant: true,
+                },
+                scopes: [
+                    aws_cdk_lib_1.aws_cognito.OAuthScope.OPENID,
+                    aws_cdk_lib_1.aws_cognito.OAuthScope.EMAIL,
+                    aws_cdk_lib_1.aws_cognito.OAuthScope.PROFILE,
+                ],
+                callbackUrls: [
+                    ...allowedRedirectUris,
+                    ...(props.additionalCallbackUrls ?? []),
+                ],
+            },
+            authFlows: {
+                userSrp: true,
+            },
+        });
+        // Create the generic McpAuth, deriving endpoints from authDomain
+        this.mcpAuth = new mcp_auth_1.McpAuth(this, 'McpAuth', {
+            apiDomain: props.apiDomain,
+            authorizeEndpoint: `https://${props.authDomain}/oauth2/authorize`,
+            tokenEndpoint: `https://${props.authDomain}/oauth2/token`,
+            allowedRedirectUris,
+            clientId: this.userPoolClient.userPoolClientId,
+            serverInfo: props.serverInfo,
+            protocolVersions: props.protocolVersions,
+            scopes: props.scopes,
+            additionalEnv: props.additionalEnv,
+            lambdaOptions: props.lambdaOptions,
+            stageName: props.stageName,
+        });
+    }
+}
+exports.McpCognitoAuth = McpCognitoAuth;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-cognito-auth.js","sourceRoot":"","sources":["../../src/constructs/mcp-cognito-auth.ts"],"names":[],"mappings":";;;AAAA,6CAA0C;AAC1C,2CAAuC;AAGvC,yCAAqC;AAkFrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,cAAe,SAAQ,sBAAS;IAa3C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA0B;QAClE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,QAAQ,GAAG,KAAK,CAAC,iBAAiB,IAAI,cAAc,CAAC;QAE3D,MAAM,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,IAAI;YACvD,kCAAkC;YAClC,yCAAyC;YACzC,oCAAoC;SACrC,CAAC;QAEF,gEAAgE;QAChE,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE;YAC3D,cAAc,EAAE,KAAK;YACrB,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL,sBAAsB,EAAE,IAAI;iBAC7B;gBACD,MAAM,EAAE;oBACN,yBAAW,CAAC,UAAU,CAAC,MAAM;oBAC7B,yBAAW,CAAC,UAAU,CAAC,KAAK;oBAC5B,yBAAW,CAAC,UAAU,CAAC,OAAO;iBAC/B;gBACD,YAAY,EAAE;oBACZ,GAAG,mBAAmB;oBACtB,GAAG,CAAC,KAAK,CAAC,sBAAsB,IAAI,EAAE,CAAC;iBACxC;aACF;YACD,SAAS,EAAE;gBACT,OAAO,EAAE,IAAI;aACd;SACF,CAAC,CAAC;QAEH,iEAAiE;QACjE,IAAI,CAAC,OAAO,GAAG,IAAI,kBAAO,CAAC,IAAI,EAAE,SAAS,EAAE;YAC1C,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,iBAAiB,EAAE,WAAW,KAAK,CAAC,UAAU,mBAAmB;YACjE,aAAa,EAAE,WAAW,KAAK,CAAC,UAAU,eAAe;YACzD,mBAAmB;YACnB,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,gBAAgB;YAC9C,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAC,CAAC;IACL,CAAC;CACF;AA7DD,wCA6DC","sourcesContent":["import { aws_cognito } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CognitoAuthentication } from './authentication';\nimport { LambdaOptions } from './func';\nimport { McpAuth } from './mcp-auth';\n\n/**\n * Props for creating an McpAuth backed by a Cognito User Pool.\n * This is a convenience wrapper — use McpAuth directly for non-Cognito providers.\n */\nexport interface McpCognitoAuthProps {\n  /**\n   * The CognitoAuthentication construct that manages the user pool.\n   * A dedicated user pool client will be created for MCP connectors.\n   */\n  readonly auth: CognitoAuthentication;\n\n  /**\n   * The API domain that acts as the MCP OAuth issuer.\n   * All discovery endpoints will reference this domain.\n   * Example: 'api.example.com'\n   */\n  readonly apiDomain: string;\n\n  /**\n   * The Cognito auth domain (custom domain or Cognito-hosted domain).\n   * Authorize and token requests are proxied here.\n   * Example: 'auth.example.com' or 'myapp.auth.eu-central-1.amazoncognito.com'\n   */\n  readonly authDomain: string;\n\n  /**\n   * Allowed redirect URIs for dynamic client registration.\n   * @default ['https://claude.ai/oauth/callback', 'https://claude.ai/api/mcp/auth_callback', 'https://chatgpt.com/oauth/callback']\n   */\n  readonly allowedRedirectUris?: string[];\n\n  /**\n   * MCP server info returned in the 'initialize' response.\n   */\n  readonly serverInfo: { readonly name: string; readonly version: string };\n\n  /**\n   * Supported MCP protocol versions (newest first).\n   * @default ['2025-11-25', '2025-03-26', '2024-11-05']\n   */\n  readonly protocolVersions?: string[];\n\n  /**\n   * OAuth scopes to advertise in discovery metadata.\n   * Note: Do NOT include custom resource server scopes here —\n   * Cognito Managed Login v2 requires RFC 8707 resource parameter\n   * for custom scopes which MCP clients cannot supply.\n   * @default ['openid', 'email', 'profile']\n   */\n  readonly scopes?: string[];\n\n  /**\n   * Additional environment variables for MCP auth Lambda functions.\n   */\n  readonly additionalEnv?: Record<string, string>;\n\n  /**\n   * Lambda function options for MCP auth handlers.\n   */\n  readonly lambdaOptions?: LambdaOptions;\n\n  /**\n   * Stage name for function naming and tagging.\n   */\n  readonly stageName: string;\n\n  /**\n   * Construct ID for the user pool client (affects CloudFormation logical ID).\n   * @default 'mcpConnector'\n   */\n  readonly clientConstructId?: string;\n\n  /**\n   * Additional OAuth callback URLs to configure on the Cognito client\n   * beyond the allowedRedirectUris. Useful if the Cognito client needs\n   * URLs that aren't in the MCP registration allowlist.\n   */\n  readonly additionalCallbackUrls?: string[];\n}\n\n/**\n * Convenience construct that creates an McpAuth backed by Amazon Cognito.\n *\n * It creates a dedicated Cognito user pool client configured for the\n * authorization code + PKCE flow and wires it into the generic McpAuth\n * construct. Use this when your authentication is managed by Cognito;\n * use McpAuth directly for other OAuth2/OIDC providers.\n *\n * @example\n * const mcpAuth = new McpCognitoAuth(this, 'McpAuth', {\n *   auth: cognitoAuthentication,\n *   apiDomain: 'api.example.com',\n *   authDomain: 'auth.example.com',\n *   serverInfo: { name: 'my-mcp-server', version: '1.0.0' },\n *   stageName: 'dev',\n * });\n *\n * const api = new MyApiRestApi(this, 'Api', {\n *   mcpAuth: mcpAuth.mcpAuth,\n *   // ...\n * });\n */\nexport class McpCognitoAuth extends Construct {\n\n  /**\n   * The underlying service-agnostic McpAuth construct.\n   * Pass this to RestApi's `mcpAuth` prop.\n   */\n  public readonly mcpAuth: McpAuth;\n\n  /**\n   * The Cognito user pool client created for MCP connectors.\n   */\n  public readonly userPoolClient: aws_cognito.UserPoolClient;\n\n  constructor(scope: Construct, id: string, props: McpCognitoAuthProps) {\n    super(scope, id);\n\n    const clientId = props.clientConstructId ?? 'mcpConnector';\n\n    const allowedRedirectUris = props.allowedRedirectUris ?? [\n      'https://claude.ai/oauth/callback',\n      'https://claude.ai/api/mcp/auth_callback',\n      'https://chatgpt.com/oauth/callback',\n    ];\n\n    // Create a Cognito user pool client with auth code grant + PKCE\n    this.userPoolClient = props.auth.addUserPoolClient(clientId, {\n      generateSecret: false,\n      oAuth: {\n        flows: {\n          authorizationCodeGrant: true,\n        },\n        scopes: [\n          aws_cognito.OAuthScope.OPENID,\n          aws_cognito.OAuthScope.EMAIL,\n          aws_cognito.OAuthScope.PROFILE,\n        ],\n        callbackUrls: [\n          ...allowedRedirectUris,\n          ...(props.additionalCallbackUrls ?? []),\n        ],\n      },\n      authFlows: {\n        userSrp: true,\n      },\n    });\n\n    // Create the generic McpAuth, deriving endpoints from authDomain\n    this.mcpAuth = new McpAuth(this, 'McpAuth', {\n      apiDomain: props.apiDomain,\n      authorizeEndpoint: `https://${props.authDomain}/oauth2/authorize`,\n      tokenEndpoint: `https://${props.authDomain}/oauth2/token`,\n      allowedRedirectUris,\n      clientId: this.userPoolClient.userPoolClientId,\n      serverInfo: props.serverInfo,\n      protocolVersions: props.protocolVersions,\n      scopes: props.scopes,\n      additionalEnv: props.additionalEnv,\n      lambdaOptions: props.lambdaOptions,\n      stageName: props.stageName,\n    });\n  }\n}\n"]}

package/lib/constructs/rest-api.d.ts

@@ -1,8 +1,103 @@
 import { aws_apigateway } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { OpenAPI3, OperationObject } from 'openapi-typescript';
+import { CognitoAuthentication } from './authentication';
 import { BaseApi, BaseApiProps } from './base-api';
 import { LambdaFunction, LambdaOptions } from './func';
+import { McpAuth } from './mcp-auth';
+/**
+ * Cognito-specific MCP auth configuration.
+ * Creates a dedicated user pool client for MCP connectors automatically.
+ */
+export interface McpAuthCognitoOptions {
+    /**
+     * The CognitoAuthentication construct managing the user pool.
+     * A dedicated client with auth code + PKCE will be created.
+     */
+    readonly auth: CognitoAuthentication;
+    /**
+     * The Cognito auth domain (custom or Cognito-hosted).
+     * Required — never inferred from apiDomain.
+     * Example: 'auth.example.com'
+     */
+    readonly authDomain: string;
+    /**
+     * Construct ID for the user pool client (affects CloudFormation logical ID).
+     * @default 'mcpConnector'
+     */
+    readonly clientConstructId?: string;
+    /**
+     * Additional OAuth callback URLs for the Cognito client beyond the allowedRedirectUris.
+     */
+    readonly additionalCallbackUrls?: string[];
+}
+/**
+ * Generic (non-Cognito) MCP auth configuration.
+ * Requires explicit authorize and token endpoint URLs.
+ */
+export interface McpAuthGenericOptions {
+    /**
+     * The upstream OAuth authorize endpoint URL.
+     * Example: 'https://auth.example.com/oauth2/authorize'
+     */
+    readonly authorizeEndpoint: string;
+    /**
+     * The upstream OAuth token endpoint URL.
+     * Example: 'https://auth.example.com/oauth2/token'
+     */
+    readonly tokenEndpoint: string;
+    /**
+     * The pre-provisioned OAuth client ID returned by the register endpoint.
+     */
+    readonly clientId: string;
+}
+/**
+ * MCP auth configuration for the RestApi.
+ * Provide either `cognito` (for Cognito-backed auth) or `generic` (for any OAuth2 provider).
+ */
+export interface McpAuthOptions {
+    /**
+     * Cognito-specific configuration. Mutually exclusive with `generic`.
+     * Creates a user pool client and derives endpoints automatically.
+     */
+    readonly cognito?: McpAuthCognitoOptions;
+    /**
+     * Generic OAuth2 provider configuration. Mutually exclusive with `cognito`.
+     * Requires explicit endpoint URLs and client ID.
+     */
+    readonly generic?: McpAuthGenericOptions;
+    /**
+     * MCP server info returned in the 'initialize' response.
+     */
+    readonly serverInfo: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /**
+     * Allowed redirect URIs for dynamic client registration.
+     * @default ['https://claude.ai/oauth/callback', 'https://claude.ai/api/mcp/auth_callback', 'https://chatgpt.com/oauth/callback']
+     */
+    readonly allowedRedirectUris?: string[];
+    /**
+     * Supported MCP protocol versions (newest first).
+     * @default ['2025-11-25', '2025-03-26', '2024-11-05']
+     */
+    readonly protocolVersions?: string[];
+    /**
+     * OAuth scopes to advertise in discovery metadata.
+     * @default ['openid', 'email', 'profile']
+     */
+    readonly scopes?: string[];
+    /**
+     * Parameters to strip from authorize/token proxy requests.
+     * @default ['resource']
+     */
+    readonly stripParameters?: string[];
+    /**
+     * Lambda function options for MCP auth handlers.
+     */
+    readonly lambdaOptions?: LambdaOptions;
+}
 export interface RestApiProps<OPS> extends BaseApiProps {
     /**
      * Generate routes for all endpoints configured in the openapi.yaml file
@@ -56,6 +151,26 @@ export interface RestApiProps<OPS> extends BaseApiProps {
      * @default 'token'
      */
     jwtAuthorizerType?: 'token' | 'request';
+    /**
+     * MCP Auth configuration to wire into this API.
+     * When provided, the following paths are automatically added to the OpenAPI spec
+     * with Lambda proxy integrations:
+     *
+     * - GET  /.well-known/oauth-protected-resource
+     * - GET  /.well-known/oauth-authorization-server
+     * - GET  /oauth/authorize
+     * - POST /oauth/token
+     * - POST /oauth/register
+     *
+     * All MCP auth endpoints are anonymous (no authorizer).
+     * The API domain is derived from the RestApi's own domain configuration.
+     *
+     * Provide either `cognito` (creates a Cognito client automatically) or
+     * `generic` (for any OAuth2 provider with explicit endpoint URLs).
+     *
+     * @default - no MCP auth
+     */
+    mcpAuth?: McpAuthOptions;
     /**
      * Global OAuth2 scopes required by the Cognito authorizer.
      *
@@ -135,6 +250,11 @@ export declare class RestApi<PATHS, OPS> extends BaseApi {
      * @private
      */
     private _authorizerFn?;
+    /**
+     * The MCP auth construct, if mcpAuth options were provided.
+     * @private
+     */
+    private _mcpAuth?;
     /**
      * Set of operationIds that should have security disabled (security: []).
      * @private
@@ -222,6 +342,22 @@ export declare class RestApi<PATHS, OPS> extends BaseApi {
      * For JWT: creates a Lambda authorizer function and adds a token authorizer referencing its ARN.
      */
     protected patchSecuritySchemes(spec: OpenAPI3): void;
+    /**
+     * Returns the MCP auth construct if mcpAuth was configured.
+     * Useful for accessing the created Lambda functions or env vars.
+     */
+    getMcpAuth(): McpAuth | undefined;
+    /**
+     * Creates the McpAuth construct from the provided options.
+     * Derives apiDomain from the RestApi's own domain config.
+     * For Cognito, creates a user pool client automatically.
+     */
+    private createMcpAuth;
+    /**
+     * Injects MCP OAuth paths into the OpenAPI spec with Lambda proxy integrations
+     * pointing to the MCP auth construct's functions. All paths are anonymous (security: []).
+     */
+    private injectMcpAuthPaths;
     /**
      * Returns the security-scheme container for the spec, creating it if needed.
      * OpenAPI 3.x stores schemes under `components.securitySchemes`; Swagger 2.0