cdk-local-lambda 0.0.2

package/lib/bootstrap-stack/bootstrap-stack.js

@@ -0,0 +1,338 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as cdk from "aws-cdk-lib";
+import * as appsync from "aws-cdk-lib/aws-appsync";
+import * as ecrAssets from "aws-cdk-lib/aws-ecr-assets";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as ssm from "aws-cdk-lib/aws-ssm";
+import * as cr from "aws-cdk-lib/custom-resources";
+import { BOOTSTRAP_VERSION, SSM_BASE_PATH } from "../shared/types.js";
+// ESM equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Bootstrap stack that creates the shared AppSync Events API infrastructure
+ * for live lambda debugging. This stack should be deployed once per account/region.
+ */
+export class CdkLocalLambdaBootstrapStack extends cdk.Stack {
+    /**
+     * The AppSync Events API for WebSocket communication
+     */
+    api;
+    /**
+     * The channel namespace for live debugging channels
+     */
+    channelNamespace;
+    /**
+     * The HTTP endpoint for publishing events
+     */
+    httpEndpoint;
+    /**
+     * The WebSocket endpoint for real-time subscriptions
+     */
+    realtimeEndpoint;
+    /**
+     * IAM role for publishing to the Events API
+     */
+    publishRole;
+    /**
+     * S3 bucket for storing the bridge Lambda code
+     */
+    bridgeBucket;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const apiName = props?.apiName ?? "LiveLambdaEventsApi";
+        // Create S3 bucket for bridge code
+        this.bridgeBucket = new s3.Bucket(this, "BridgeBucket", {
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+            blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+        });
+        // Create AppSync Events API with IAM authentication
+        this.api = new appsync.CfnApi(this, "EventsApi", {
+            name: apiName,
+            eventConfig: {
+                authProviders: [
+                    {
+                        authType: "AWS_IAM",
+                    },
+                ],
+                connectionAuthModes: [
+                    {
+                        authType: "AWS_IAM",
+                    },
+                ],
+                defaultPublishAuthModes: [
+                    {
+                        authType: "AWS_IAM",
+                    },
+                ],
+                defaultSubscribeAuthModes: [
+                    {
+                        authType: "AWS_IAM",
+                    },
+                ],
+            },
+        });
+        // Create channel namespace for live debugging
+        // Channels will be: /live/{stackName}/{functionId}/in and /live/{stackName}/{functionId}/out
+        this.channelNamespace = new appsync.CfnChannelNamespace(this, "LiveNamespace", {
+            apiId: this.api.attrApiId,
+            name: "live",
+        });
+        // Store endpoints - using getAtt since attrDns is typed as IResolvable
+        // Prepend protocols since AppSync only returns hostnames
+        this.httpEndpoint = cdk.Fn.join("", [
+            "https://",
+            cdk.Token.asString(this.api.getAtt("Dns.Http")),
+        ]);
+        this.realtimeEndpoint = cdk.Fn.join("", [
+            "wss://",
+            cdk.Token.asString(this.api.getAtt("Dns.Realtime")),
+        ]);
+        // Create IAM role for Lambda functions to publish/subscribe
+        this.publishRole = new iam.Role(this, "PublishRole", {
+            assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
+            description: "Role for Lambda functions to publish/subscribe to Live Lambda Events API",
+        });
+        // Grant permissions to publish and subscribe to the Events API
+        this.publishRole.addToPolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: [
+                "appsync:EventConnect",
+                "appsync:EventPublish",
+                "appsync:EventSubscribe",
+            ],
+            resources: [`${this.api.attrApiArn}/*`, this.api.attrApiArn],
+        }));
+        // Create SSM parameters for the endpoints
+        // These are used by the live-lambda-aspect to configure Lambda functions
+        // Use the CDK bootstrap qualifier for proper scoping
+        const bootstrapQualifier = this.node.tryGetContext("@aws-cdk/core:bootstrapQualifier") || "hnb659fds";
+        const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`;
+        new ssm.StringParameter(this, "HttpEndpointParam", {
+            parameterName: `${ssmBasePath}/http-endpoint`,
+            stringValue: this.httpEndpoint,
+            description: "AppSync Events HTTP endpoint for Live Lambda",
+        });
+        new ssm.StringParameter(this, "RealtimeEndpointParam", {
+            parameterName: `${ssmBasePath}/realtime-endpoint`,
+            stringValue: this.realtimeEndpoint,
+            description: "AppSync Events WebSocket endpoint for Live Lambda",
+        });
+        new ssm.StringParameter(this, "ApiArnParam", {
+            parameterName: `${ssmBasePath}/api-arn`,
+            stringValue: this.api.attrApiArn,
+            description: "AppSync Events API ARN for Live Lambda",
+        });
+        new ssm.StringParameter(this, "ApiIdParam", {
+            parameterName: `${ssmBasePath}/api-id`,
+            stringValue: this.api.attrApiId,
+            description: "AppSync Events API ID for Live Lambda",
+        });
+        // Build bridge handler and upload to S3
+        const { bucketName, s3Key, bridgeSource } = this.buildAndUploadBridge();
+        const bridgeS3Location = { bucketName, s3Key };
+        // Store bridge S3 location in SSM
+        new ssm.StringParameter(this, "BridgeBucketParam", {
+            parameterName: `${ssmBasePath}/bridge-bucket`,
+            stringValue: bridgeS3Location.bucketName,
+            description: "S3 bucket containing Live Lambda bridge code",
+        });
+        new ssm.StringParameter(this, "BridgeKeyParam", {
+            parameterName: `${ssmBasePath}/bridge-key`,
+            stringValue: bridgeS3Location.s3Key,
+            description: "S3 key for Live Lambda bridge code",
+        });
+        // Build and store Docker bridge images for DockerImageFunction support
+        const dockerBridgeImages = this.buildDockerBridgeImages(bridgeSource);
+        new ssm.StringParameter(this, "BridgeImageArm64Param", {
+            parameterName: `${ssmBasePath}/bridge-image-arm64`,
+            stringValue: dockerBridgeImages.arm64ImageUri,
+            description: "ECR image URI for ARM64 bridge Docker image",
+        });
+        new ssm.StringParameter(this, "BridgeImageX86Param", {
+            parameterName: `${ssmBasePath}/bridge-image-x86_64`,
+            stringValue: dockerBridgeImages.x86ImageUri,
+            description: "ECR image URI for x86_64 bridge Docker image",
+        });
+        // Store the bootstrap version for compatibility checking
+        new ssm.StringParameter(this, "VersionParam", {
+            parameterName: `${ssmBasePath}/version`,
+            stringValue: BOOTSTRAP_VERSION,
+            description: "Bootstrap stack version for Live Lambda",
+        });
+        // Output the endpoints (for CLI and debugging)
+        new cdk.CfnOutput(this, "HttpEndpoint", {
+            value: this.httpEndpoint,
+            description: "AppSync Events HTTP endpoint",
+        });
+        new cdk.CfnOutput(this, "RealtimeEndpoint", {
+            value: this.realtimeEndpoint,
+            description: "AppSync Events WebSocket endpoint",
+        });
+        new cdk.CfnOutput(this, "ApiId", {
+            value: this.api.attrApiId,
+            description: "AppSync Events API ID",
+        });
+        new cdk.CfnOutput(this, "ApiArn", {
+            value: this.api.attrApiArn,
+            description: "AppSync Events API ARN",
+        });
+        new cdk.CfnOutput(this, "PublishRoleArn", {
+            value: this.publishRole.roleArn,
+            description: "IAM Role ARN for publishing to Events API",
+        });
+    }
+    /**
+     * Grant a Lambda function permission to publish and subscribe to the Events API
+     */
+    grantPublishSubscribe(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: [
+                "appsync:EventConnect",
+                "appsync:EventPublish",
+                "appsync:EventSubscribe",
+            ],
+            resourceArns: [`${this.api.attrApiArn}/*`, this.api.attrApiArn],
+        });
+    }
+    /**
+     * Build the bridge handler and upload to S3 using a custom resource.
+     * The bridge code has AppSync endpoints baked in at deploy time.
+     */
+    buildAndUploadBridge() {
+        // Build the bridge source code at synth time (with placeholders)
+        const bridgePath = path.join(__dirname, "..", "functions", "bridge");
+        const outputPath = path.join(__dirname, "..", "out-tsc", "bridge-bundle.js");
+        // Bundle the bridge handler
+        // Note: We use .js since TypeScript compiles src/ to lib/
+        try {
+            execSync(`bun build ${bridgePath}/handler.js --outfile=${outputPath} --target=node --format=cjs --bundle --external=@aws-sdk/*`, { stdio: "pipe" });
+        }
+        catch (err) {
+            console.error("Failed to bundle bridge handler:", err);
+            throw err;
+        }
+        // Read the bundled code
+        const bridgeSource = fs.readFileSync(outputPath, "utf-8");
+        // Create the bridge builder Lambda that will replace placeholders and upload
+        const bridgeBuilderPath = path.join(__dirname, "..", "functions", "bridge-builder");
+        const bridgeBuilder = new lambda.Function(this, "BridgeBuilder", {
+            runtime: lambda.Runtime.NODEJS_24_X,
+            handler: "index.handler",
+            code: lambda.Code.fromAsset(bridgeBuilderPath, {
+                bundling: {
+                    image: lambda.Runtime.NODEJS_24_X.bundlingImage,
+                    command: [
+                        "bash",
+                        "-c",
+                        [
+                            "npm install --prefix /tmp esbuild",
+                            "/tmp/node_modules/.bin/esbuild handler.ts --bundle --platform=node --target=node24 --format=cjs --outfile=/asset-output/index.js --external:@aws-sdk/*",
+                        ].join(" && "),
+                    ],
+                    local: {
+                        tryBundle(outputDir) {
+                            try {
+                                execSync(`bun build ${bridgeBuilderPath}/handler.js --outfile=${outputDir}/index.js --target=node --format=cjs --bundle --external=@aws-sdk/*`, { stdio: "pipe" });
+                                return true;
+                            }
+                            catch {
+                                return false;
+                            }
+                        },
+                    },
+                },
+            }),
+            timeout: cdk.Duration.minutes(1),
+            memorySize: 256,
+            logRetention: logs.RetentionDays.ONE_WEEK,
+        });
+        // Grant the builder Lambda permission to write to the bridge bucket
+        this.bridgeBucket.grantWrite(bridgeBuilder);
+        // Create custom resource provider
+        const provider = new cr.Provider(this, "BridgeBuilderProvider", {
+            onEventHandler: bridgeBuilder,
+            logRetention: logs.RetentionDays.ONE_WEEK,
+        });
+        // Create custom resource that builds and uploads the bridge
+        const bridgeResource = new cdk.CustomResource(this, "BridgeResource", {
+            serviceToken: provider.serviceToken,
+            properties: {
+                HttpEndpoint: this.httpEndpoint,
+                RealtimeEndpoint: this.realtimeEndpoint,
+                BucketName: this.bridgeBucket.bucketName,
+                BridgeSource: Buffer.from(bridgeSource).toString("base64"),
+                // Force update when source changes
+                SourceHash: cdk.Fn.base64(bridgeSource.substring(0, 100)),
+            },
+        });
+        // Ensure the bridge is built after the bucket exists
+        bridgeResource.node.addDependency(this.bridgeBucket);
+        return {
+            bucketName: bridgeResource.getAttString("BucketName"),
+            s3Key: bridgeResource.getAttString("S3Key"),
+            bridgeSource,
+        };
+    }
+    /**
+     * Build Docker bridge images for ARM64 and x86_64 architectures.
+     * Uses CDK Docker image assets to build and push to ECR.
+     */
+    buildDockerBridgeImages(_bridgeSource) {
+        const projectRoot = path.join(__dirname, "..", "..");
+        const bridgeDockerPath = path.join(projectRoot, "src", "functions", "bridge-docker");
+        // Create a temporary directory for Docker build context
+        const buildContextPath = path.join(projectRoot, "src", "out-tsc", "docker-ctx");
+        fs.mkdirSync(buildContextPath, { recursive: true });
+        // Build the runtime wrapper that implements the Lambda Runtime API
+        // This bundle INCLUDES all dependencies (AWS SDK, ws, etc.) since
+        // Docker images using provided:al2023 don't have them pre-installed
+        const runtimePath = path.join(bridgeDockerPath, "runtime.ts");
+        const runtimeBundlePath = path.join(buildContextPath, "runtime.js");
+        try {
+            execSync(`bun build ${runtimePath} --outfile=${runtimeBundlePath} --target=node --format=cjs --bundle`, { stdio: "pipe" });
+        }
+        catch (err) {
+            console.error("Failed to bundle runtime wrapper for Docker:", err);
+            throw err;
+        }
+        // Copy Dockerfile and bootstrap script
+        fs.copyFileSync(path.join(bridgeDockerPath, "Dockerfile.arm64"), path.join(buildContextPath, "Dockerfile.arm64"));
+        fs.copyFileSync(path.join(bridgeDockerPath, "Dockerfile.x86_64"), path.join(buildContextPath, "Dockerfile.x86_64"));
+        fs.copyFileSync(path.join(bridgeDockerPath, "bootstrap.sh"), path.join(buildContextPath, "bootstrap.sh"));
+        // Build ARM64 image using CDK Docker image asset
+        const arm64Image = new ecrAssets.DockerImageAsset(this, "BridgeImageArm64", {
+            directory: buildContextPath,
+            file: "Dockerfile.arm64",
+            platform: ecrAssets.Platform.LINUX_ARM64,
+        });
+        // Build x86_64 image using CDK Docker image asset
+        const x86Image = new ecrAssets.DockerImageAsset(this, "BridgeImageX86", {
+            directory: buildContextPath,
+            file: "Dockerfile.x86_64",
+            platform: ecrAssets.Platform.LINUX_AMD64,
+        });
+        // Output the image URIs
+        new cdk.CfnOutput(this, "BridgeImageArm64Uri", {
+            value: arm64Image.imageUri,
+            description: "ECR URI for ARM64 bridge Docker image",
+        });
+        new cdk.CfnOutput(this, "BridgeImageX86Uri", {
+            value: x86Image.imageUri,
+            description: "ECR URI for x86_64 bridge Docker image",
+        });
+        return {
+            arm64ImageUri: arm64Image.imageUri,
+            x86ImageUri: x86Image.imageUri,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap-stack.js","sourceRoot":"","sources":["../../src/bootstrap-stack/bootstrap-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync } from \"node:child_process\"\nimport * as fs from \"node:fs\"\nimport * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as appsync from \"aws-cdk-lib/aws-appsync\"\nimport * as ecrAssets from \"aws-cdk-lib/aws-ecr-assets\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as ssm from \"aws-cdk-lib/aws-ssm\"\nimport * as cr from \"aws-cdk-lib/custom-resources\"\nimport type { Construct } from \"constructs\"\nimport { BOOTSTRAP_VERSION, SSM_BASE_PATH } from \"../shared/types.js\"\n\n// ESM equivalent of __dirname\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n\n/**\n * Properties for the LiveLambdaBootstrapStack\n */\nexport interface CdkLocalLambdaBootstrapStackProps extends cdk.StackProps {\n  /**\n   * Optional name for the AppSync Events API\n   * @default 'LiveLambdaEventsApi'\n   */\n  apiName?: string\n}\n\n/**\n * Bootstrap stack that creates the shared AppSync Events API infrastructure\n * for live lambda debugging. This stack should be deployed once per account/region.\n */\nexport class CdkLocalLambdaBootstrapStack extends cdk.Stack {\n  /**\n   * The AppSync Events API for WebSocket communication\n   */\n  public readonly api: appsync.CfnApi\n\n  /**\n   * The channel namespace for live debugging channels\n   */\n  public readonly channelNamespace: appsync.CfnChannelNamespace\n\n  /**\n   * The HTTP endpoint for publishing events\n   */\n  public readonly httpEndpoint: string\n\n  /**\n   * The WebSocket endpoint for real-time subscriptions\n   */\n  public readonly realtimeEndpoint: string\n\n  /**\n   * IAM role for publishing to the Events API\n   */\n  public readonly publishRole: iam.Role\n\n  /**\n   * S3 bucket for storing the bridge Lambda code\n   */\n  public readonly bridgeBucket: s3.Bucket\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props?: CdkLocalLambdaBootstrapStackProps,\n  ) {\n    super(scope, id, props)\n\n    const apiName = props?.apiName ?? \"LiveLambdaEventsApi\"\n\n    // Create S3 bucket for bridge code\n    this.bridgeBucket = new s3.Bucket(this, \"BridgeBucket\", {\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n    })\n\n    // Create AppSync Events API with IAM authentication\n    this.api = new appsync.CfnApi(this, \"EventsApi\", {\n      name: apiName,\n      eventConfig: {\n        authProviders: [\n          {\n            authType: \"AWS_IAM\",\n          },\n        ],\n        connectionAuthModes: [\n          {\n            authType: \"AWS_IAM\",\n          },\n        ],\n        defaultPublishAuthModes: [\n          {\n            authType: \"AWS_IAM\",\n          },\n        ],\n        defaultSubscribeAuthModes: [\n          {\n            authType: \"AWS_IAM\",\n          },\n        ],\n      },\n    })\n\n    // Create channel namespace for live debugging\n    // Channels will be: /live/{stackName}/{functionId}/in and /live/{stackName}/{functionId}/out\n    this.channelNamespace = new appsync.CfnChannelNamespace(\n      this,\n      \"LiveNamespace\",\n      {\n        apiId: this.api.attrApiId,\n        name: \"live\",\n      },\n    )\n\n    // Store endpoints - using getAtt since attrDns is typed as IResolvable\n    // Prepend protocols since AppSync only returns hostnames\n    this.httpEndpoint = cdk.Fn.join(\"\", [\n      \"https://\",\n      cdk.Token.asString(this.api.getAtt(\"Dns.Http\")),\n    ])\n    this.realtimeEndpoint = cdk.Fn.join(\"\", [\n      \"wss://\",\n      cdk.Token.asString(this.api.getAtt(\"Dns.Realtime\")),\n    ])\n\n    // Create IAM role for Lambda functions to publish/subscribe\n    this.publishRole = new iam.Role(this, \"PublishRole\", {\n      assumedBy: new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n      description:\n        \"Role for Lambda functions to publish/subscribe to Live Lambda Events API\",\n    })\n\n    // Grant permissions to publish and subscribe to the Events API\n    this.publishRole.addToPolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          \"appsync:EventConnect\",\n          \"appsync:EventPublish\",\n          \"appsync:EventSubscribe\",\n        ],\n        resources: [`${this.api.attrApiArn}/*`, this.api.attrApiArn],\n      }),\n    )\n\n    // Create SSM parameters for the endpoints\n    // These are used by the live-lambda-aspect to configure Lambda functions\n    // Use the CDK bootstrap qualifier for proper scoping\n    const bootstrapQualifier =\n      this.node.tryGetContext(\"@aws-cdk/core:bootstrapQualifier\") || \"hnb659fds\"\n    const ssmBasePath = `${SSM_BASE_PATH}/${bootstrapQualifier}`\n\n    new ssm.StringParameter(this, \"HttpEndpointParam\", {\n      parameterName: `${ssmBasePath}/http-endpoint`,\n      stringValue: this.httpEndpoint,\n      description: \"AppSync Events HTTP endpoint for Live Lambda\",\n    })\n\n    new ssm.StringParameter(this, \"RealtimeEndpointParam\", {\n      parameterName: `${ssmBasePath}/realtime-endpoint`,\n      stringValue: this.realtimeEndpoint,\n      description: \"AppSync Events WebSocket endpoint for Live Lambda\",\n    })\n\n    new ssm.StringParameter(this, \"ApiArnParam\", {\n      parameterName: `${ssmBasePath}/api-arn`,\n      stringValue: this.api.attrApiArn,\n      description: \"AppSync Events API ARN for Live Lambda\",\n    })\n\n    new ssm.StringParameter(this, \"ApiIdParam\", {\n      parameterName: `${ssmBasePath}/api-id`,\n      stringValue: this.api.attrApiId,\n      description: \"AppSync Events API ID for Live Lambda\",\n    })\n\n    // Build bridge handler and upload to S3\n    const { bucketName, s3Key, bridgeSource } = this.buildAndUploadBridge()\n    const bridgeS3Location = { bucketName, s3Key }\n\n    // Store bridge S3 location in SSM\n    new ssm.StringParameter(this, \"BridgeBucketParam\", {\n      parameterName: `${ssmBasePath}/bridge-bucket`,\n      stringValue: bridgeS3Location.bucketName,\n      description: \"S3 bucket containing Live Lambda bridge code\",\n    })\n\n    new ssm.StringParameter(this, \"BridgeKeyParam\", {\n      parameterName: `${ssmBasePath}/bridge-key`,\n      stringValue: bridgeS3Location.s3Key,\n      description: \"S3 key for Live Lambda bridge code\",\n    })\n\n    // Build and store Docker bridge images for DockerImageFunction support\n    const dockerBridgeImages = this.buildDockerBridgeImages(bridgeSource)\n\n    new ssm.StringParameter(this, \"BridgeImageArm64Param\", {\n      parameterName: `${ssmBasePath}/bridge-image-arm64`,\n      stringValue: dockerBridgeImages.arm64ImageUri,\n      description: \"ECR image URI for ARM64 bridge Docker image\",\n    })\n\n    new ssm.StringParameter(this, \"BridgeImageX86Param\", {\n      parameterName: `${ssmBasePath}/bridge-image-x86_64`,\n      stringValue: dockerBridgeImages.x86ImageUri,\n      description: \"ECR image URI for x86_64 bridge Docker image\",\n    })\n\n    // Store the bootstrap version for compatibility checking\n    new ssm.StringParameter(this, \"VersionParam\", {\n      parameterName: `${ssmBasePath}/version`,\n      stringValue: BOOTSTRAP_VERSION,\n      description: \"Bootstrap stack version for Live Lambda\",\n    })\n\n    // Output the endpoints (for CLI and debugging)\n    new cdk.CfnOutput(this, \"HttpEndpoint\", {\n      value: this.httpEndpoint,\n      description: \"AppSync Events HTTP endpoint\",\n    })\n\n    new cdk.CfnOutput(this, \"RealtimeEndpoint\", {\n      value: this.realtimeEndpoint,\n      description: \"AppSync Events WebSocket endpoint\",\n    })\n\n    new cdk.CfnOutput(this, \"ApiId\", {\n      value: this.api.attrApiId,\n      description: \"AppSync Events API ID\",\n    })\n\n    new cdk.CfnOutput(this, \"ApiArn\", {\n      value: this.api.attrApiArn,\n      description: \"AppSync Events API ARN\",\n    })\n\n    new cdk.CfnOutput(this, \"PublishRoleArn\", {\n      value: this.publishRole.roleArn,\n      description: \"IAM Role ARN for publishing to Events API\",\n    })\n  }\n\n  /**\n   * Grant a Lambda function permission to publish and subscribe to the Events API\n   */\n  public grantPublishSubscribe(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\n        \"appsync:EventConnect\",\n        \"appsync:EventPublish\",\n        \"appsync:EventSubscribe\",\n      ],\n      resourceArns: [`${this.api.attrApiArn}/*`, this.api.attrApiArn],\n    })\n  }\n\n  /**\n   * Build the bridge handler and upload to S3 using a custom resource.\n   * The bridge code has AppSync endpoints baked in at deploy time.\n   */\n  private buildAndUploadBridge(): {\n    bucketName: string\n    s3Key: string\n    bridgeSource: string\n  } {\n    // Build the bridge source code at synth time (with placeholders)\n    const bridgePath = path.join(__dirname, \"..\", \"functions\", \"bridge\")\n    const outputPath = path.join(__dirname, \"..\", \"out-tsc\", \"bridge-bundle.js\")\n\n    // Bundle the bridge handler\n    // Note: We use .js since TypeScript compiles src/ to lib/\n    try {\n      execSync(\n        `bun build ${bridgePath}/handler.js --outfile=${outputPath} --target=node --format=cjs --bundle --external=@aws-sdk/*`,\n        { stdio: \"pipe\" },\n      )\n    } catch (err) {\n      console.error(\"Failed to bundle bridge handler:\", err)\n      throw err\n    }\n\n    // Read the bundled code\n    const bridgeSource = fs.readFileSync(outputPath, \"utf-8\")\n\n    // Create the bridge builder Lambda that will replace placeholders and upload\n    const bridgeBuilderPath = path.join(\n      __dirname,\n      \"..\",\n      \"functions\",\n      \"bridge-builder\",\n    )\n    const bridgeBuilder = new lambda.Function(this, \"BridgeBuilder\", {\n      runtime: lambda.Runtime.NODEJS_24_X,\n      handler: \"index.handler\",\n      code: lambda.Code.fromAsset(bridgeBuilderPath, {\n        bundling: {\n          image: lambda.Runtime.NODEJS_24_X.bundlingImage,\n          command: [\n            \"bash\",\n            \"-c\",\n            [\n              \"npm install --prefix /tmp esbuild\",\n              \"/tmp/node_modules/.bin/esbuild handler.ts --bundle --platform=node --target=node24 --format=cjs --outfile=/asset-output/index.js --external:@aws-sdk/*\",\n            ].join(\" && \"),\n          ],\n          local: {\n            tryBundle(outputDir: string): boolean {\n              try {\n                execSync(\n                  `bun build ${bridgeBuilderPath}/handler.js --outfile=${outputDir}/index.js --target=node --format=cjs --bundle --external=@aws-sdk/*`,\n                  { stdio: \"pipe\" },\n                )\n                return true\n              } catch {\n                return false\n              }\n            },\n          },\n        },\n      }),\n      timeout: cdk.Duration.minutes(1),\n      memorySize: 256,\n      logRetention: logs.RetentionDays.ONE_WEEK,\n    })\n\n    // Grant the builder Lambda permission to write to the bridge bucket\n    this.bridgeBucket.grantWrite(bridgeBuilder)\n\n    // Create custom resource provider\n    const provider = new cr.Provider(this, \"BridgeBuilderProvider\", {\n      onEventHandler: bridgeBuilder,\n      logRetention: logs.RetentionDays.ONE_WEEK,\n    })\n\n    // Create custom resource that builds and uploads the bridge\n    const bridgeResource = new cdk.CustomResource(this, \"BridgeResource\", {\n      serviceToken: provider.serviceToken,\n      properties: {\n        HttpEndpoint: this.httpEndpoint,\n        RealtimeEndpoint: this.realtimeEndpoint,\n        BucketName: this.bridgeBucket.bucketName,\n        BridgeSource: Buffer.from(bridgeSource).toString(\"base64\"),\n        // Force update when source changes\n        SourceHash: cdk.Fn.base64(bridgeSource.substring(0, 100)),\n      },\n    })\n\n    // Ensure the bridge is built after the bucket exists\n    bridgeResource.node.addDependency(this.bridgeBucket)\n\n    return {\n      bucketName: bridgeResource.getAttString(\"BucketName\"),\n      s3Key: bridgeResource.getAttString(\"S3Key\"),\n      bridgeSource,\n    }\n  }\n\n  /**\n   * Build Docker bridge images for ARM64 and x86_64 architectures.\n   * Uses CDK Docker image assets to build and push to ECR.\n   */\n  private buildDockerBridgeImages(_bridgeSource: string): {\n    arm64ImageUri: string\n    x86ImageUri: string\n  } {\n    const projectRoot = path.join(__dirname, \"..\", \"..\")\n    const bridgeDockerPath = path.join(\n      projectRoot,\n      \"src\",\n      \"functions\",\n      \"bridge-docker\",\n    )\n\n    // Create a temporary directory for Docker build context\n    const buildContextPath = path.join(\n      projectRoot,\n      \"src\",\n      \"out-tsc\",\n      \"docker-ctx\",\n    )\n    fs.mkdirSync(buildContextPath, { recursive: true })\n\n    // Build the runtime wrapper that implements the Lambda Runtime API\n    // This bundle INCLUDES all dependencies (AWS SDK, ws, etc.) since\n    // Docker images using provided:al2023 don't have them pre-installed\n    const runtimePath = path.join(bridgeDockerPath, \"runtime.ts\")\n    const runtimeBundlePath = path.join(buildContextPath, \"runtime.js\")\n    try {\n      execSync(\n        `bun build ${runtimePath} --outfile=${runtimeBundlePath} --target=node --format=cjs --bundle`,\n        { stdio: \"pipe\" },\n      )\n    } catch (err) {\n      console.error(\"Failed to bundle runtime wrapper for Docker:\", err)\n      throw err\n    }\n\n    // Copy Dockerfile and bootstrap script\n    fs.copyFileSync(\n      path.join(bridgeDockerPath, \"Dockerfile.arm64\"),\n      path.join(buildContextPath, \"Dockerfile.arm64\"),\n    )\n    fs.copyFileSync(\n      path.join(bridgeDockerPath, \"Dockerfile.x86_64\"),\n      path.join(buildContextPath, \"Dockerfile.x86_64\"),\n    )\n    fs.copyFileSync(\n      path.join(bridgeDockerPath, \"bootstrap.sh\"),\n      path.join(buildContextPath, \"bootstrap.sh\"),\n    )\n\n    // Build ARM64 image using CDK Docker image asset\n    const arm64Image = new ecrAssets.DockerImageAsset(\n      this,\n      \"BridgeImageArm64\",\n      {\n        directory: buildContextPath,\n        file: \"Dockerfile.arm64\",\n        platform: ecrAssets.Platform.LINUX_ARM64,\n      },\n    )\n\n    // Build x86_64 image using CDK Docker image asset\n    const x86Image = new ecrAssets.DockerImageAsset(this, \"BridgeImageX86\", {\n      directory: buildContextPath,\n      file: \"Dockerfile.x86_64\",\n      platform: ecrAssets.Platform.LINUX_AMD64,\n    })\n\n    // Output the image URIs\n    new cdk.CfnOutput(this, \"BridgeImageArm64Uri\", {\n      value: arm64Image.imageUri,\n      description: \"ECR URI for ARM64 bridge Docker image\",\n    })\n\n    new cdk.CfnOutput(this, \"BridgeImageX86Uri\", {\n      value: x86Image.imageUri,\n      description: \"ECR URI for x86_64 bridge Docker image\",\n    })\n\n    return {\n      arm64ImageUri: arm64Image.imageUri,\n      x86ImageUri: x86Image.imageUri,\n    }\n  }\n}\n"]}

