cdk-local-lambda 0.0.2

package/lib/cli/appsync/client.js

@@ -0,0 +1,227 @@
+/**
+ * Effect-based AppSync Events client for the daemon.
+ *
+ * Wraps the existing AppSync client with Effect primitives for better
+ * error handling and resource management.
+ */
+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 { Effect, Stream } from "effect";
+import WebSocket from "ws";
+/**
+ * Create an Effect-based AppSync Events client.
+ */
+export const makeAppSyncClient = (config) => {
+    // Extract region from endpoint URL
+    const match = config.httpEndpoint.match(/\.([a-z0-9-]+)\.amazonaws\.com/);
+    const region = config.region ?? match?.[1] ?? process.env.AWS_REGION ?? "us-east-1";
+    /**
+     * Sign a request with AWS SigV4.
+     */
+    const signRequest = (request) => Effect.tryPromise({
+        try: async () => {
+            const signer = new SignatureV4({
+                credentials: defaultProvider(),
+                region,
+                service: "appsync",
+                sha256: Sha256,
+            });
+            return await signer.sign(request);
+        },
+        catch: (error) => new Error(`Failed to sign request: ${String(error)}`),
+    });
+    /**
+     * Create authorization headers for subscribe operation.
+     */
+    const createSubscribeAuthorization = (channel) => Effect.gen(function* () {
+        const httpUrl = new URL(config.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 signedRequest = yield* signRequest(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.
+     */
+    const buildSignedWebSocketConnection = Effect.gen(function* () {
+        const realtimeUrl = new URL(config.realtimeEndpoint);
+        realtimeUrl.pathname = "/event/realtime";
+        const httpUrl = new URL(config.httpEndpoint);
+        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 signedRequest = yield* signRequest(request);
+        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"],
+        };
+        if (signedRequest.headers["x-amz-security-token"]) {
+            headerPayload["x-amz-security-token"] =
+                signedRequest.headers["x-amz-security-token"];
+        }
+        const encodedHeader = Buffer.from(JSON.stringify(headerPayload))
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+        const authSubprotocol = `header-${encodedHeader}`;
+        return {
+            url: realtimeUrl.toString(),
+            subprotocols: ["aws-appsync-event-ws", authSubprotocol],
+        };
+    });
+    /**
+     * Publish a message to a channel.
+     */
+    const publish = (channel, message) => Effect.gen(function* () {
+        const url = new URL(config.httpEndpoint);
+        const body = JSON.stringify({
+            channel,
+            events: [JSON.stringify(message)],
+        });
+        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,
+        });
+        const signedRequest = yield* signRequest(request);
+        const publishUrl = `${url.protocol}//${url.hostname}${path}`;
+        const response = yield* Effect.tryPromise({
+            try: async () => fetch(publishUrl, {
+                method: "POST",
+                headers: signedRequest.headers,
+                body,
+            }),
+            catch: (error) => new Error(`Failed to publish event: ${String(error)}`),
+        });
+        if (!response.ok) {
+            const text = yield* Effect.tryPromise({
+                try: () => response.text(),
+                catch: () => new Error("Failed to read response"),
+            });
+            yield* Effect.fail(new Error(`Failed to publish event: ${response.status} ${text}`));
+        }
+        yield* Effect.logDebug(`Published to ${channel}`);
+    });
+    /**
+     * Subscribe to a channel and receive messages as a Stream.
+     */
+    const subscribe = (channel) => Stream.asyncScoped((emit) => Effect.gen(function* () {
+        const { url, subprotocols } = yield* buildSignedWebSocketConnection;
+        yield* Effect.logDebug(`Connecting to ${url}`);
+        const ws = new WebSocket(url, [...subprotocols]);
+        ws.on("open", () => {
+            Effect.runSync(Effect.logDebug("WebSocket connected"));
+            ws.send(JSON.stringify({ type: "connection_init" }));
+        });
+        ws.on("message", async (data) => {
+            const message = JSON.parse(data.toString());
+            if (message.type === "connection_ack") {
+                Effect.runSync(Effect.logDebug("Connection acknowledged"));
+                const auth = await Effect.runPromise(createSubscribeAuthorization(channel));
+                ws.send(JSON.stringify({
+                    type: "subscribe",
+                    id: "sub-1",
+                    channel,
+                    authorization: auth,
+                }));
+            }
+            else if (message.type === "subscribe_success") {
+                Effect.runSync(Effect.logDebug(`Subscribed to ${channel}`));
+            }
+            else if (message.type === "data" && message.id === "sub-1") {
+                try {
+                    const eventData = JSON.parse(message.event);
+                    emit.single(eventData);
+                }
+                catch (err) {
+                    Effect.runSync(Effect.logError(`Failed to parse event data: ${err}`));
+                }
+            }
+            else if (message.type === "error") {
+                Effect.runSync(Effect.logError(`WebSocket error: ${JSON.stringify(message)}`));
+                emit.fail(new Error(message.errors
+                    ?.map((e) => e.message)
+                    .join(", ") ?? "Unknown error"));
+            }
+        });
+        ws.on("error", (err) => {
+            Effect.runSync(Effect.logError(`WebSocket error: ${err.message}`));
+            emit.fail(new Error(err.message));
+        });
+        ws.on("close", () => {
+            Effect.runSync(Effect.logDebug("WebSocket closed"));
+            emit.end();
+        });
+        // Cleanup when scope closes
+        yield* Effect.addFinalizer(() => Effect.gen(function* () {
+            yield* Effect.logDebug("Closing WebSocket");
+            ws.close();
+        }));
+    }));
+    /**
+     * Subscribe to invocations for a function.
+     */
+    const subscribeToInvocations = (channel) => subscribe(channel);
+    /**
+     * Publish a response to a channel.
+     */
+    const publishResponse = (channel, response) => publish(channel, response);
+    return {
+        publish,
+        subscribe,
+        subscribeToInvocations,
+        publishResponse,
+        createSubscribeAuthorization,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/cli/appsync/client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Effect-based AppSync Events client for the daemon.\n *\n * Wraps the existing AppSync client with Effect primitives for better\n * error handling and resource management.\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 { Effect, Stream } from \"effect\"\nimport WebSocket from \"ws\"\nimport type { InvocationMessage, ResponseMessage } from \"../../shared/types.js\"\n\n/**\n * Configuration for the Effect AppSync client.\n */\nexport interface AppSyncClientConfig {\n  httpEndpoint: string\n  realtimeEndpoint: string\n  region?: string\n}\n\n/**\n * Create an Effect-based AppSync Events client.\n */\nexport const makeAppSyncClient = (config: AppSyncClientConfig) => {\n  // Extract region from endpoint URL\n  const match = config.httpEndpoint.match(/\\.([a-z0-9-]+)\\.amazonaws\\.com/)\n  const region =\n    config.region ?? match?.[1] ?? process.env.AWS_REGION ?? \"us-east-1\"\n\n  /**\n   * Sign a request with AWS SigV4.\n   */\n  const signRequest = (request: HttpRequest) =>\n    Effect.tryPromise({\n      try: async () => {\n        const signer = new SignatureV4({\n          credentials: defaultProvider(),\n          region,\n          service: \"appsync\",\n          sha256: Sha256,\n        })\n        return await signer.sign(request)\n      },\n      catch: (error) => new Error(`Failed to sign request: ${String(error)}`),\n    })\n\n  /**\n   * Create authorization headers for subscribe operation.\n   */\n  const createSubscribeAuthorization = (channel: string) =>\n    Effect.gen(function* () {\n      const httpUrl = new URL(config.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 signedRequest = yield* signRequest(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.\n   */\n  const buildSignedWebSocketConnection = Effect.gen(function* () {\n    const realtimeUrl = new URL(config.realtimeEndpoint)\n    realtimeUrl.pathname = \"/event/realtime\"\n    const httpUrl = new URL(config.httpEndpoint)\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: \"{}\",\n    })\n\n    const signedRequest = yield* signRequest(request)\n\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    if (signedRequest.headers[\"x-amz-security-token\"]) {\n      headerPayload[\"x-amz-security-token\"] =\n        signedRequest.headers[\"x-amz-security-token\"]\n    }\n\n    const encodedHeader = Buffer.from(JSON.stringify(headerPayload))\n      .toString(\"base64\")\n      .replace(/\\+/g, \"-\")\n      .replace(/\\//g, \"_\")\n      .replace(/=+$/, \"\")\n\n    const authSubprotocol = `header-${encodedHeader}`\n\n    return {\n      url: realtimeUrl.toString(),\n      subprotocols: [\"aws-appsync-event-ws\", authSubprotocol] as const,\n    }\n  })\n\n  /**\n   * Publish a message to a channel.\n   */\n  const publish = (channel: string, message: unknown) =>\n    Effect.gen(function* () {\n      const url = new URL(config.httpEndpoint)\n      const body = JSON.stringify({\n        channel,\n        events: [JSON.stringify(message)],\n      })\n\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      const signedRequest = yield* signRequest(request)\n\n      const publishUrl = `${url.protocol}//${url.hostname}${path}`\n      const response = yield* Effect.tryPromise({\n        try: async () =>\n          fetch(publishUrl, {\n            method: \"POST\",\n            headers: signedRequest.headers as Record<string, string>,\n            body,\n          }),\n        catch: (error) =>\n          new Error(`Failed to publish event: ${String(error)}`),\n      })\n\n      if (!response.ok) {\n        const text = yield* Effect.tryPromise({\n          try: () => response.text(),\n          catch: () => new Error(\"Failed to read response\"),\n        })\n        yield* Effect.fail(\n          new Error(`Failed to publish event: ${response.status} ${text}`),\n        )\n      }\n\n      yield* Effect.logDebug(`Published to ${channel}`)\n    })\n\n  /**\n   * Subscribe to a channel and receive messages as a Stream.\n   */\n  const subscribe = <T>(channel: string) =>\n    Stream.asyncScoped<T, Error>((emit) =>\n      Effect.gen(function* () {\n        const { url, subprotocols } = yield* buildSignedWebSocketConnection\n\n        yield* Effect.logDebug(`Connecting to ${url}`)\n\n        const ws = new WebSocket(url, [...subprotocols])\n        ws.on(\"open\", () => {\n          Effect.runSync(Effect.logDebug(\"WebSocket connected\"))\n          ws.send(JSON.stringify({ type: \"connection_init\" }))\n        })\n\n        ws.on(\"message\", async (data) => {\n          const message = JSON.parse(data.toString())\n\n          if (message.type === \"connection_ack\") {\n            Effect.runSync(Effect.logDebug(\"Connection acknowledged\"))\n            const auth = await Effect.runPromise(\n              createSubscribeAuthorization(channel),\n            )\n            ws.send(\n              JSON.stringify({\n                type: \"subscribe\",\n                id: \"sub-1\",\n                channel,\n                authorization: auth,\n              }),\n            )\n          } else if (message.type === \"subscribe_success\") {\n            Effect.runSync(Effect.logDebug(`Subscribed to ${channel}`))\n          } else if (message.type === \"data\" && message.id === \"sub-1\") {\n            try {\n              const eventData = JSON.parse(message.event) as T\n              emit.single(eventData)\n            } catch (err) {\n              Effect.runSync(\n                Effect.logError(`Failed to parse event data: ${err}`),\n              )\n            }\n          } else if (message.type === \"error\") {\n            Effect.runSync(\n              Effect.logError(`WebSocket error: ${JSON.stringify(message)}`),\n            )\n            emit.fail(\n              new Error(\n                message.errors\n                  ?.map((e: { message: string }) => e.message)\n                  .join(\", \") ?? \"Unknown error\",\n              ),\n            )\n          }\n        })\n\n        ws.on(\"error\", (err) => {\n          Effect.runSync(Effect.logError(`WebSocket error: ${err.message}`))\n          emit.fail(new Error(err.message))\n        })\n\n        ws.on(\"close\", () => {\n          Effect.runSync(Effect.logDebug(\"WebSocket closed\"))\n          emit.end()\n        })\n\n        // Cleanup when scope closes\n        yield* Effect.addFinalizer(() =>\n          Effect.gen(function* () {\n            yield* Effect.logDebug(\"Closing WebSocket\")\n            ws.close()\n          }),\n        )\n      }),\n    )\n\n  /**\n   * Subscribe to invocations for a function.\n   */\n  const subscribeToInvocations = (channel: string) =>\n    subscribe<InvocationMessage>(channel)\n\n  /**\n   * Publish a response to a channel.\n   */\n  const publishResponse = (channel: string, response: ResponseMessage) =>\n    publish(channel, response)\n\n  return {\n    publish,\n    subscribe,\n    subscribeToInvocations,\n    publishResponse,\n    createSubscribeAuthorization,\n  }\n}\n\n/**\n * Type for the AppSync client.\n */\nexport type AppSyncClient = ReturnType<typeof makeAppSyncClient>\n"]}

package/lib/cli/cdk-app.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+/**
+ * CDK app entry point for bootstrap deployment.
+ *
+ * This file is used by CDK CLI to deploy the CdkLocalLambdaBootstrapStack.
+ */
+export {};

package/lib/cli/cdk-app.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+/**
+ * CDK app entry point for bootstrap deployment.
+ *
+ * This file is used by CDK CLI to deploy the CdkLocalLambdaBootstrapStack.
+ */
+import * as cdk from "aws-cdk-lib";
+import { CdkLocalLambdaBootstrapStack } from "../bootstrap-stack/bootstrap-stack.js";
+const app = new cdk.App();
+// Get account and region from environment
+const account = process.env.CDK_DEFAULT_ACCOUNT || process.env.AWS_ACCOUNT_ID;
+const region = process.env.CDK_DEFAULT_REGION ||
+    process.env.AWS_REGION ||
+    process.env.AWS_DEFAULT_REGION;
+if (!account || !region) {
+    console.error("Error: AWS account and region must be configured.");
+    console.error("Set CDK_DEFAULT_ACCOUNT and CDK_DEFAULT_REGION, or use AWS CLI profile.");
+    console.error(`Current: account=${account}, region=${region}`);
+    process.exit(1);
+}
+new CdkLocalLambdaBootstrapStack(app, "CdkLocalLambdaBootstrapStack", {
+    env: { account, region },
+});
+app.synth();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/commands/bootstrap.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@effect/cli";
+import { Option } from "effect";
+/**
+ * Bootstrap command - deploys the CdkLocalLambdaBootstrapStack
+ */
+export declare const bootstrapCommand: Command.Command<"bootstrap", never, Error, {
+    readonly profile: Option.Option<string>;
+    readonly region: Option.Option<string>;
+}>;

package/lib/cli/commands/bootstrap.js

@@ -0,0 +1,50 @@
+import { execSync } from "node:child_process";
+import { Command, Options } from "@effect/cli";
+import { Console, Effect, Option } from "effect";
+import { BOOTSTRAP_STACK_NAME } from "../../shared/types.js";
+// Common options
+const profileOption = Options.text("profile").pipe(Options.optional, Options.withDescription("AWS profile to use"));
+const regionOption = Options.text("region").pipe(Options.optional, Options.withDescription("AWS region to deploy to"));
+/**
+ * Bootstrap command - deploys the CdkLocalLambdaBootstrapStack
+ */
+export const bootstrapCommand = Command.make("bootstrap", { profile: profileOption, region: regionOption }, ({ profile, region }) => Effect.gen(function* () {
+    yield* Console.log("Deploying bootstrap stack...");
+    // Build CDK deploy command with options
+    const args = [
+        "npx",
+        "cdk",
+        "deploy",
+        BOOTSTRAP_STACK_NAME,
+        "--require-approval",
+        "never",
+    ];
+    if (Option.isSome(profile)) {
+        args.push("--profile", profile.value);
+    }
+    // Build environment with optional region
+    const env = { ...process.env };
+    if (Option.isSome(region)) {
+        env.AWS_REGION = region.value;
+        env.CDK_DEFAULT_REGION = region.value;
+    }
+    const command = args.join(" ");
+    yield* Console.log(`Running: ${command}`);
+    // Execute CDK deploy synchronously so output is streamed
+    yield* Effect.try({
+        try: () => {
+            execSync(command, {
+                stdio: "inherit",
+                env,
+            });
+        },
+        catch: (error) => {
+            if (error instanceof Error) {
+                return new Error(`CDK deploy failed: ${error.message}`);
+            }
+            return new Error("CDK deploy failed with unknown error");
+        },
+    });
+    yield* Console.log("Bootstrap stack deployed successfully!");
+})).pipe(Command.withDescription("Deploy the Live Lambda bootstrap stack to AWS"));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/commands/local.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Local command for running Lambda functions locally using Docker.
+ *
+ * This command:
+ * 1. Starts CDK watch with CDK_LIVE=true and hotswap
+ * 2. Discovers Lambda functions with live-lambda:handler tag
+ * 3. Connects to AppSync Events
+ * 4. Subscribes to invocation channels
+ * 5. For each function, maintains ONE Docker container that handles all invocations
+ * 6. Sends responses back via AppSync
+ * 7. Re-discovers functions after each CDK deploy
+ */
+import { Command } from "@effect/cli";
+import { type CommandExecutor } from "@effect/platform";
+/**
+ * Invocation context for tracking and logging.
+ */
+export interface InvocationContext {
+    /** Sequential invocation number */
+    num: number;
+    /** Start timestamp in milliseconds */
+    start: number;
+    /** Function name */
+    fn: string;
+    /** Whether this is a Docker container invocation */
+    isDocker: boolean;
+}
+/**
+ * Local command definition.
+ */
+export declare const localCommand: Command.Command<"local", CommandExecutor.CommandExecutor, Error | import("@effect/platform/Error").PlatformError, {
+    readonly profile: import("effect/Option").Option<string>;
+    readonly region: import("effect/Option").Option<string>;
+    readonly qualifier: string;
+    readonly stacks: import("effect/Option").Option<string>;
+    readonly all: boolean;
+    readonly debug: boolean;
+    readonly idleTimeout: number;
+    readonly pollTimeout: import("effect/Option").Option<number>;
+}>;