cdk-local-lambda 0.0.2

package/lib/functions/bridge/appsync-client.js

@@ -0,0 +1,345 @@
+/**
+ * AppSync Events client with AWS SigV4 signing.
+ *
+ * This client handles:
+ * - HTTP requests to publish events (with IAM signing)
+ * - WebSocket connections for real-time subscriptions (with IAM signing)
+ */
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { SignatureV4 } from "@aws-sdk/signature-v4";
+import WebSocket from "ws";
+/**
+ * Client for AppSync Events API
+ */
+export class AppSyncEventsClient {
+    httpEndpoint;
+    realtimeEndpoint;
+    region;
+    ws = null;
+    constructor(config) {
+        this.httpEndpoint = config.httpEndpoint;
+        this.realtimeEndpoint = config.realtimeEndpoint;
+        // Extract region from endpoint URL
+        // Format: https://{api-id}.appsync-api.{region}.amazonaws.com/event
+        const match = config.httpEndpoint.match(/\.([a-z0-9-]+)\.amazonaws\.com/);
+        this.region =
+            config.region ?? match?.[1] ?? process.env.AWS_REGION ?? "us-east-1";
+    }
+    /**
+     * Publish a message to a channel and wait for a response on another channel.
+     */
+    async publishAndWaitForResponse(options) {
+        const { publishChannel, subscribeChannel, message, timeoutMs, matchResponse, } = options;
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.close();
+                reject(new Error(`Timeout waiting for response after ${timeoutMs}ms`));
+            }, timeoutMs);
+            // Set up WebSocket connection first
+            this.connectAndSubscribe(subscribeChannel, (receivedMessage) => {
+                if (matchResponse(receivedMessage)) {
+                    clearTimeout(timeoutId);
+                    resolve(receivedMessage);
+                    return true; // Signal to stop listening
+                }
+                return false;
+            })
+                .then(() => {
+                // Once subscribed, publish the message
+                return this.publish(publishChannel, message);
+            })
+                .catch((err) => {
+                clearTimeout(timeoutId);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Publish a message to a channel via HTTP
+     */
+    async publish(channel, message) {
+        const url = new URL(this.httpEndpoint);
+        const body = JSON.stringify({
+            channel,
+            events: [JSON.stringify(message)],
+        });
+        // AppSync Events requires /event path for publishing
+        const path = url.pathname.endsWith("/event") ? url.pathname : "/event";
+        const request = new HttpRequest({
+            method: "POST",
+            protocol: url.protocol,
+            hostname: url.hostname,
+            path,
+            headers: {
+                "Content-Type": "application/json",
+                host: url.hostname,
+            },
+            body,
+        });
+        // Sign the request
+        const signer = new SignatureV4({
+            credentials: defaultProvider(),
+            region: this.region,
+            service: "appsync",
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Make the HTTP request - use the correct endpoint with /event path
+        const publishUrl = `${url.protocol}//${url.hostname}${path}`;
+        const response = await fetch(publishUrl, {
+            method: "POST",
+            headers: signedRequest.headers,
+            body,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Failed to publish event: ${response.status} ${text}`);
+        }
+    }
+    /**
+     * Subscribe to a channel and receive messages continuously.
+     * Returns an unsubscribe function.
+     */
+    async subscribe(options) {
+        const { channel, onMessage, onError } = options;
+        await this.connectAndSubscribeContinuous(channel, onMessage, onError);
+        return () => {
+            this.close();
+        };
+    }
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Connect to WebSocket and subscribe to a channel
+     */
+    async connectAndSubscribe(channel, onMessage) {
+        // Build signed WebSocket connection
+        const [wsUrl, subprotocols] = await this.buildSignedWebSocketConnection();
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl, subprotocols);
+            this.ws.on("open", () => {
+                console.log("[Bridge] WebSocket connected");
+                // Send connection init
+                this.ws?.send(JSON.stringify({ type: "connection_init" }));
+            });
+            this.ws.on("message", (data) => {
+                const message = JSON.parse(data.toString());
+                if (message.type === "connection_ack") {
+                    console.log("[Bridge] Connection acknowledged");
+                    // Subscribe to channel with authorization
+                    this.createSubscribeAuthorization(channel).then((auth) => {
+                        this.ws?.send(JSON.stringify({
+                            type: "subscribe",
+                            id: "sub-1",
+                            channel,
+                            authorization: auth,
+                        }));
+                    });
+                }
+                else if (message.type === "subscribe_success") {
+                    console.log(`[Bridge] Subscribed to ${channel}`);
+                    resolve();
+                }
+                else if (message.type === "data" && message.id === "sub-1") {
+                    // Parse the event data
+                    try {
+                        const eventData = JSON.parse(message.event);
+                        const shouldStop = onMessage(eventData);
+                        if (shouldStop) {
+                            this.close();
+                        }
+                    }
+                    catch (err) {
+                        console.error("[Bridge] Failed to parse event data:", err);
+                    }
+                }
+                else if (message.type === "error") {
+                    console.error("[Bridge] WebSocket error:", message);
+                    reject(new Error(message.errors
+                        ?.map((e) => e.message)
+                        .join(", ") ?? "Unknown error"));
+                }
+            });
+            this.ws.on("error", (err) => {
+                console.error("[Bridge] WebSocket error:", err);
+                reject(err);
+            });
+            this.ws.on("close", () => {
+                console.log("[Bridge] WebSocket closed");
+            });
+        });
+    }
+    /**
+     * Connect to WebSocket and subscribe to a channel with continuous message handling.
+     * Unlike connectAndSubscribe, this doesn't close after receiving a message.
+     */
+    async connectAndSubscribeContinuous(channel, onMessage, onError) {
+        // Build signed WebSocket connection
+        const [wsUrl, subprotocols] = await this.buildSignedWebSocketConnection();
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl, subprotocols);
+            this.ws.on("open", () => {
+                console.log("[AppSync] WebSocket connected");
+                // Send connection init
+                this.ws?.send(JSON.stringify({ type: "connection_init" }));
+            });
+            this.ws.on("message", async (data) => {
+                const message = JSON.parse(data.toString());
+                if (message.type === "connection_ack") {
+                    console.log("[AppSync] Connection acknowledged");
+                    // Subscribe to channel with authorization
+                    this.createSubscribeAuthorization(channel).then((auth) => {
+                        this.ws?.send(JSON.stringify({
+                            type: "subscribe",
+                            id: "sub-1",
+                            channel,
+                            authorization: auth,
+                        }));
+                    });
+                }
+                else if (message.type === "subscribe_success") {
+                    console.log(`[AppSync] Subscribed to ${channel}`);
+                    resolve();
+                }
+                else if (message.type === "data" && message.id === "sub-1") {
+                    // Parse the event data
+                    try {
+                        const eventData = JSON.parse(message.event);
+                        await onMessage(eventData);
+                    }
+                    catch (err) {
+                        console.error("[AppSync] Failed to parse event data:", err);
+                        onError?.(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+                else if (message.type === "error") {
+                    console.error("[AppSync] WebSocket error:", message);
+                    const error = new Error(message.errors
+                        ?.map((e) => e.message)
+                        .join(", ") ?? "Unknown error");
+                    onError?.(error);
+                    reject(error);
+                }
+            });
+            this.ws.on("error", (err) => {
+                console.error("[AppSync] WebSocket error:", err);
+                onError?.(err);
+                reject(err);
+            });
+            this.ws.on("close", () => {
+                console.log("[AppSync] WebSocket closed");
+            });
+        });
+    }
+    /**
+     * Create authorization headers for subscribe operation
+     */
+    async createSubscribeAuthorization(channel) {
+        const httpUrl = new URL(this.httpEndpoint);
+        const payload = JSON.stringify({ channel });
+        const request = new HttpRequest({
+            method: "POST",
+            protocol: "https:",
+            hostname: httpUrl.hostname,
+            path: "/event",
+            headers: {
+                accept: "application/json, text/javascript",
+                "content-encoding": "amz-1.0",
+                "content-type": "application/json; charset=UTF-8",
+                host: httpUrl.hostname,
+            },
+            body: payload,
+        });
+        const signer = new SignatureV4({
+            credentials: defaultProvider(),
+            region: this.region,
+            service: "appsync",
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        const auth = {
+            accept: "application/json, text/javascript",
+            "content-encoding": "amz-1.0",
+            "content-type": "application/json; charset=UTF-8",
+            host: httpUrl.hostname,
+            "x-amz-date": signedRequest.headers["x-amz-date"],
+            "x-amz-content-sha256": signedRequest.headers["x-amz-content-sha256"],
+            Authorization: signedRequest.headers["authorization"],
+        };
+        if (signedRequest.headers["x-amz-security-token"]) {
+            auth["x-amz-security-token"] =
+                signedRequest.headers["x-amz-security-token"];
+        }
+        return auth;
+    }
+    /**
+     * Build signed WebSocket connection info for AppSync Events
+     * Returns [url, subprotocols] for WebSocket constructor
+     */
+    async buildSignedWebSocketConnection() {
+        const realtimeUrl = new URL(this.realtimeEndpoint);
+        realtimeUrl.pathname = "/event/realtime";
+        const httpUrl = new URL(this.httpEndpoint);
+        // For IAM auth, sign a POST request to the HTTP endpoint
+        const request = new HttpRequest({
+            method: "POST",
+            protocol: "https:",
+            hostname: httpUrl.hostname,
+            path: "/event",
+            headers: {
+                accept: "application/json, text/javascript",
+                "content-encoding": "amz-1.0",
+                "content-type": "application/json; charset=UTF-8",
+                host: httpUrl.hostname,
+            },
+            body: "{}",
+        });
+        const signer = new SignatureV4({
+            credentials: defaultProvider(),
+            region: this.region,
+            service: "appsync",
+            sha256: Sha256,
+        });
+        const signedRequest = await signer.sign(request);
+        // Build header payload for subprotocol - include all signed headers
+        const headerPayload = {
+            accept: "application/json, text/javascript",
+            "content-encoding": "amz-1.0",
+            "content-type": "application/json; charset=UTF-8",
+            host: httpUrl.hostname,
+            "x-amz-date": signedRequest.headers["x-amz-date"],
+            "x-amz-content-sha256": signedRequest.headers["x-amz-content-sha256"],
+            Authorization: signedRequest.headers["authorization"],
+        };
+        // Add session token if present
+        if (signedRequest.headers["x-amz-security-token"]) {
+            headerPayload["x-amz-security-token"] =
+                signedRequest.headers["x-amz-security-token"];
+        }
+        // Base64url encode (no padding, URL-safe)
+        const encodedHeader = Buffer.from(JSON.stringify(headerPayload))
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+        // Auth is passed as header-{base64url} subprotocol
+        const authSubprotocol = `header-${encodedHeader}`;
+        return [realtimeUrl.toString(), ["aws-appsync-event-ws", authSubprotocol]];
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    async close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appsync-client.js","sourceRoot":"","sources":["../../../src/functions/bridge/appsync-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppSync Events client with AWS SigV4 signing.\n *\n * This client handles:\n * - HTTP requests to publish events (with IAM signing)\n * - WebSocket connections for real-time subscriptions (with IAM signing)\n */\n\nimport { Sha256 } from \"@aws-crypto/sha256-js\"\nimport { defaultProvider } from \"@aws-sdk/credential-provider-node\"\nimport { HttpRequest } from \"@aws-sdk/protocol-http\"\nimport { SignatureV4 } from \"@aws-sdk/signature-v4\"\nimport WebSocket from \"ws\"\n\nexport interface AppSyncEventsClientConfig {\n  httpEndpoint: string\n  realtimeEndpoint: string\n  region?: string\n}\n\nexport interface PublishAndWaitOptions<T> {\n  publishChannel: string\n  subscribeChannel: string\n  message: unknown\n  timeoutMs: number\n  matchResponse: (message: T) => boolean\n}\n\nexport interface SubscriptionOptions<T> {\n  channel: string\n  onMessage: (message: T) => void | Promise<void>\n  onError?: (error: Error) => void\n}\n\n/**\n * Client for AppSync Events API\n */\nexport class AppSyncEventsClient {\n  private readonly httpEndpoint: string\n  private readonly realtimeEndpoint: string\n  private readonly region: string\n  private ws: WebSocket | null = null\n\n  constructor(config: AppSyncEventsClientConfig) {\n    this.httpEndpoint = config.httpEndpoint\n    this.realtimeEndpoint = config.realtimeEndpoint\n    // Extract region from endpoint URL\n    // Format: https://{api-id}.appsync-api.{region}.amazonaws.com/event\n    const match = config.httpEndpoint.match(/\\.([a-z0-9-]+)\\.amazonaws\\.com/)\n    this.region =\n      config.region ?? match?.[1] ?? process.env.AWS_REGION ?? \"us-east-1\"\n  }\n\n  /**\n   * Publish a message to a channel and wait for a response on another channel.\n   */\n  async publishAndWaitForResponse<T>(\n    options: PublishAndWaitOptions<T>,\n  ): Promise<T> {\n    const {\n      publishChannel,\n      subscribeChannel,\n      message,\n      timeoutMs,\n      matchResponse,\n    } = options\n\n    return new Promise<T>((resolve, reject) => {\n      const timeoutId = setTimeout(() => {\n        this.close()\n        reject(new Error(`Timeout waiting for response after ${timeoutMs}ms`))\n      }, timeoutMs)\n\n      // Set up WebSocket connection first\n      this.connectAndSubscribe<T>(subscribeChannel, (receivedMessage) => {\n        if (matchResponse(receivedMessage)) {\n          clearTimeout(timeoutId)\n          resolve(receivedMessage)\n          return true // Signal to stop listening\n        }\n        return false\n      })\n        .then(() => {\n          // Once subscribed, publish the message\n          return this.publish(publishChannel, message)\n        })\n        .catch((err) => {\n          clearTimeout(timeoutId)\n          reject(err)\n        })\n    })\n  }\n\n  /**\n   * Publish a message to a channel via HTTP\n   */\n  async publish(channel: string, message: unknown): Promise<void> {\n    const url = new URL(this.httpEndpoint)\n    const body = JSON.stringify({\n      channel,\n      events: [JSON.stringify(message)],\n    })\n\n    // AppSync Events requires /event path for publishing\n    const path = url.pathname.endsWith(\"/event\") ? url.pathname : \"/event\"\n\n    const request = new HttpRequest({\n      method: \"POST\",\n      protocol: url.protocol,\n      hostname: url.hostname,\n      path,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        host: url.hostname,\n      },\n      body,\n    })\n\n    // Sign the request\n    const signer = new SignatureV4({\n      credentials: defaultProvider(),\n      region: this.region,\n      service: \"appsync\",\n      sha256: Sha256,\n    })\n\n    const signedRequest = await signer.sign(request)\n\n    // Make the HTTP request - use the correct endpoint with /event path\n    const publishUrl = `${url.protocol}//${url.hostname}${path}`\n    const response = await fetch(publishUrl, {\n      method: \"POST\",\n      headers: signedRequest.headers as Record<string, string>,\n      body,\n    })\n\n    if (!response.ok) {\n      const text = await response.text()\n      throw new Error(`Failed to publish event: ${response.status} ${text}`)\n    }\n  }\n\n  /**\n   * Subscribe to a channel and receive messages continuously.\n   * Returns an unsubscribe function.\n   */\n  async subscribe<T>(options: SubscriptionOptions<T>): Promise<() => void> {\n    const { channel, onMessage, onError } = options\n\n    await this.connectAndSubscribeContinuous<T>(channel, onMessage, onError)\n\n    return () => {\n      this.close()\n    }\n  }\n\n  /**\n   * Check if WebSocket is connected\n   */\n  isConnected(): boolean {\n    return this.ws !== null && this.ws.readyState === WebSocket.OPEN\n  }\n\n  /**\n   * Connect to WebSocket and subscribe to a channel\n   */\n  private async connectAndSubscribe<T>(\n    channel: string,\n    onMessage: (message: T) => boolean,\n  ): Promise<void> {\n    // Build signed WebSocket connection\n    const [wsUrl, subprotocols] = await this.buildSignedWebSocketConnection()\n\n    return new Promise((resolve, reject) => {\n      this.ws = new WebSocket(wsUrl, subprotocols)\n\n      this.ws.on(\"open\", () => {\n        console.log(\"[Bridge] WebSocket connected\")\n        // Send connection init\n        this.ws?.send(JSON.stringify({ type: \"connection_init\" }))\n      })\n\n      this.ws.on(\"message\", (data) => {\n        const message = JSON.parse(data.toString())\n\n        if (message.type === \"connection_ack\") {\n          console.log(\"[Bridge] Connection acknowledged\")\n          // Subscribe to channel with authorization\n          this.createSubscribeAuthorization(channel).then((auth) => {\n            this.ws?.send(\n              JSON.stringify({\n                type: \"subscribe\",\n                id: \"sub-1\",\n                channel,\n                authorization: auth,\n              }),\n            )\n          })\n        } else if (message.type === \"subscribe_success\") {\n          console.log(`[Bridge] Subscribed to ${channel}`)\n          resolve()\n        } else if (message.type === \"data\" && message.id === \"sub-1\") {\n          // Parse the event data\n          try {\n            const eventData = JSON.parse(message.event) as T\n            const shouldStop = onMessage(eventData)\n            if (shouldStop) {\n              this.close()\n            }\n          } catch (err) {\n            console.error(\"[Bridge] Failed to parse event data:\", err)\n          }\n        } else if (message.type === \"error\") {\n          console.error(\"[Bridge] WebSocket error:\", message)\n          reject(\n            new Error(\n              message.errors\n                ?.map((e: { message: string }) => e.message)\n                .join(\", \") ?? \"Unknown error\",\n            ),\n          )\n        }\n      })\n\n      this.ws.on(\"error\", (err) => {\n        console.error(\"[Bridge] WebSocket error:\", err)\n        reject(err)\n      })\n\n      this.ws.on(\"close\", () => {\n        console.log(\"[Bridge] WebSocket closed\")\n      })\n    })\n  }\n\n  /**\n   * Connect to WebSocket and subscribe to a channel with continuous message handling.\n   * Unlike connectAndSubscribe, this doesn't close after receiving a message.\n   */\n  private async connectAndSubscribeContinuous<T>(\n    channel: string,\n    onMessage: (message: T) => void | Promise<void>,\n    onError?: (error: Error) => void,\n  ): Promise<void> {\n    // Build signed WebSocket connection\n    const [wsUrl, subprotocols] = await this.buildSignedWebSocketConnection()\n\n    return new Promise((resolve, reject) => {\n      this.ws = new WebSocket(wsUrl, subprotocols)\n\n      this.ws.on(\"open\", () => {\n        console.log(\"[AppSync] WebSocket connected\")\n        // Send connection init\n        this.ws?.send(JSON.stringify({ type: \"connection_init\" }))\n      })\n\n      this.ws.on(\"message\", async (data) => {\n        const message = JSON.parse(data.toString())\n\n        if (message.type === \"connection_ack\") {\n          console.log(\"[AppSync] Connection acknowledged\")\n          // Subscribe to channel with authorization\n          this.createSubscribeAuthorization(channel).then((auth) => {\n            this.ws?.send(\n              JSON.stringify({\n                type: \"subscribe\",\n                id: \"sub-1\",\n                channel,\n                authorization: auth,\n              }),\n            )\n          })\n        } else if (message.type === \"subscribe_success\") {\n          console.log(`[AppSync] Subscribed to ${channel}`)\n          resolve()\n        } else if (message.type === \"data\" && message.id === \"sub-1\") {\n          // Parse the event data\n          try {\n            const eventData = JSON.parse(message.event) as T\n            await onMessage(eventData)\n          } catch (err) {\n            console.error(\"[AppSync] Failed to parse event data:\", err)\n            onError?.(err instanceof Error ? err : new Error(String(err)))\n          }\n        } else if (message.type === \"error\") {\n          console.error(\"[AppSync] WebSocket error:\", message)\n          const error = new Error(\n            message.errors\n              ?.map((e: { message: string }) => e.message)\n              .join(\", \") ?? \"Unknown error\",\n          )\n          onError?.(error)\n          reject(error)\n        }\n      })\n\n      this.ws.on(\"error\", (err) => {\n        console.error(\"[AppSync] WebSocket error:\", err)\n        onError?.(err)\n        reject(err)\n      })\n\n      this.ws.on(\"close\", () => {\n        console.log(\"[AppSync] WebSocket closed\")\n      })\n    })\n  }\n\n  /**\n   * Create authorization headers for subscribe operation\n   */\n  private async createSubscribeAuthorization(\n    channel: string,\n  ): Promise<Record<string, string>> {\n    const httpUrl = new URL(this.httpEndpoint)\n    const payload = JSON.stringify({ channel })\n\n    const request = new HttpRequest({\n      method: \"POST\",\n      protocol: \"https:\",\n      hostname: httpUrl.hostname,\n      path: \"/event\",\n      headers: {\n        accept: \"application/json, text/javascript\",\n        \"content-encoding\": \"amz-1.0\",\n        \"content-type\": \"application/json; charset=UTF-8\",\n        host: httpUrl.hostname,\n      },\n      body: payload,\n    })\n\n    const signer = new SignatureV4({\n      credentials: defaultProvider(),\n      region: this.region,\n      service: \"appsync\",\n      sha256: Sha256,\n    })\n\n    const signedRequest = await signer.sign(request)\n\n    const auth: Record<string, string> = {\n      accept: \"application/json, text/javascript\",\n      \"content-encoding\": \"amz-1.0\",\n      \"content-type\": \"application/json; charset=UTF-8\",\n      host: httpUrl.hostname,\n      \"x-amz-date\": signedRequest.headers[\"x-amz-date\"],\n      \"x-amz-content-sha256\": signedRequest.headers[\"x-amz-content-sha256\"],\n      Authorization: signedRequest.headers[\"authorization\"],\n    }\n\n    if (signedRequest.headers[\"x-amz-security-token\"]) {\n      auth[\"x-amz-security-token\"] =\n        signedRequest.headers[\"x-amz-security-token\"]\n    }\n\n    return auth\n  }\n\n  /**\n   * Build signed WebSocket connection info for AppSync Events\n   * Returns [url, subprotocols] for WebSocket constructor\n   */\n  private async buildSignedWebSocketConnection(): Promise<[string, string[]]> {\n    const realtimeUrl = new URL(this.realtimeEndpoint)\n    realtimeUrl.pathname = \"/event/realtime\"\n    const httpUrl = new URL(this.httpEndpoint)\n\n    // For IAM auth, sign a POST request to the HTTP endpoint\n    const request = new HttpRequest({\n      method: \"POST\",\n      protocol: \"https:\",\n      hostname: httpUrl.hostname,\n      path: \"/event\",\n      headers: {\n        accept: \"application/json, text/javascript\",\n        \"content-encoding\": \"amz-1.0\",\n        \"content-type\": \"application/json; charset=UTF-8\",\n        host: httpUrl.hostname,\n      },\n      body: \"{}\",\n    })\n\n    const signer = new SignatureV4({\n      credentials: defaultProvider(),\n      region: this.region,\n      service: \"appsync\",\n      sha256: Sha256,\n    })\n\n    const signedRequest = await signer.sign(request)\n\n    // Build header payload for subprotocol - include all signed headers\n    const headerPayload: Record<string, string> = {\n      accept: \"application/json, text/javascript\",\n      \"content-encoding\": \"amz-1.0\",\n      \"content-type\": \"application/json; charset=UTF-8\",\n      host: httpUrl.hostname,\n      \"x-amz-date\": signedRequest.headers[\"x-amz-date\"],\n      \"x-amz-content-sha256\": signedRequest.headers[\"x-amz-content-sha256\"],\n      Authorization: signedRequest.headers[\"authorization\"],\n    }\n\n    // Add session token if present\n    if (signedRequest.headers[\"x-amz-security-token\"]) {\n      headerPayload[\"x-amz-security-token\"] =\n        signedRequest.headers[\"x-amz-security-token\"]\n    }\n\n    // Base64url encode (no padding, URL-safe)\n    const encodedHeader = Buffer.from(JSON.stringify(headerPayload))\n      .toString(\"base64\")\n      .replace(/\\+/g, \"-\")\n      .replace(/\\//g, \"_\")\n      .replace(/=+$/, \"\")\n\n    // Auth is passed as header-{base64url} subprotocol\n    const authSubprotocol = `header-${encodedHeader}`\n\n    return [realtimeUrl.toString(), [\"aws-appsync-event-ws\", authSubprotocol]]\n  }\n\n  /**\n   * Close the WebSocket connection\n   */\n  async close(): Promise<void> {\n    if (this.ws) {\n      this.ws.close()\n      this.ws = null\n    }\n  }\n}\n"]}

package/lib/functions/bridge/handler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bridge Lambda handler that forwards invocations to the local daemon via AppSync Events.
+ *
+ * This handler:
+ * 1. Receives Lambda invocations from AWS
+ * 2. Publishes the invocation to AppSync Events channel
+ * 3. Subscribes to response channel
+ * 4. Waits for the daemon to process and respond
+ * 5. Returns the response or throws an error
+ *
+ * AppSync endpoints are read from SSM Parameter Store at runtime.
+ */
+import type { Context } from "aws-lambda";
+/**
+ * Main Lambda handler - forwards all invocations to the local daemon
+ */
+export declare function handler(event: unknown, context: Context): Promise<unknown>;

package/lib/functions/bridge/handler.js

@@ -0,0 +1,79 @@
+/**
+ * Bridge Lambda handler that forwards invocations to the local daemon via AppSync Events.
+ *
+ * This handler:
+ * 1. Receives Lambda invocations from AWS
+ * 2. Publishes the invocation to AppSync Events channel
+ * 3. Subscribes to response channel
+ * 4. Waits for the daemon to process and respond
+ * 5. Returns the response or throws an error
+ *
+ * AppSync endpoints are read from SSM Parameter Store at runtime.
+ */
+import { buildChannelName, filterEnvVars, } from "../../shared/types.js";
+import { AppSyncEventsClient } from "./appsync-client.js";
+import { getAppSyncEndpoints } from "./ssm-config.js";
+// Timeout waiting for daemon response (ms)
+const RESPONSE_TIMEOUT_MS = 290_000; // 4:50 to leave buffer for 5 min Lambda timeout
+/**
+ * Main Lambda handler - forwards all invocations to the local daemon
+ */
+export async function handler(event, context) {
+    const functionName = context.functionName;
+    const requestId = context.awsRequestId;
+    console.log(`[Bridge] Processing invocation for ${functionName}`);
+    console.log(`[Bridge] Request ID: ${requestId}`);
+    // Get AppSync endpoints from SSM
+    const { httpEndpoint, realtimeEndpoint } = await getAppSyncEndpoints();
+    // Create AppSync client
+    const client = new AppSyncEventsClient({
+        httpEndpoint,
+        realtimeEndpoint,
+    });
+    // Build channel names
+    const invocationChannel = buildChannelName.invocation(functionName);
+    const responseChannel = buildChannelName.response(functionName);
+    try {
+        // Create the invocation message with filtered env vars
+        const invocationMessage = {
+            type: "invocation",
+            requestId,
+            event,
+            context: {
+                functionName: context.functionName,
+                functionVersion: context.functionVersion,
+                invokedFunctionArn: context.invokedFunctionArn,
+                memoryLimitInMB: context.memoryLimitInMB,
+                awsRequestId: context.awsRequestId,
+                logGroupName: context.logGroupName,
+                logStreamName: context.logStreamName,
+                getRemainingTimeInMillis: context.getRemainingTimeInMillis(),
+            },
+            env: filterEnvVars(process.env),
+        };
+        // Subscribe to response channel first, then publish invocation
+        const response = await client.publishAndWaitForResponse({
+            publishChannel: invocationChannel,
+            subscribeChannel: responseChannel,
+            message: invocationMessage,
+            timeoutMs: RESPONSE_TIMEOUT_MS,
+            matchResponse: (msg) => msg.requestId === requestId,
+        });
+        console.log(`[Bridge] Received response for ${requestId}`);
+        // Check for error response
+        if (response.error) {
+            const error = new Error(response.error.errorMessage);
+            error.name = response.error.errorType;
+            if (response.error.stackTrace) {
+                error.stack = response.error.stackTrace.join("\n");
+            }
+            throw error;
+        }
+        return response.result;
+    }
+    finally {
+        // Clean up client connection
+        await client.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/functions/bridge/ssm-config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SSM parameter reader for AppSync endpoints.
+ *
+ * Reads the AppSync HTTP and realtime endpoints from SSM Parameter Store
+ * and caches them to avoid repeated SSM calls during Lambda warm starts.
+ */
+export interface AppSyncEndpoints {
+    httpEndpoint: string;
+    realtimeEndpoint: string;
+}
+/**
+ * Get AppSync endpoints from SSM Parameter Store.
+ * Results are cached after the first call.
+ */
+export declare function getAppSyncEndpoints(): Promise<AppSyncEndpoints>;
+/**
+ * Clear the cached endpoints. Useful for testing.
+ */
+export declare function clearEndpointCache(): void;

package/lib/functions/bridge/ssm-config.js

@@ -0,0 +1,45 @@
+/**
+ * SSM parameter reader for AppSync endpoints.
+ *
+ * Reads the AppSync HTTP and realtime endpoints from SSM Parameter Store
+ * and caches them to avoid repeated SSM calls during Lambda warm starts.
+ */
+import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+import { SSM_BASE_PATH } from "../../shared/types.js";
+// Cache endpoints to avoid repeated SSM calls
+let cachedEndpoints = null;
+/**
+ * Get AppSync endpoints from SSM Parameter Store.
+ * Results are cached after the first call.
+ */
+export async function getAppSyncEndpoints() {
+    if (cachedEndpoints)
+        return cachedEndpoints;
+    const client = new SSMClient({});
+    const qualifier = process.env.CDK_BOOTSTRAP_QUALIFIER ?? "hnb659fds";
+    const basePath = `${SSM_BASE_PATH}/${qualifier}`;
+    const [httpResponse, realtimeResponse] = await Promise.all([
+        client.send(new GetParameterCommand({
+            Name: `${basePath}/http-endpoint`,
+        })),
+        client.send(new GetParameterCommand({
+            Name: `${basePath}/realtime-endpoint`,
+        })),
+    ]);
+    if (!httpResponse.Parameter?.Value || !realtimeResponse.Parameter?.Value) {
+        throw new Error(`[LiveLambda] SSM parameters not found at ${basePath}. ` +
+            "Ensure the bootstrap stack is deployed.");
+    }
+    cachedEndpoints = {
+        httpEndpoint: httpResponse.Parameter.Value,
+        realtimeEndpoint: realtimeResponse.Parameter.Value,
+    };
+    return cachedEndpoints;
+}
+/**
+ * Clear the cached endpoints. Useful for testing.
+ */
+export function clearEndpointCache() {
+    cachedEndpoints = null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/functions/bridge-builder/handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { CloudFormationCustomResourceEvent, CloudFormationCustomResourceResponse } from "aws-lambda";
+export declare function handler(event: CloudFormationCustomResourceEvent): Promise<CloudFormationCustomResourceResponse>;