cdk-local-lambda 0.0.2

package/lib/aspect/live-lambda-aspect.js

@@ -0,0 +1,277 @@
+/**
+ * CDK Aspect to transform Lambda functions for live debugging
+ *
+ * When applied to a CDK app/stack, this aspect:
+ * 1. Replaces Lambda code with the bridge handler from the bootstrap stack's S3 bucket
+ * 2. Grants IAM permissions for AppSync Events
+ * 3. Adds a tag with the local handler path for the daemon to discover
+ *
+ * The bridge uses AWS_LAMBDA_FUNCTION_NAME (auto-injected by Lambda) for channel routing.
+ * The daemon discovers functions by querying Lambda API for functions with the live-lambda tag.
+ */
+import * as cdk from "aws-cdk-lib";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as ssm from "aws-cdk-lib/aws-ssm";
+import { LIVE_LAMBDA_DOCKER_TAG, LIVE_LAMBDA_TAG, SSM_BASE_PATH, } from "../shared/types.js";
+import { getDockerContextPath, isDockerImageFunction, } from "./docker-function-hook.js";
+import { getEntryPath, getHandlerName } from "./nodejs-function-hook.js";
+// Regex to strip file extension from entry path
+const EXTENSION_REGEX = /\.(ts|js|mjs|cjs|mts|cts)$/;
+/**
+ * CDK Aspect that transforms Lambda functions for live debugging.
+ *
+ * Usage in bin/app.ts:
+ * ```typescript
+ * const app = new cdk.App();
+ * const stack = new MyStack(app, 'MyStack');
+ *
+ * if (process.env.CDK_LIVE === 'true') {
+ *   cdk.Aspects.of(app).add(new LiveLambdaAspect());
+ * }
+ * ```
+ */
+export class LiveLambdaAspect {
+    props;
+    processedFunctions = new Set();
+    constructor(props = {}) {
+        this.props = props;
+    }
+    visit(node) {
+        // Check if this is a Lambda Function using duck-typing instead of instanceof
+        // This avoids issues with multiple copies of aws-cdk-lib being loaded
+        if (!this.isLambdaFunction(node)) {
+            return;
+        }
+        // Cast to lambda.Function for type checking (we've verified it's a Lambda)
+        const fn = node;
+        // Skip if already processed (aspects can visit multiple times)
+        const nodeId = node.node.addr;
+        if (this.processedFunctions.has(nodeId)) {
+            return;
+        }
+        // Generate a unique function ID from the construct path
+        const functionId = this.generateFunctionId(fn);
+        // Check exclusion list
+        if (this.props.excludeFunctions?.includes(functionId)) {
+            console.log(`[LiveLambda] Skipping excluded function: ${functionId}`);
+            return;
+        }
+        // Check pattern match
+        if (this.props.functionPattern &&
+            !this.props.functionPattern.test(functionId)) {
+            console.log(`[LiveLambda] Skipping non-matching function: ${functionId}`);
+            return;
+        }
+        console.log(`[LiveLambda] Transforming function: ${functionId}`);
+        const stackName = this.props.stackName || cdk.Stack.of(fn).stackName;
+        // Check if this is a DockerImageFunction
+        const isDockerFunction = isDockerImageFunction(fn);
+        if (isDockerFunction) {
+            console.log(`[LiveLambda] Detected DockerImageFunction: ${functionId}`);
+            this.transformDockerFunction(fn, stackName, functionId);
+        }
+        else {
+            // Get handler paths before we modify anything
+            const handlerPaths = this.getHandlerPaths(fn);
+            // Skip unsupported functions (not NodejsFunction or DockerImageFunction)
+            if (!handlerPaths) {
+                return;
+            }
+            const { originalHandler, localHandler } = handlerPaths;
+            // Transform the function
+            this.transformFunction(fn, stackName, functionId, originalHandler, localHandler);
+        }
+        this.processedFunctions.add(nodeId);
+    }
+    /**
+     * Check if a construct is a Lambda Function using duck-typing.
+     * This avoids instanceof issues when multiple copies of aws-cdk-lib are loaded.
+     */
+    isLambdaFunction(node) {
+        // Check by constructor name - handles Function, DockerImageFunction, NodejsFunction, etc.
+        // Also handles our patched versions like DockerImageFunctionWithCapture
+        const constructorName = node.constructor.name;
+        // CDK appends "2" to class names in some versions
+        const isFunction = constructorName === "Function" ||
+            constructorName === "Function2" ||
+            constructorName.endsWith("Function") ||
+            constructorName.endsWith("Function2") ||
+            constructorName.includes("Function"); // Catch patched versions like DockerImageFunctionWithCapture
+        if (!isFunction) {
+            return false;
+        }
+        // Exclude CfnFunction (the L1 construct)
+        if (constructorName === "CfnFunction") {
+            return false;
+        }
+        // Verify it has expected Lambda Function properties
+        const maybeFunction = node;
+        // Must have functionName and functionArn (IFunction interface)
+        if (!maybeFunction.functionName || !maybeFunction.functionArn) {
+            return false;
+        }
+        // Must have a defaultChild (the CfnFunction)
+        if (!maybeFunction.node?.defaultChild) {
+            return false;
+        }
+        return true;
+    }
+    generateFunctionId(fn) {
+        // Use the construct ID as the function ID
+        // For nested constructs, join with dashes
+        const parts = fn.node.path.split("/");
+        // Skip first part (App) and take the rest
+        const relevantParts = parts.slice(1);
+        return relevantParts.join("-").replace(/[^a-zA-Z0-9-]/g, "-");
+    }
+    /**
+     * Get handler paths for a function.
+     * Returns both the original handler (as set in CfnFunction) and the local handler path.
+     * Returns null if the function is not supported (e.g., not a NodejsFunction).
+     */
+    getHandlerPaths(fn) {
+        const cfnFunction = fn.node.defaultChild;
+        const originalHandler = cfnFunction.handler || "index.handler";
+        const constructId = fn.node.id;
+        // Check if captured by the NodejsFunction hook
+        const entryPath = getEntryPath(fn);
+        const handlerName = getHandlerName(fn) || "handler";
+        if (entryPath) {
+            // Convert entry path to local handler path
+            // e.g., "functions/s3-writer/handler.ts" + "handler" -> "functions/s3-writer/handler.handler"
+            const localHandler = `${entryPath.replace(EXTENSION_REGEX, "")}.${handlerName}`;
+            console.log(`[LiveLambda] Using captured entry for ${constructId}: ${localHandler}`);
+            return { originalHandler, localHandler };
+        }
+        // No handler path found - this function is not supported (not a NodejsFunction or DockerImageFunction)
+        console.log(`[LiveLambda] Skipping unsupported function "${constructId}": ` +
+            `not a NodejsFunction or DockerImageFunction (or bootstrap hook was not installed early enough)`);
+        return null;
+    }
+    /**
+     * Transform a DockerImageFunction to use the bridge Docker image.
+     * Stores the local Docker context path in a tag for the daemon to build/run locally.
+     */
+    transformDockerFunction(fn, _stackName, functionId) {
+        const cfnFunction = fn.node.defaultChild;
+        const stack = cdk.Stack.of(fn);
+        // Get the docker context path from the hook
+        const dockerContextPath = getDockerContextPath(fn);
+        if (!dockerContextPath) {
+            throw new Error(`[LiveLambda] No docker context path for "${functionId}". ` +
+                `The bootstrap hook was not installed early enough. ` +
+                `Fix: import "cdk-local-lambda/bootstrap" before any CDK imports (Node.js), ` +
+                `or run Bun with "bun --preload cdk-local-lambda/bootstrap".`);
+        }
+        // Get SSM parameters
+        const bootstrapQualifier = stack.node.tryGetContext("@aws-cdk/core:bootstrapQualifier") ||
+            "hnb659fds";
+        const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`;
+        const apiArn = ssm.StringParameter.valueForStringParameter(stack, `${ssmBasePath}/api-arn`);
+        // Determine architecture and get appropriate bridge image
+        const architecture = this.getArchitecture(cfnFunction);
+        const bridgeImageParam = architecture === "arm64" ? "bridge-image-arm64" : "bridge-image-x86_64";
+        const bridgeImageUri = ssm.StringParameter.valueForStringParameter(stack, `${ssmBasePath}/${bridgeImageParam}`);
+        // Add tag with docker context path for daemon discovery
+        // The daemon uses this tag to build and run the container locally
+        cfnFunction.tags.setTag(LIVE_LAMBDA_DOCKER_TAG, dockerContextPath);
+        // Grant permissions to publish/subscribe to AppSync Events
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                "appsync:EventConnect",
+                "appsync:EventPublish",
+                "appsync:EventSubscribe",
+            ],
+            resources: [apiArn, `${apiArn}/*`],
+        }));
+        // Grant permissions to read SSM parameters (bridge needs AppSync endpoints)
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ["ssm:GetParameter", "ssm:GetParameters"],
+            resources: [
+                `arn:aws:ssm:${stack.region}:${stack.account}:parameter${ssmBasePath}/*`,
+            ],
+        }));
+        // Increase timeout to allow for local debugging
+        cfnFunction.timeout = 300; // 5 minutes
+        // Replace the Docker image with the bridge image
+        cfnFunction.code = {
+            imageUri: bridgeImageUri,
+        };
+        console.log(`[LiveLambda] Replaced Docker image with bridge (${architecture})`);
+    }
+    /**
+     * Determine the architecture of a Lambda function.
+     * Defaults to x86_64 if not explicitly set.
+     */
+    getArchitecture(cfnFunction) {
+        const architectures = cfnFunction.architectures;
+        if (architectures?.includes("arm64")) {
+            return "arm64";
+        }
+        return "x86_64";
+    }
+    transformFunction(fn, _stackName, _functionId, _originalHandler, localHandler) {
+        const cfnFunction = fn.node.defaultChild;
+        const stack = cdk.Stack.of(fn);
+        // Read values from SSM parameters (created by bootstrap stack)
+        // Use the CDK bootstrap qualifier for proper scoping
+        const bootstrapQualifier = stack.node.tryGetContext("@aws-cdk/core:bootstrapQualifier") ||
+            "hnb659fds";
+        const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`;
+        const apiArn = ssm.StringParameter.valueForStringParameter(stack, `${ssmBasePath}/api-arn`);
+        const bridgeBucket = ssm.StringParameter.valueForStringParameter(stack, `${ssmBasePath}/bridge-bucket`);
+        const bridgeKey = ssm.StringParameter.valueForStringParameter(stack, `${ssmBasePath}/bridge-key`);
+        // Add tag with local handler path for daemon discovery
+        // The daemon queries Lambda API for functions with this tag
+        cfnFunction.tags.setTag(LIVE_LAMBDA_TAG, localHandler);
+        // Grant permissions to publish/subscribe to AppSync Events
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                "appsync:EventConnect",
+                "appsync:EventPublish",
+                "appsync:EventSubscribe",
+            ],
+            resources: [apiArn, `${apiArn}/*`],
+        }));
+        // Grant permissions to read SSM parameters (bridge needs AppSync endpoints)
+        fn.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ["ssm:GetParameter", "ssm:GetParameters"],
+            resources: [
+                `arn:aws:ssm:${stack.region}:${stack.account}:parameter${ssmBasePath}/*`,
+            ],
+        }));
+        // Increase timeout to allow for local debugging
+        cfnFunction.timeout = 300; // 5 minutes
+        // Replace the code with bridge handler from bootstrap stack's S3 bucket
+        cfnFunction.code = {
+            s3Bucket: bridgeBucket,
+            s3Key: bridgeKey,
+        };
+        cfnFunction.handler = "index.handler";
+    }
+}
+/**
+ * Helper function to check if live mode is enabled
+ */
+export function isLiveModeEnabled() {
+    return process.env.CDK_LIVE === "true";
+}
+/**
+ * Apply live lambda aspect to a CDK app or stack if live mode is enabled.
+ *
+ * @param scope The CDK app or stack to apply the aspect to
+ * @param props Optional configuration for the live lambda aspect
+ */
+export function applyLiveLambdaAspect(scope, props = {}) {
+    if (!isLiveModeEnabled()) {
+        console.log("[LiveLambda] Live mode not enabled (set CDK_LIVE=true to enable)");
+        return;
+    }
+    console.log("[LiveLambda] Live mode enabled - transforming Lambda functions");
+    cdk.Aspects.of(scope).add(new LiveLambdaAspect(props));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-lambda-aspect.js","sourceRoot":"","sources":["../../src/aspect/live-lambda-aspect.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CDK Aspect to transform Lambda functions for live debugging\n *\n * When applied to a CDK app/stack, this aspect:\n * 1. Replaces Lambda code with the bridge handler from the bootstrap stack's S3 bucket\n * 2. Grants IAM permissions for AppSync Events\n * 3. Adds a tag with the local handler path for the daemon to discover\n *\n * The bridge uses AWS_LAMBDA_FUNCTION_NAME (auto-injected by Lambda) for channel routing.\n * The daemon discovers functions by querying Lambda API for functions with the live-lambda tag.\n */\n\nimport * as cdk from \"aws-cdk-lib\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport type * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as ssm from \"aws-cdk-lib/aws-ssm\"\nimport type { IConstruct } from \"constructs\"\nimport {\n  LIVE_LAMBDA_DOCKER_TAG,\n  LIVE_LAMBDA_TAG,\n  SSM_BASE_PATH,\n} from \"../shared/types.js\"\nimport {\n  getDockerContextPath,\n  isDockerImageFunction,\n} from \"./docker-function-hook.js\"\nimport { getEntryPath, getHandlerName } from \"./nodejs-function-hook.js\"\n\n// Regex to strip file extension from entry path\nconst EXTENSION_REGEX = /\\.(ts|js|mjs|cjs|mts|cts)$/\n\n/**\n * Properties for LiveLambdaAspect\n */\nexport interface LiveLambdaAspectProps {\n  /**\n   * The stack name to use for channel routing.\n   * If not provided, uses the stack name from the function's stack.\n   */\n  stackName?: string\n\n  /**\n   * Optional: Pattern to match function construct IDs to transform.\n   * If not provided, all Lambda functions are transformed.\n   */\n  functionPattern?: RegExp\n\n  /**\n   * Optional: Function construct IDs to exclude from transformation.\n   */\n  excludeFunctions?: string[]\n}\n\n/**\n * CDK Aspect that transforms Lambda functions for live debugging.\n *\n * Usage in bin/app.ts:\n * ```typescript\n * const app = new cdk.App();\n * const stack = new MyStack(app, 'MyStack');\n *\n * if (process.env.CDK_LIVE === 'true') {\n *   cdk.Aspects.of(app).add(new LiveLambdaAspect());\n * }\n * ```\n */\nexport class LiveLambdaAspect implements cdk.IAspect {\n  private readonly props: LiveLambdaAspectProps\n  private readonly processedFunctions: Set<string> = new Set()\n\n  constructor(props: LiveLambdaAspectProps = {}) {\n    this.props = props\n  }\n\n  visit(node: IConstruct): void {\n    // Check if this is a Lambda Function using duck-typing instead of instanceof\n    // This avoids issues with multiple copies of aws-cdk-lib being loaded\n    if (!this.isLambdaFunction(node)) {\n      return\n    }\n\n    // Cast to lambda.Function for type checking (we've verified it's a Lambda)\n    const fn = node as unknown as lambda.Function\n\n    // Skip if already processed (aspects can visit multiple times)\n    const nodeId = node.node.addr\n    if (this.processedFunctions.has(nodeId)) {\n      return\n    }\n\n    // Generate a unique function ID from the construct path\n    const functionId = this.generateFunctionId(fn)\n\n    // Check exclusion list\n    if (this.props.excludeFunctions?.includes(functionId)) {\n      console.log(`[LiveLambda] Skipping excluded function: ${functionId}`)\n      return\n    }\n\n    // Check pattern match\n    if (\n      this.props.functionPattern &&\n      !this.props.functionPattern.test(functionId)\n    ) {\n      console.log(`[LiveLambda] Skipping non-matching function: ${functionId}`)\n      return\n    }\n\n    console.log(`[LiveLambda] Transforming function: ${functionId}`)\n\n    const stackName = this.props.stackName || cdk.Stack.of(fn).stackName\n\n    // Check if this is a DockerImageFunction\n    const isDockerFunction = isDockerImageFunction(fn)\n\n    if (isDockerFunction) {\n      console.log(`[LiveLambda] Detected DockerImageFunction: ${functionId}`)\n      this.transformDockerFunction(fn, stackName, functionId)\n    } else {\n      // Get handler paths before we modify anything\n      const handlerPaths = this.getHandlerPaths(fn)\n\n      // Skip unsupported functions (not NodejsFunction or DockerImageFunction)\n      if (!handlerPaths) {\n        return\n      }\n\n      const { originalHandler, localHandler } = handlerPaths\n\n      // Transform the function\n      this.transformFunction(\n        fn,\n        stackName,\n        functionId,\n        originalHandler,\n        localHandler,\n      )\n    }\n\n    this.processedFunctions.add(nodeId)\n  }\n\n  /**\n   * Check if a construct is a Lambda Function using duck-typing.\n   * This avoids instanceof issues when multiple copies of aws-cdk-lib are loaded.\n   */\n  private isLambdaFunction(node: IConstruct): boolean {\n    // Check by constructor name - handles Function, DockerImageFunction, NodejsFunction, etc.\n    // Also handles our patched versions like DockerImageFunctionWithCapture\n    const constructorName = node.constructor.name\n    // CDK appends \"2\" to class names in some versions\n    const isFunction =\n      constructorName === \"Function\" ||\n      constructorName === \"Function2\" ||\n      constructorName.endsWith(\"Function\") ||\n      constructorName.endsWith(\"Function2\") ||\n      constructorName.includes(\"Function\") // Catch patched versions like DockerImageFunctionWithCapture\n\n    if (!isFunction) {\n      return false\n    }\n\n    // Exclude CfnFunction (the L1 construct)\n    if (constructorName === \"CfnFunction\") {\n      return false\n    }\n\n    // Verify it has expected Lambda Function properties\n    const maybeFunction = node as unknown as {\n      functionName?: unknown\n      functionArn?: unknown\n      node?: { defaultChild?: unknown }\n    }\n\n    // Must have functionName and functionArn (IFunction interface)\n    if (!maybeFunction.functionName || !maybeFunction.functionArn) {\n      return false\n    }\n\n    // Must have a defaultChild (the CfnFunction)\n    if (!maybeFunction.node?.defaultChild) {\n      return false\n    }\n\n    return true\n  }\n\n  private generateFunctionId(fn: lambda.Function): string {\n    // Use the construct ID as the function ID\n    // For nested constructs, join with dashes\n    const parts = fn.node.path.split(\"/\")\n    // Skip first part (App) and take the rest\n    const relevantParts = parts.slice(1)\n    return relevantParts.join(\"-\").replace(/[^a-zA-Z0-9-]/g, \"-\")\n  }\n\n  /**\n   * Get handler paths for a function.\n   * Returns both the original handler (as set in CfnFunction) and the local handler path.\n   * Returns null if the function is not supported (e.g., not a NodejsFunction).\n   */\n  private getHandlerPaths(fn: lambda.Function): {\n    originalHandler: string\n    localHandler: string\n  } | null {\n    const cfnFunction = fn.node.defaultChild as lambda.CfnFunction\n    const originalHandler = cfnFunction.handler || \"index.handler\"\n    const constructId = fn.node.id\n\n    // Check if captured by the NodejsFunction hook\n    const entryPath = getEntryPath(fn)\n    const handlerName = getHandlerName(fn) || \"handler\"\n    if (entryPath) {\n      // Convert entry path to local handler path\n      // e.g., \"functions/s3-writer/handler.ts\" + \"handler\" -> \"functions/s3-writer/handler.handler\"\n      const localHandler = `${entryPath.replace(EXTENSION_REGEX, \"\")}.${handlerName}`\n      console.log(\n        `[LiveLambda] Using captured entry for ${constructId}: ${localHandler}`,\n      )\n      return { originalHandler, localHandler }\n    }\n\n    // No handler path found - this function is not supported (not a NodejsFunction or DockerImageFunction)\n    console.log(\n      `[LiveLambda] Skipping unsupported function \"${constructId}\": ` +\n        `not a NodejsFunction or DockerImageFunction (or bootstrap hook was not installed early enough)`,\n    )\n    return null\n  }\n\n  /**\n   * Transform a DockerImageFunction to use the bridge Docker image.\n   * Stores the local Docker context path in a tag for the daemon to build/run locally.\n   */\n  private transformDockerFunction(\n    fn: lambda.Function,\n    _stackName: string,\n    functionId: string,\n  ): void {\n    const cfnFunction = fn.node.defaultChild as lambda.CfnFunction\n    const stack = cdk.Stack.of(fn)\n\n    // Get the docker context path from the hook\n    const dockerContextPath = getDockerContextPath(fn)\n    if (!dockerContextPath) {\n      throw new Error(\n        `[LiveLambda] No docker context path for \"${functionId}\". ` +\n          `The bootstrap hook was not installed early enough. ` +\n          `Fix: import \"cdk-local-lambda/bootstrap\" before any CDK imports (Node.js), ` +\n          `or run Bun with \"bun --preload cdk-local-lambda/bootstrap\".`,\n      )\n    }\n\n    // Get SSM parameters\n    const bootstrapQualifier =\n      stack.node.tryGetContext(\"@aws-cdk/core:bootstrapQualifier\") ||\n      \"hnb659fds\"\n    const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`\n\n    const apiArn = ssm.StringParameter.valueForStringParameter(\n      stack,\n      `${ssmBasePath}/api-arn`,\n    )\n\n    // Determine architecture and get appropriate bridge image\n    const architecture = this.getArchitecture(cfnFunction)\n    const bridgeImageParam =\n      architecture === \"arm64\" ? \"bridge-image-arm64\" : \"bridge-image-x86_64\"\n\n    const bridgeImageUri = ssm.StringParameter.valueForStringParameter(\n      stack,\n      `${ssmBasePath}/${bridgeImageParam}`,\n    )\n\n    // Add tag with docker context path for daemon discovery\n    // The daemon uses this tag to build and run the container locally\n    cfnFunction.tags.setTag(LIVE_LAMBDA_DOCKER_TAG, dockerContextPath)\n\n    // Grant permissions to publish/subscribe to AppSync Events\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          \"appsync:EventConnect\",\n          \"appsync:EventPublish\",\n          \"appsync:EventSubscribe\",\n        ],\n        resources: [apiArn, `${apiArn}/*`],\n      }),\n    )\n\n    // Grant permissions to read SSM parameters (bridge needs AppSync endpoints)\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\"ssm:GetParameter\", \"ssm:GetParameters\"],\n        resources: [\n          `arn:aws:ssm:${stack.region}:${stack.account}:parameter${ssmBasePath}/*`,\n        ],\n      }),\n    )\n\n    // Increase timeout to allow for local debugging\n    cfnFunction.timeout = 300 // 5 minutes\n\n    // Replace the Docker image with the bridge image\n    cfnFunction.code = {\n      imageUri: bridgeImageUri,\n    }\n\n    console.log(\n      `[LiveLambda] Replaced Docker image with bridge (${architecture})`,\n    )\n  }\n\n  /**\n   * Determine the architecture of a Lambda function.\n   * Defaults to x86_64 if not explicitly set.\n   */\n  private getArchitecture(cfnFunction: lambda.CfnFunction): \"arm64\" | \"x86_64\" {\n    const architectures = cfnFunction.architectures as string[] | undefined\n    if (architectures?.includes(\"arm64\")) {\n      return \"arm64\"\n    }\n    return \"x86_64\"\n  }\n\n  private transformFunction(\n    fn: lambda.Function,\n    _stackName: string,\n    _functionId: string,\n    _originalHandler: string,\n    localHandler: string,\n  ): void {\n    const cfnFunction = fn.node.defaultChild as lambda.CfnFunction\n    const stack = cdk.Stack.of(fn)\n\n    // Read values from SSM parameters (created by bootstrap stack)\n    // Use the CDK bootstrap qualifier for proper scoping\n    const bootstrapQualifier =\n      stack.node.tryGetContext(\"@aws-cdk/core:bootstrapQualifier\") ||\n      \"hnb659fds\"\n    const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`\n\n    const apiArn = ssm.StringParameter.valueForStringParameter(\n      stack,\n      `${ssmBasePath}/api-arn`,\n    )\n    const bridgeBucket = ssm.StringParameter.valueForStringParameter(\n      stack,\n      `${ssmBasePath}/bridge-bucket`,\n    )\n    const bridgeKey = ssm.StringParameter.valueForStringParameter(\n      stack,\n      `${ssmBasePath}/bridge-key`,\n    )\n\n    // Add tag with local handler path for daemon discovery\n    // The daemon queries Lambda API for functions with this tag\n    cfnFunction.tags.setTag(LIVE_LAMBDA_TAG, localHandler)\n\n    // Grant permissions to publish/subscribe to AppSync Events\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          \"appsync:EventConnect\",\n          \"appsync:EventPublish\",\n          \"appsync:EventSubscribe\",\n        ],\n        resources: [apiArn, `${apiArn}/*`],\n      }),\n    )\n\n    // Grant permissions to read SSM parameters (bridge needs AppSync endpoints)\n    fn.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\"ssm:GetParameter\", \"ssm:GetParameters\"],\n        resources: [\n          `arn:aws:ssm:${stack.region}:${stack.account}:parameter${ssmBasePath}/*`,\n        ],\n      }),\n    )\n\n    // Increase timeout to allow for local debugging\n    cfnFunction.timeout = 300 // 5 minutes\n\n    // Replace the code with bridge handler from bootstrap stack's S3 bucket\n    cfnFunction.code = {\n      s3Bucket: bridgeBucket,\n      s3Key: bridgeKey,\n    }\n    cfnFunction.handler = \"index.handler\"\n  }\n}\n\n/**\n * Helper function to check if live mode is enabled\n */\nexport function isLiveModeEnabled(): boolean {\n  return process.env.CDK_LIVE === \"true\"\n}\n\n/**\n * Apply live lambda aspect to a CDK app or stack if live mode is enabled.\n *\n * @param scope The CDK app or stack to apply the aspect to\n * @param props Optional configuration for the live lambda aspect\n */\nexport function applyLiveLambdaAspect(\n  scope: IConstruct,\n  props: LiveLambdaAspectProps = {},\n): void {\n  if (!isLiveModeEnabled()) {\n    console.log(\n      \"[LiveLambda] Live mode not enabled (set CDK_LIVE=true to enable)\",\n    )\n    return\n  }\n\n  console.log(\"[LiveLambda] Live mode enabled - transforming Lambda functions\")\n  cdk.Aspects.of(scope).add(new LiveLambdaAspect(props))\n}\n"]}

package/lib/aspect/live-lambda-bootstrap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bootstrap file that installs hooks for NodejsFunction and DockerImageFunction
+ * BEFORE any CDK imports.
+ *
+ * This must be imported as the very first thing in the CDK app entry point,
+ * before any other imports.
+ *
+ * Runtime support:
+ * - Node.js: patches Module._load to intercept module loading
+ * - Bun: directly imports and patches modules (Module._load not supported)
+ *
+ * Hooks installed:
+ * - NodejsFunction: captures entry and handler props
+ * - DockerImageFunction: captures docker context path from code prop
+ * - DockerImageCode.fromImageAsset: captures the directory path
+ */
+export {};