cdk-local-lambda 0.0.2

package/lib/functions/bridge-builder/handler.js

@@ -0,0 +1,181 @@
+/**
+ * Custom resource handler that builds and uploads the bridge Lambda code.
+ *
+ * This handler:
+ * 1. Receives the bridge source code (base64 encoded) and AppSync endpoints
+ * 2. Replaces endpoint placeholders with actual values
+ * 3. Creates a zip file with the code
+ * 4. Uploads the zip to S3
+ * 5. Returns the S3 location for Lambda functions to use
+ */
+import * as crypto from "node:crypto";
+import * as zlib from "node:zlib";
+import { DeleteObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
+const s3 = new S3Client({});
+/**
+ * Create a minimal zip file containing a single file.
+ * This is a simple implementation that creates a valid zip without external dependencies.
+ */
+function createZip(filename, content) {
+    const contentBuffer = Buffer.from(content, "utf-8");
+    // Compress the content using deflate
+    const compressed = zlib.deflateRawSync(contentBuffer);
+    const crc32 = crc32buf(contentBuffer);
+    const now = new Date();
+    // DOS time and date
+    const dosTime = ((now.getHours() << 11) |
+        (now.getMinutes() << 5) |
+        Math.floor(now.getSeconds() / 2)) &
+        0xffff;
+    const dosDate = (((now.getFullYear() - 1980) << 9) |
+        ((now.getMonth() + 1) << 5) |
+        now.getDate()) &
+        0xffff;
+    const filenameBuffer = Buffer.from(filename, "utf-8");
+    // Local file header
+    const localHeader = Buffer.alloc(30);
+    localHeader.writeUInt32LE(0x04034b50, 0); // Local file header signature
+    localHeader.writeUInt16LE(20, 4); // Version needed to extract (2.0)
+    localHeader.writeUInt16LE(0, 6); // General purpose bit flag
+    localHeader.writeUInt16LE(8, 8); // Compression method (deflate)
+    localHeader.writeUInt16LE(dosTime, 10); // Last mod file time
+    localHeader.writeUInt16LE(dosDate, 12); // Last mod file date
+    localHeader.writeUInt32LE(crc32, 14); // CRC-32
+    localHeader.writeUInt32LE(compressed.length, 18); // Compressed size
+    localHeader.writeUInt32LE(contentBuffer.length, 22); // Uncompressed size
+    localHeader.writeUInt16LE(filenameBuffer.length, 26); // Filename length
+    localHeader.writeUInt16LE(0, 28); // Extra field length
+    // Central directory header
+    const centralHeader = Buffer.alloc(46);
+    centralHeader.writeUInt32LE(0x02014b50, 0); // Central directory signature
+    centralHeader.writeUInt16LE(20, 4); // Version made by
+    centralHeader.writeUInt16LE(20, 6); // Version needed to extract
+    centralHeader.writeUInt16LE(0, 8); // General purpose bit flag
+    centralHeader.writeUInt16LE(8, 10); // Compression method
+    centralHeader.writeUInt16LE(dosTime, 12); // Last mod file time
+    centralHeader.writeUInt16LE(dosDate, 14); // Last mod file date
+    centralHeader.writeUInt32LE(crc32, 16); // CRC-32
+    centralHeader.writeUInt32LE(compressed.length, 20); // Compressed size
+    centralHeader.writeUInt32LE(contentBuffer.length, 24); // Uncompressed size
+    centralHeader.writeUInt16LE(filenameBuffer.length, 28); // Filename length
+    centralHeader.writeUInt16LE(0, 30); // Extra field length
+    centralHeader.writeUInt16LE(0, 32); // File comment length
+    centralHeader.writeUInt16LE(0, 34); // Disk number start
+    centralHeader.writeUInt16LE(0, 36); // Internal file attributes
+    centralHeader.writeUInt32LE(0, 38); // External file attributes
+    centralHeader.writeUInt32LE(0, 42); // Relative offset of local header
+    // End of central directory
+    const localFileDataSize = localHeader.length + filenameBuffer.length + compressed.length;
+    const centralDirSize = centralHeader.length + filenameBuffer.length;
+    const endOfCentralDir = Buffer.alloc(22);
+    endOfCentralDir.writeUInt32LE(0x06054b50, 0); // End of central dir signature
+    endOfCentralDir.writeUInt16LE(0, 4); // Disk number
+    endOfCentralDir.writeUInt16LE(0, 6); // Disk number with central dir
+    endOfCentralDir.writeUInt16LE(1, 8); // Number of entries on this disk
+    endOfCentralDir.writeUInt16LE(1, 10); // Total number of entries
+    endOfCentralDir.writeUInt32LE(centralDirSize, 12); // Size of central directory
+    endOfCentralDir.writeUInt32LE(localFileDataSize, 16); // Offset of central directory
+    endOfCentralDir.writeUInt16LE(0, 20); // Comment length
+    return Buffer.concat([
+        localHeader,
+        filenameBuffer,
+        compressed,
+        centralHeader,
+        filenameBuffer,
+        endOfCentralDir,
+    ]);
+}
+/**
+ * Calculate CRC-32 of a buffer.
+ */
+function crc32buf(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        crc ^= buf[i];
+        for (let j = 0; j < 8; j++) {
+            crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export async function handler(event) {
+    console.log("Received event:", JSON.stringify(event, null, 2));
+    const props = event.ResourceProperties;
+    const { HttpEndpoint, RealtimeEndpoint, BucketName, BridgeSource } = props;
+    // Generate a unique key for this version
+    const sourceHash = crypto
+        .createHash("md5")
+        .update(BridgeSource)
+        .digest("hex")
+        .substring(0, 8);
+    const s3Key = `bridge/handler-${sourceHash}.zip`;
+    try {
+        if (event.RequestType === "Delete") {
+            // Clean up: delete the S3 object
+            // Use the physical resource ID from the event, not the computed s3Key
+            // This handles the case where the key format changed between versions
+            const keyToDelete = event.PhysicalResourceId || s3Key;
+            console.log(`Deleting S3 object: s3://${BucketName}/${keyToDelete}`);
+            try {
+                await s3.send(new DeleteObjectCommand({
+                    Bucket: BucketName,
+                    Key: keyToDelete,
+                }));
+            }
+            catch (deleteError) {
+                // Ignore delete errors - the object might not exist
+                console.log(`Note: Could not delete ${keyToDelete}: ${deleteError}`);
+            }
+            return {
+                Status: "SUCCESS",
+                PhysicalResourceId: event.PhysicalResourceId || s3Key,
+                StackId: event.StackId,
+                RequestId: event.RequestId,
+                LogicalResourceId: event.LogicalResourceId,
+                Data: {},
+            };
+        }
+        // Create or Update
+        // Decode the base64 source
+        const bridgeCode = Buffer.from(BridgeSource, "base64").toString("utf-8");
+        // Replace placeholders with actual endpoints
+        const finalCode = bridgeCode
+            .replace(/__APPSYNC_HTTP_ENDPOINT__/g, HttpEndpoint)
+            .replace(/__APPSYNC_REALTIME_ENDPOINT__/g, RealtimeEndpoint);
+        // Create a zip file containing the handler code
+        // Lambda expects the handler file to be named 'index.js' when handler is 'index.handler'
+        const zipBuffer = createZip("index.js", finalCode);
+        // Upload to S3
+        await s3.send(new PutObjectCommand({
+            Bucket: BucketName,
+            Key: s3Key,
+            Body: zipBuffer,
+            ContentType: "application/zip",
+        }));
+        console.log(`Uploaded bridge code to s3://${BucketName}/${s3Key}`);
+        return {
+            Status: "SUCCESS",
+            PhysicalResourceId: s3Key,
+            StackId: event.StackId,
+            RequestId: event.RequestId,
+            LogicalResourceId: event.LogicalResourceId,
+            Data: {
+                BucketName,
+                S3Key: s3Key,
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error:", error);
+        return {
+            Status: "FAILED",
+            Reason: error instanceof Error ? error.message : "Unknown error",
+            PhysicalResourceId: s3Key,
+            StackId: event.StackId,
+            RequestId: event.RequestId,
+            LogicalResourceId: event.LogicalResourceId,
+            Data: {},
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../../src/functions/bridge-builder/handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom resource handler that builds and uploads the bridge Lambda code.\n *\n * This handler:\n * 1. Receives the bridge source code (base64 encoded) and AppSync endpoints\n * 2. Replaces endpoint placeholders with actual values\n * 3. Creates a zip file with the code\n * 4. Uploads the zip to S3\n * 5. Returns the S3 location for Lambda functions to use\n */\n\nimport * as crypto from \"node:crypto\"\nimport * as zlib from \"node:zlib\"\nimport {\n  DeleteObjectCommand,\n  PutObjectCommand,\n  S3Client,\n} from \"@aws-sdk/client-s3\"\nimport type {\n  CloudFormationCustomResourceEvent,\n  CloudFormationCustomResourceResponse,\n} from \"aws-lambda\"\n\nconst s3 = new S3Client({})\n\n/**\n * Create a minimal zip file containing a single file.\n * This is a simple implementation that creates a valid zip without external dependencies.\n */\nfunction createZip(filename: string, content: string): Buffer {\n  const contentBuffer = Buffer.from(content, \"utf-8\")\n\n  // Compress the content using deflate\n  const compressed = zlib.deflateRawSync(contentBuffer)\n\n  const crc32 = crc32buf(contentBuffer)\n  const now = new Date()\n\n  // DOS time and date\n  const dosTime =\n    ((now.getHours() << 11) |\n      (now.getMinutes() << 5) |\n      Math.floor(now.getSeconds() / 2)) &\n    0xffff\n  const dosDate =\n    (((now.getFullYear() - 1980) << 9) |\n      ((now.getMonth() + 1) << 5) |\n      now.getDate()) &\n    0xffff\n\n  const filenameBuffer = Buffer.from(filename, \"utf-8\")\n\n  // Local file header\n  const localHeader = Buffer.alloc(30)\n  localHeader.writeUInt32LE(0x04034b50, 0) // Local file header signature\n  localHeader.writeUInt16LE(20, 4) // Version needed to extract (2.0)\n  localHeader.writeUInt16LE(0, 6) // General purpose bit flag\n  localHeader.writeUInt16LE(8, 8) // Compression method (deflate)\n  localHeader.writeUInt16LE(dosTime, 10) // Last mod file time\n  localHeader.writeUInt16LE(dosDate, 12) // Last mod file date\n  localHeader.writeUInt32LE(crc32, 14) // CRC-32\n  localHeader.writeUInt32LE(compressed.length, 18) // Compressed size\n  localHeader.writeUInt32LE(contentBuffer.length, 22) // Uncompressed size\n  localHeader.writeUInt16LE(filenameBuffer.length, 26) // Filename length\n  localHeader.writeUInt16LE(0, 28) // Extra field length\n\n  // Central directory header\n  const centralHeader = Buffer.alloc(46)\n  centralHeader.writeUInt32LE(0x02014b50, 0) // Central directory signature\n  centralHeader.writeUInt16LE(20, 4) // Version made by\n  centralHeader.writeUInt16LE(20, 6) // Version needed to extract\n  centralHeader.writeUInt16LE(0, 8) // General purpose bit flag\n  centralHeader.writeUInt16LE(8, 10) // Compression method\n  centralHeader.writeUInt16LE(dosTime, 12) // Last mod file time\n  centralHeader.writeUInt16LE(dosDate, 14) // Last mod file date\n  centralHeader.writeUInt32LE(crc32, 16) // CRC-32\n  centralHeader.writeUInt32LE(compressed.length, 20) // Compressed size\n  centralHeader.writeUInt32LE(contentBuffer.length, 24) // Uncompressed size\n  centralHeader.writeUInt16LE(filenameBuffer.length, 28) // Filename length\n  centralHeader.writeUInt16LE(0, 30) // Extra field length\n  centralHeader.writeUInt16LE(0, 32) // File comment length\n  centralHeader.writeUInt16LE(0, 34) // Disk number start\n  centralHeader.writeUInt16LE(0, 36) // Internal file attributes\n  centralHeader.writeUInt32LE(0, 38) // External file attributes\n  centralHeader.writeUInt32LE(0, 42) // Relative offset of local header\n\n  // End of central directory\n  const localFileDataSize =\n    localHeader.length + filenameBuffer.length + compressed.length\n  const centralDirSize = centralHeader.length + filenameBuffer.length\n\n  const endOfCentralDir = Buffer.alloc(22)\n  endOfCentralDir.writeUInt32LE(0x06054b50, 0) // End of central dir signature\n  endOfCentralDir.writeUInt16LE(0, 4) // Disk number\n  endOfCentralDir.writeUInt16LE(0, 6) // Disk number with central dir\n  endOfCentralDir.writeUInt16LE(1, 8) // Number of entries on this disk\n  endOfCentralDir.writeUInt16LE(1, 10) // Total number of entries\n  endOfCentralDir.writeUInt32LE(centralDirSize, 12) // Size of central directory\n  endOfCentralDir.writeUInt32LE(localFileDataSize, 16) // Offset of central directory\n  endOfCentralDir.writeUInt16LE(0, 20) // Comment length\n\n  return Buffer.concat([\n    localHeader,\n    filenameBuffer,\n    compressed,\n    centralHeader,\n    filenameBuffer,\n    endOfCentralDir,\n  ])\n}\n\n/**\n * Calculate CRC-32 of a buffer.\n */\nfunction crc32buf(buf: Buffer): number {\n  let crc = 0xffffffff\n  for (let i = 0; i < buf.length; i++) {\n    crc ^= buf[i]\n    for (let j = 0; j < 8; j++) {\n      crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1\n    }\n  }\n  return (crc ^ 0xffffffff) >>> 0\n}\n\ninterface ResourceProperties {\n  HttpEndpoint: string\n  RealtimeEndpoint: string\n  BucketName: string\n  BridgeSource: string // Base64 encoded\n  SourceHash?: string\n}\n\nexport async function handler(\n  event: CloudFormationCustomResourceEvent,\n): Promise<CloudFormationCustomResourceResponse> {\n  console.log(\"Received event:\", JSON.stringify(event, null, 2))\n\n  const props = event.ResourceProperties as unknown as ResourceProperties\n  const { HttpEndpoint, RealtimeEndpoint, BucketName, BridgeSource } = props\n\n  // Generate a unique key for this version\n  const sourceHash = crypto\n    .createHash(\"md5\")\n    .update(BridgeSource)\n    .digest(\"hex\")\n    .substring(0, 8)\n  const s3Key = `bridge/handler-${sourceHash}.zip`\n\n  try {\n    if (event.RequestType === \"Delete\") {\n      // Clean up: delete the S3 object\n      // Use the physical resource ID from the event, not the computed s3Key\n      // This handles the case where the key format changed between versions\n      const keyToDelete = event.PhysicalResourceId || s3Key\n      console.log(`Deleting S3 object: s3://${BucketName}/${keyToDelete}`)\n\n      try {\n        await s3.send(\n          new DeleteObjectCommand({\n            Bucket: BucketName,\n            Key: keyToDelete,\n          }),\n        )\n      } catch (deleteError) {\n        // Ignore delete errors - the object might not exist\n        console.log(`Note: Could not delete ${keyToDelete}: ${deleteError}`)\n      }\n\n      return {\n        Status: \"SUCCESS\",\n        PhysicalResourceId: event.PhysicalResourceId || s3Key,\n        StackId: event.StackId,\n        RequestId: event.RequestId,\n        LogicalResourceId: event.LogicalResourceId,\n        Data: {},\n      }\n    }\n\n    // Create or Update\n    // Decode the base64 source\n    const bridgeCode = Buffer.from(BridgeSource, \"base64\").toString(\"utf-8\")\n\n    // Replace placeholders with actual endpoints\n    const finalCode = bridgeCode\n      .replace(/__APPSYNC_HTTP_ENDPOINT__/g, HttpEndpoint)\n      .replace(/__APPSYNC_REALTIME_ENDPOINT__/g, RealtimeEndpoint)\n\n    // Create a zip file containing the handler code\n    // Lambda expects the handler file to be named 'index.js' when handler is 'index.handler'\n    const zipBuffer = createZip(\"index.js\", finalCode)\n\n    // Upload to S3\n    await s3.send(\n      new PutObjectCommand({\n        Bucket: BucketName,\n        Key: s3Key,\n        Body: zipBuffer,\n        ContentType: \"application/zip\",\n      }),\n    )\n\n    console.log(`Uploaded bridge code to s3://${BucketName}/${s3Key}`)\n\n    return {\n      Status: \"SUCCESS\",\n      PhysicalResourceId: s3Key,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      Data: {\n        BucketName,\n        S3Key: s3Key,\n      },\n    }\n  } catch (error) {\n    console.error(\"Error:\", error)\n\n    return {\n      Status: \"FAILED\",\n      Reason: error instanceof Error ? error.message : \"Unknown error\",\n      PhysicalResourceId: s3Key,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      Data: {},\n    }\n  }\n}\n"]}

package/lib/functions/bridge-docker/runtime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lambda Custom Runtime implementation for the Docker bridge.
+ *
+ * This implements the Lambda Runtime API to:
+ * 1. Fetch invocations from the runtime API
+ * 2. Call the bridge handler
+ * 3. Post responses back to the runtime API
+ */
+export {};

package/lib/functions/bridge-docker/runtime.js

@@ -0,0 +1,127 @@
+/**
+ * Lambda Custom Runtime implementation for the Docker bridge.
+ *
+ * This implements the Lambda Runtime API to:
+ * 1. Fetch invocations from the runtime API
+ * 2. Call the bridge handler
+ * 3. Post responses back to the runtime API
+ */
+import { handler as bridgeHandler } from "../bridge/handler.js";
+const RUNTIME_API = process.env.AWS_LAMBDA_RUNTIME_API;
+const HANDLER = process.env._HANDLER || "index.handler";
+if (!RUNTIME_API) {
+    console.error("[Runtime] AWS_LAMBDA_RUNTIME_API not set");
+    process.exit(1);
+}
+const RUNTIME_BASE = `http://${RUNTIME_API}/2018-06-01/runtime`;
+async function getNextInvocation() {
+    const response = await fetch(`${RUNTIME_BASE}/invocation/next`);
+    if (!response.ok) {
+        throw new Error(`Failed to get next invocation: ${response.status}`);
+    }
+    const headers = Object.fromEntries(response.headers.entries());
+    const event = await response.json();
+    const requestId = headers["lambda-runtime-aws-request-id"];
+    const deadlineMs = parseInt(headers["lambda-runtime-deadline-ms"], 10);
+    const invokedFunctionArn = headers["lambda-runtime-invoked-function-arn"];
+    const traceId = headers["lambda-runtime-trace-id"];
+    // Set trace ID environment variable for X-Ray
+    if (traceId) {
+        process.env._X_AMZN_TRACE_ID = traceId;
+    }
+    const context = {
+        functionName: process.env.AWS_LAMBDA_FUNCTION_NAME || "unknown",
+        functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION || "$LATEST",
+        invokedFunctionArn,
+        memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || "256",
+        awsRequestId: requestId,
+        logGroupName: process.env.AWS_LAMBDA_LOG_GROUP_NAME || "/aws/lambda/unknown",
+        logStreamName: process.env.AWS_LAMBDA_LOG_STREAM_NAME || "unknown",
+        getRemainingTimeInMillis: () => deadlineMs - Date.now(),
+        callbackWaitsForEmptyEventLoop: true,
+        done: () => { },
+        fail: () => { },
+        succeed: () => { },
+    };
+    return { event, context };
+}
+async function postResponse(requestId, response) {
+    const res = await fetch(`${RUNTIME_BASE}/invocation/${requestId}/response`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(response),
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to post response: ${res.status}`);
+    }
+}
+async function postError(requestId, error) {
+    const errorPayload = {
+        errorType: error.name || "Error",
+        errorMessage: error.message,
+        stackTrace: error.stack?.split("\n") || [],
+    };
+    const res = await fetch(`${RUNTIME_BASE}/invocation/${requestId}/error`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Lambda-Runtime-Function-Error-Type": "Unhandled",
+        },
+        body: JSON.stringify(errorPayload),
+    });
+    if (!res.ok) {
+        console.error(`[Runtime] Failed to post error: ${res.status}`);
+    }
+}
+async function postInitError(error) {
+    const errorPayload = {
+        errorType: error.name || "Error",
+        errorMessage: error.message,
+        stackTrace: error.stack?.split("\n") || [],
+    };
+    const res = await fetch(`${RUNTIME_BASE}/init/error`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Lambda-Runtime-Function-Error-Type": "Unhandled",
+        },
+        body: JSON.stringify(errorPayload),
+    });
+    if (!res.ok) {
+        console.error(`[Runtime] Failed to post init error: ${res.status}`);
+    }
+}
+async function main() {
+    console.log("[Runtime] Starting Lambda custom runtime");
+    console.log(`[Runtime] Handler: ${HANDLER}`);
+    console.log(`[Runtime] Function: ${process.env.AWS_LAMBDA_FUNCTION_NAME}`);
+    // Process invocations in a loop
+    while (true) {
+        let requestId;
+        try {
+            // Get next invocation
+            const { event, context } = await getNextInvocation();
+            requestId = context.awsRequestId;
+            console.log(`[Runtime] Processing invocation ${requestId}`);
+            // Call the bridge handler
+            const result = await bridgeHandler(event, context);
+            // Post response
+            await postResponse(requestId, result);
+            console.log(`[Runtime] Response sent for ${requestId}`);
+        }
+        catch (error) {
+            console.error(`[Runtime] Error:`, error);
+            if (requestId) {
+                await postError(requestId, error instanceof Error ? error : new Error(String(error)));
+            }
+            else {
+                await postInitError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+}
+main().catch((error) => {
+    console.error("[Runtime] Fatal error:", error);
+    postInitError(error instanceof Error ? error : new Error(String(error))).finally(() => process.exit(1));
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/functions/bridge-docker/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lambda Custom Runtime implementation for the Docker bridge.\n *\n * This implements the Lambda Runtime API to:\n * 1. Fetch invocations from the runtime API\n * 2. Call the bridge handler\n * 3. Post responses back to the runtime API\n */\n\nimport type { Context } from \"aws-lambda\"\nimport { handler as bridgeHandler } from \"../bridge/handler.js\"\n\nconst RUNTIME_API = process.env.AWS_LAMBDA_RUNTIME_API\nconst HANDLER = process.env._HANDLER || \"index.handler\"\n\nif (!RUNTIME_API) {\n  console.error(\"[Runtime] AWS_LAMBDA_RUNTIME_API not set\")\n  process.exit(1)\n}\n\nconst RUNTIME_BASE = `http://${RUNTIME_API}/2018-06-01/runtime`\n\ninterface RuntimeHeaders {\n  \"lambda-runtime-aws-request-id\": string\n  \"lambda-runtime-deadline-ms\": string\n  \"lambda-runtime-invoked-function-arn\": string\n  \"lambda-runtime-trace-id\"?: string\n  \"lambda-runtime-client-context\"?: string\n  \"lambda-runtime-cognito-identity\"?: string\n}\n\nasync function getNextInvocation(): Promise<{\n  event: unknown\n  context: Context\n}> {\n  const response = await fetch(`${RUNTIME_BASE}/invocation/next`)\n\n  if (!response.ok) {\n    throw new Error(`Failed to get next invocation: ${response.status}`)\n  }\n\n  const headers = Object.fromEntries(\n    response.headers.entries(),\n  ) as unknown as RuntimeHeaders\n  const event = await response.json()\n\n  const requestId = headers[\"lambda-runtime-aws-request-id\"]\n  const deadlineMs = parseInt(headers[\"lambda-runtime-deadline-ms\"], 10)\n  const invokedFunctionArn = headers[\"lambda-runtime-invoked-function-arn\"]\n  const traceId = headers[\"lambda-runtime-trace-id\"]\n\n  // Set trace ID environment variable for X-Ray\n  if (traceId) {\n    process.env._X_AMZN_TRACE_ID = traceId\n  }\n\n  const context: Context = {\n    functionName: process.env.AWS_LAMBDA_FUNCTION_NAME || \"unknown\",\n    functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION || \"$LATEST\",\n    invokedFunctionArn,\n    memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE || \"256\",\n    awsRequestId: requestId,\n    logGroupName:\n      process.env.AWS_LAMBDA_LOG_GROUP_NAME || \"/aws/lambda/unknown\",\n    logStreamName: process.env.AWS_LAMBDA_LOG_STREAM_NAME || \"unknown\",\n    getRemainingTimeInMillis: () => deadlineMs - Date.now(),\n    callbackWaitsForEmptyEventLoop: true,\n    done: () => {},\n    fail: () => {},\n    succeed: () => {},\n  }\n\n  return { event, context }\n}\n\nasync function postResponse(\n  requestId: string,\n  response: unknown,\n): Promise<void> {\n  const res = await fetch(`${RUNTIME_BASE}/invocation/${requestId}/response`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify(response),\n  })\n\n  if (!res.ok) {\n    throw new Error(`Failed to post response: ${res.status}`)\n  }\n}\n\nasync function postError(requestId: string, error: Error): Promise<void> {\n  const errorPayload = {\n    errorType: error.name || \"Error\",\n    errorMessage: error.message,\n    stackTrace: error.stack?.split(\"\\n\") || [],\n  }\n\n  const res = await fetch(`${RUNTIME_BASE}/invocation/${requestId}/error`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      \"Lambda-Runtime-Function-Error-Type\": \"Unhandled\",\n    },\n    body: JSON.stringify(errorPayload),\n  })\n\n  if (!res.ok) {\n    console.error(`[Runtime] Failed to post error: ${res.status}`)\n  }\n}\n\nasync function postInitError(error: Error): Promise<void> {\n  const errorPayload = {\n    errorType: error.name || \"Error\",\n    errorMessage: error.message,\n    stackTrace: error.stack?.split(\"\\n\") || [],\n  }\n\n  const res = await fetch(`${RUNTIME_BASE}/init/error`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      \"Lambda-Runtime-Function-Error-Type\": \"Unhandled\",\n    },\n    body: JSON.stringify(errorPayload),\n  })\n\n  if (!res.ok) {\n    console.error(`[Runtime] Failed to post init error: ${res.status}`)\n  }\n}\n\nasync function main() {\n  console.log(\"[Runtime] Starting Lambda custom runtime\")\n  console.log(`[Runtime] Handler: ${HANDLER}`)\n  console.log(`[Runtime] Function: ${process.env.AWS_LAMBDA_FUNCTION_NAME}`)\n\n  // Process invocations in a loop\n  while (true) {\n    let requestId: string | undefined\n\n    try {\n      // Get next invocation\n      const { event, context } = await getNextInvocation()\n      requestId = context.awsRequestId\n\n      console.log(`[Runtime] Processing invocation ${requestId}`)\n\n      // Call the bridge handler\n      const result = await bridgeHandler(event, context)\n\n      // Post response\n      await postResponse(requestId, result)\n      console.log(`[Runtime] Response sent for ${requestId}`)\n    } catch (error) {\n      console.error(`[Runtime] Error:`, error)\n\n      if (requestId) {\n        await postError(\n          requestId,\n          error instanceof Error ? error : new Error(String(error)),\n        )\n      } else {\n        await postInitError(\n          error instanceof Error ? error : new Error(String(error)),\n        )\n      }\n    }\n  }\n}\n\nmain().catch((error) => {\n  console.error(\"[Runtime] Fatal error:\", error)\n  postInitError(\n    error instanceof Error ? error : new Error(String(error)),\n  ).finally(() => process.exit(1))\n})\n"]}

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Main entry point for cdk-local-lambda.
+ *
+ * Exports:
+ * - LiveLambdaAspect: CDK Aspect to transform Lambda functions
+ * - applyLiveLambdaAspect: Helper to apply the aspect if CDK_LIVE=true
+ * - isLiveModeEnabled: Check if live mode is enabled
+ * - CdkLocalLambdaBootstrapStack: The bootstrap stack for shared infrastructure
+ *
+ * For Docker function support, you must install the bootstrap BEFORE any CDK
+ * imports in your app entry point:
+ *
+ * ```typescript
+ * import "cdk-local-lambda/bootstrap"
+ * import * as cdk from "aws-cdk-lib"
+ * ```
+ *
+ * Node.js: this is sufficient.
+ * Bun: use `bun --preload cdk-local-lambda/bootstrap` (static ESM imports are
+ * linked before this module runs).
+ */
+export { applyLiveLambdaAspect, isLiveModeEnabled, LiveLambdaAspect, type LiveLambdaAspectProps, } from "./aspect/live-lambda-aspect.js";
+export { CdkLocalLambdaBootstrapStack, type CdkLocalLambdaBootstrapStackProps, } from "./bootstrap-stack/bootstrap-stack.js";
+export { buildChannelName, type ErrorPayload, hashFunctionName, type InvocationMessage, type LambdaContext, LIVE_LAMBDA_DOCKER_TAG, LIVE_LAMBDA_TAG, type ResponseMessage, SSM_BASE_PATH, } from "./shared/types.js";

package/lib/index.js

@@ -0,0 +1,28 @@
+/**
+ * Main entry point for cdk-local-lambda.
+ *
+ * Exports:
+ * - LiveLambdaAspect: CDK Aspect to transform Lambda functions
+ * - applyLiveLambdaAspect: Helper to apply the aspect if CDK_LIVE=true
+ * - isLiveModeEnabled: Check if live mode is enabled
+ * - CdkLocalLambdaBootstrapStack: The bootstrap stack for shared infrastructure
+ *
+ * For Docker function support, you must install the bootstrap BEFORE any CDK
+ * imports in your app entry point:
+ *
+ * ```typescript
+ * import "cdk-local-lambda/bootstrap"
+ * import * as cdk from "aws-cdk-lib"
+ * ```
+ *
+ * Node.js: this is sufficient.
+ * Bun: use `bun --preload cdk-local-lambda/bootstrap` (static ESM imports are
+ * linked before this module runs).
+ */
+// Re-export the aspect and helpers
+export { applyLiveLambdaAspect, isLiveModeEnabled, LiveLambdaAspect, } from "./aspect/live-lambda-aspect.js";
+// Re-export the bootstrap stack
+export { CdkLocalLambdaBootstrapStack, } from "./bootstrap-stack/bootstrap-stack.js";
+// Re-export shared types
+export { buildChannelName, hashFunctionName, LIVE_LAMBDA_DOCKER_TAG, LIVE_LAMBDA_TAG, SSM_BASE_PATH, } from "./shared/types.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared constants and types used by bootstrap stack, aspect, and CLI.
+ */
+/**
+ * SSM parameter paths for Live Lambda infrastructure
+ * Base path for all Live Lambda SSM parameters
+ */
+export declare const SSM_BASE_PATH = "/cdk-local-lambda";
+/**
+ * Tag key used to store the local handler path on Lambda functions
+ */
+export declare const LIVE_LAMBDA_TAG = "live-lambda:handler";
+/**
+ * Tag key used to store the local Docker context path on DockerImageFunction.
+ * The daemon uses this to build and run the container locally.
+ */
+export declare const LIVE_LAMBDA_DOCKER_TAG = "live-lambda:docker-context";
+/**
+ * Name of the CDK bootstrap stack
+ */
+export declare const BOOTSTRAP_STACK_NAME = "CdkLocalLambdaBootstrapStack";
+/**
+ * Current version of the bootstrap stack.
+ * Increment this when making breaking changes to the bootstrap infrastructure.
+ */
+export declare const BOOTSTRAP_VERSION = "1";
+/**
+ * Environment variable names used by the bridge handler
+ */
+export declare const ENV_VARS: {
+    readonly HTTP_ENDPOINT: "APPSYNC_HTTP_ENDPOINT";
+    readonly REALTIME_ENDPOINT: "APPSYNC_REALTIME_ENDPOINT";
+};
+/**
+ * Message types for AppSync Events communication
+ */
+export interface InvocationMessage {
+    type: "invocation";
+    requestId: string;
+    event: unknown;
+    context: LambdaContext;
+    /** Lambda environment variables (forwarded from bridge on first invocation) */
+    env?: Record<string, string>;
+}
+/**
+ * Environment variables that are set locally by the daemon.
+ * These override any values from the bridge Lambda and are excluded from forwarding.
+ * Note: AWS_LAMBDA_FUNCTION_MEMORY_SIZE is also set locally but isn't in EXCLUDED_ENV_VARS
+ * because it doesn't come from the bridge Lambda's process.env (it's in the context).
+ */
+export declare const LOCAL_OVERRIDE_ENV_VARS: Set<string>;
+/**
+ * Environment variables to exclude when forwarding from Lambda.
+ * These are either Lambda internals or should use local values instead.
+ */
+export declare const EXCLUDED_ENV_VARS: Set<string>;
+/**
+ * Filter environment variables for forwarding to local execution.
+ * Removes Lambda internals and system variables that should use local values.
+ */
+export declare function filterEnvVars(env: NodeJS.ProcessEnv): Record<string, string>;
+export interface ResponseMessage {
+    type: "response";
+    requestId: string;
+    result?: unknown;
+    error?: ErrorPayload;
+}
+export interface ErrorPayload {
+    errorType: string;
+    errorMessage: string;
+    stackTrace?: string[];
+}
+export interface LambdaContext {
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    getRemainingTimeInMillis: number;
+}
+/**
+ * Hash a function name for use in channel paths.
+ * Uses first 16 hex chars of SHA256 to stay within AppSync limits.
+ */
+export declare function hashFunctionName(functionName: string): string;
+/**
+ * Channel name builders for AppSync Events
+ */
+export declare const buildChannelName: {
+    /**
+     * Channel for sending invocations to the daemon
+     * Bridge -> Daemon
+     */
+    readonly invocation: (functionName: string) => string;
+    /**
+     * Channel for receiving responses from the daemon
+     * Daemon -> Bridge
+     */
+    readonly response: (functionName: string) => string;
+};