package/lib/cli/appsync/client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Effect-based AppSync Events client for the daemon.
+ *
+ * Wraps the existing AppSync client with Effect primitives for better
+ * error handling and resource management.
+ */
+import { Effect, Stream } from "effect";
+import type { InvocationMessage, ResponseMessage } from "../../shared/types.js";
+/**
+ * Configuration for the Effect AppSync client.
+ */
+export interface AppSyncClientConfig {
+    httpEndpoint: string;
+    realtimeEndpoint: string;
+    region?: string;
+}
+/**
+ * Create an Effect-based AppSync Events client.
+ */
+export declare const makeAppSyncClient: (config: AppSyncClientConfig) => {
+    publish: (channel: string, message: unknown) => Effect.Effect<void, Error, never>;
+    subscribe: <T>(channel: string) => Stream.Stream<T, Error, never>;
+    subscribeToInvocations: (channel: string) => Stream.Stream<InvocationMessage, Error, never>;
+    publishResponse: (channel: string, response: ResponseMessage) => Effect.Effect<void, Error, never>;
+    createSubscribeAuthorization: (channel: string) => Effect.Effect<Record<string, string>, Error, never>;
+};
+/**
+ * Type for the AppSync client.
+ */
+export type AppSyncClient = ReturnType<typeof makeAppSyncClient>;