cdk-local-lambda 0.0.2

package/lib/cli/docker/watcher.js

@@ -0,0 +1,115 @@
+/**
+ * Docker context file watching for automatic container rebuilds.
+ *
+ * Watches Docker context directories and emits events when files change,
+ * triggering container rebuilds for Docker-based Lambda functions.
+ */
+import * as path from "node:path";
+import chokidar from "chokidar";
+import { Effect, Stream } from "effect";
+/**
+ * Default patterns to ignore when watching Docker contexts.
+ * These are common directories/files that shouldn't trigger rebuilds.
+ */
+const DEFAULT_IGNORED_PATTERNS = [
+    /(^|[/\\])\.git([/\\]|$)/, // .git directory
+    /(^|[/\\])node_modules([/\\]|$)/, // node_modules
+    /(^|[/\\])\.[^/\\]+$/, // dotfiles (but not directories like .docker)
+    /\.pyc$/, // Python bytecode
+    /__pycache__/, // Python cache
+    /\.class$/, // Java bytecode
+    /\.o$/, // Object files
+    /\.log$/, // Log files
+];
+/**
+ * Watch multiple Docker context directories for file changes.
+ *
+ * Creates a single chokidar watcher that monitors all registered Docker
+ * contexts and emits events when files change. The events are debounced
+ * to prevent rapid successive rebuilds during batch operations.
+ *
+ * @param functions - Array of Docker functions to watch
+ * @param debounceMs - Debounce delay in milliseconds (default: 500)
+ * @returns Stream of change events with function ownership resolved
+ */
+export const watchDockerContexts = (functions, debounceMs = 500) => {
+    if (functions.length === 0) {
+        return Stream.empty;
+    }
+    // Build a map of normalized context paths to function IDs for quick lookup
+    const contextToFunction = new Map();
+    const pathsToWatch = [];
+    for (const fn of functions) {
+        const normalizedPath = path.normalize(fn.dockerContextPath);
+        contextToFunction.set(normalizedPath, fn.functionId);
+        pathsToWatch.push(fn.dockerContextPath);
+    }
+    return Stream.asyncScoped((emit) => Effect.gen(function* () {
+        const watcher = chokidar.watch(pathsToWatch, {
+            ignored: DEFAULT_IGNORED_PATTERNS,
+            persistent: true,
+            ignoreInitial: true,
+            // Use polling on some systems for better reliability
+            usePolling: process.platform === "linux",
+            interval: 300,
+        });
+        /**
+         * Find which function owns a given file path.
+         */
+        const findOwningFunction = (filePath) => {
+            const normalizedFilePath = path.normalize(filePath);
+            for (const [contextPath, functionId] of contextToFunction) {
+                if (normalizedFilePath.startsWith(contextPath + path.sep)) {
+                    return functionId;
+                }
+                // Also match if the file IS the context directory (shouldn't happen but handle it)
+                if (normalizedFilePath === contextPath) {
+                    return functionId;
+                }
+            }
+            return undefined;
+        };
+        /**
+         * Handle a file change event.
+         */
+        const handleChange = (type, filePath) => {
+            const functionId = findOwningFunction(filePath);
+            if (functionId) {
+                emit.single({
+                    functionId,
+                    filePath,
+                    type,
+                });
+            }
+        };
+        watcher.on("add", (filePath) => handleChange("add", filePath));
+        watcher.on("change", (filePath) => handleChange("change", filePath));
+        watcher.on("unlink", (filePath) => handleChange("unlink", filePath));
+        watcher.on("error", (err) => {
+            const error = err;
+            Effect.runSync(Effect.logWarning(`DockerWatcher error: ${error.message}`));
+            // Don't fail the stream on transient errors, just log
+        });
+        watcher.on("ready", () => {
+            Effect.runSync(Effect.logDebug(`Watching ${functions.length} Docker context(s) for changes`));
+            for (const fn of functions) {
+                Effect.runSync(Effect.logDebug(`  - ${fn.functionId}: ${fn.dockerContextPath}`));
+            }
+        });
+        // Cleanup when scope closes
+        yield* Effect.addFinalizer(() => Effect.gen(function* () {
+            yield* Effect.promise(async () => {
+                await watcher.close();
+            });
+            yield* Effect.logDebug("DockerWatcher file watcher closed");
+        }));
+    })).pipe(
+    // Debounce to handle batch file changes (e.g., git checkout, IDE save-all)
+    Stream.debounce(`${debounceMs} millis`));
+};
+/**
+ * Create a watcher for a single Docker function.
+ * Convenience wrapper around watchDockerContexts for single-function use.
+ */
+export const watchSingleDockerContext = (functionId, dockerContextPath, debounceMs = 500) => watchDockerContexts([{ functionId, dockerContextPath }], debounceMs);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../../../src/cli/docker/watcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Docker context file watching for automatic container rebuilds.\n *\n * Watches Docker context directories and emits events when files change,\n * triggering container rebuilds for Docker-based Lambda functions.\n */\n\nimport * as path from \"node:path\"\nimport chokidar from \"chokidar\"\nimport { Effect, Stream } from \"effect\"\n\n/**\n * Event emitted when a file changes in a Docker context.\n */\nexport interface DockerContextChangeEvent {\n  /** The function ID that owns this Docker context */\n  functionId: string\n  /** The absolute path to the file that changed */\n  filePath: string\n  /** Type of change */\n  type: \"add\" | \"change\" | \"unlink\"\n}\n\n/**\n * Configuration for a Docker function to watch.\n */\nexport interface WatchedDockerFunction {\n  /** Unique function identifier (Lambda function name) */\n  functionId: string\n  /** Absolute path to the Docker context directory */\n  dockerContextPath: string\n}\n\n/**\n * Default patterns to ignore when watching Docker contexts.\n * These are common directories/files that shouldn't trigger rebuilds.\n */\nconst DEFAULT_IGNORED_PATTERNS = [\n  /(^|[/\\\\])\\.git([/\\\\]|$)/, // .git directory\n  /(^|[/\\\\])node_modules([/\\\\]|$)/, // node_modules\n  /(^|[/\\\\])\\.[^/\\\\]+$/, // dotfiles (but not directories like .docker)\n  /\\.pyc$/, // Python bytecode\n  /__pycache__/, // Python cache\n  /\\.class$/, // Java bytecode\n  /\\.o$/, // Object files\n  /\\.log$/, // Log files\n]\n\n/**\n * Watch multiple Docker context directories for file changes.\n *\n * Creates a single chokidar watcher that monitors all registered Docker\n * contexts and emits events when files change. The events are debounced\n * to prevent rapid successive rebuilds during batch operations.\n *\n * @param functions - Array of Docker functions to watch\n * @param debounceMs - Debounce delay in milliseconds (default: 500)\n * @returns Stream of change events with function ownership resolved\n */\nexport const watchDockerContexts = (\n  functions: WatchedDockerFunction[],\n  debounceMs = 500,\n): Stream.Stream<DockerContextChangeEvent, Error> => {\n  if (functions.length === 0) {\n    return Stream.empty\n  }\n\n  // Build a map of normalized context paths to function IDs for quick lookup\n  const contextToFunction = new Map<string, string>()\n  const pathsToWatch: string[] = []\n\n  for (const fn of functions) {\n    const normalizedPath = path.normalize(fn.dockerContextPath)\n    contextToFunction.set(normalizedPath, fn.functionId)\n    pathsToWatch.push(fn.dockerContextPath)\n  }\n\n  return Stream.asyncScoped<DockerContextChangeEvent, Error>((emit) =>\n    Effect.gen(function* () {\n      const watcher = chokidar.watch(pathsToWatch, {\n        ignored: DEFAULT_IGNORED_PATTERNS,\n        persistent: true,\n        ignoreInitial: true,\n        // Use polling on some systems for better reliability\n        usePolling: process.platform === \"linux\",\n        interval: 300,\n      })\n\n      /**\n       * Find which function owns a given file path.\n       */\n      const findOwningFunction = (filePath: string): string | undefined => {\n        const normalizedFilePath = path.normalize(filePath)\n\n        for (const [contextPath, functionId] of contextToFunction) {\n          if (normalizedFilePath.startsWith(contextPath + path.sep)) {\n            return functionId\n          }\n          // Also match if the file IS the context directory (shouldn't happen but handle it)\n          if (normalizedFilePath === contextPath) {\n            return functionId\n          }\n        }\n        return undefined\n      }\n\n      /**\n       * Handle a file change event.\n       */\n      const handleChange = (\n        type: \"add\" | \"change\" | \"unlink\",\n        filePath: string,\n      ) => {\n        const functionId = findOwningFunction(filePath)\n        if (functionId) {\n          emit.single({\n            functionId,\n            filePath,\n            type,\n          })\n        }\n      }\n\n      watcher.on(\"add\", (filePath) => handleChange(\"add\", filePath))\n      watcher.on(\"change\", (filePath) => handleChange(\"change\", filePath))\n      watcher.on(\"unlink\", (filePath) => handleChange(\"unlink\", filePath))\n\n      watcher.on(\"error\", (err) => {\n        const error = err as Error\n        Effect.runSync(\n          Effect.logWarning(`DockerWatcher error: ${error.message}`),\n        )\n        // Don't fail the stream on transient errors, just log\n      })\n\n      watcher.on(\"ready\", () => {\n        Effect.runSync(\n          Effect.logDebug(\n            `Watching ${functions.length} Docker context(s) for changes`,\n          ),\n        )\n        for (const fn of functions) {\n          Effect.runSync(\n            Effect.logDebug(`  - ${fn.functionId}: ${fn.dockerContextPath}`),\n          )\n        }\n      })\n\n      // Cleanup when scope closes\n      yield* Effect.addFinalizer(() =>\n        Effect.gen(function* () {\n          yield* Effect.promise(async () => {\n            await watcher.close()\n          })\n          yield* Effect.logDebug(\"DockerWatcher file watcher closed\")\n        }),\n      )\n    }),\n  ).pipe(\n    // Debounce to handle batch file changes (e.g., git checkout, IDE save-all)\n    Stream.debounce(`${debounceMs} millis`),\n  )\n}\n\n/**\n * Create a watcher for a single Docker function.\n * Convenience wrapper around watchDockerContexts for single-function use.\n */\nexport const watchSingleDockerContext = (\n  functionId: string,\n  dockerContextPath: string,\n  debounceMs = 500,\n): Stream.Stream<DockerContextChangeEvent, Error> =>\n  watchDockerContexts([{ functionId, dockerContextPath }], debounceMs)\n"]}

package/lib/cli/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+/**
+ * Effect CLI entry point for cdk-local-lambda.
+ *
+ * Commands:
+ * - bootstrap: Deploy the CdkLocalLambdaBootstrapStack
+ * - local: Run Lambda functions locally using Docker
+ */
+export {};

package/lib/cli/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+/**
+ * Effect CLI entry point for cdk-local-lambda.
+ *
+ * Commands:
+ * - bootstrap: Deploy the CdkLocalLambdaBootstrapStack
+ * - local: Run Lambda functions locally using Docker
+ */
+import { Command } from "@effect/cli";
+import { BunContext, BunRuntime } from "@effect/platform-bun";
+import { Effect } from "effect";
+import { bootstrapCommand } from "./commands/bootstrap.js";
+import { localCommand } from "./commands/local.js";
+/**
+ * Root command
+ */
+const rootCommand = Command.make("local-lambda", {}).pipe(Command.withSubcommands([bootstrapCommand, localCommand]), Command.withDescription("CLI for developing AWS Lambda functions locally"));
+/**
+ * Run the CLI
+ */
+const cli = Command.run(rootCommand, {
+    name: "local-lambda",
+    version: "0.1.0",
+});
+cli(process.argv).pipe(Effect.provide(BunContext.layer), BunRuntime.runMain);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/runtime-api/server.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Lambda Runtime API HTTP server using Effect HttpServer.
+ *
+ * This server emulates the AWS Lambda Runtime API that Docker containers
+ * use to receive invocations and send responses.
+ *
+ * Each Lambda function gets its own server on an ephemeral port. The server
+ * maintains a queue of pending invocations. When a container polls
+ * /invocation/next, it blocks until an invocation is available.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html
+ */
+import { Effect, HashMap, Queue, Ref, type Scope } from "effect";
+import type { ExtensionEvent, LambdaError, LambdaInitError, LambdaInvocation, LambdaResponse, RegisteredExtension } from "./types.js";
+/**
+ * State for a registered extension.
+ */
+interface ExtensionState {
+    /** Extension info */
+    extension: RegisteredExtension;
+    /** Queue of events for this extension */
+    eventQueue: Queue.Queue<ExtensionEvent>;
+}
+/**
+ * Function metadata for extension registration responses.
+ */
+export interface FunctionMetadata {
+    functionName: string;
+    functionVersion: string;
+    handler: string;
+}
+/**
+ * State for a Runtime API server session.
+ * Supports multiple invocations with a queue-based model.
+ */
+export interface RuntimeApiState {
+    /** Queue of pending invocations waiting to be fetched by the container */
+    invocationQueue: Queue.Queue<LambdaInvocation>;
+    /** Queue for responses/errors from the container */
+    responseQueue: Queue.Queue<LambdaResponse | LambdaError | LambdaInitError>;
+    /** Registered extensions by extension ID */
+    extensions: Ref.Ref<HashMap.HashMap<string, ExtensionState>>;
+    /** Function metadata for extension registration */
+    functionMetadata: FunctionMetadata;
+}
+/**
+ * Result from starting a Runtime API server.
+ */
+export interface RuntimeApiServer {
+    /** The actual port the server is listening on */
+    port: number;
+    /** The state containing the invocation and response queues */
+    state: RuntimeApiState;
+}
+/**
+ * Create a new Runtime API state (queues only, no port).
+ *
+ * @param functionMetadata - Function metadata for extension registration responses
+ */
+export declare const makeRuntimeApiState: (functionMetadata: FunctionMetadata) => Effect.Effect<{
+    invocationQueue: Queue.Queue<LambdaInvocation>;
+    responseQueue: Queue.Queue<LambdaResponse | LambdaError | LambdaInitError>;
+    extensions: Ref.Ref<HashMap.HashMap<string, ExtensionState>>;
+    functionMetadata: FunctionMetadata;
+}, never, never>;
+/**
+ * Options for starting a Runtime API server.
+ */
+export interface RuntimeApiServerOptions {
+    /** How long to wait for an invocation before returning 503 */
+    pollTimeoutMs?: number;
+    /** Function metadata for extension registration */
+    functionMetadata?: FunctionMetadata;
+}
+/**
+ * Start a Runtime API server on an ephemeral port.
+ * Returns the actual port and state for this server instance.
+ *
+ * The server is scoped - it will be stopped when the scope closes.
+ *
+ * @param options - Server configuration options
+ */
+export declare const startRuntimeApiServer: (options?: RuntimeApiServerOptions) => Effect.Effect<RuntimeApiServer, never, Scope.Scope>;
+/**
+ * Queue an invocation for the container to process.
+ */
+export declare const queueInvocation: (state: RuntimeApiState, invocation: LambdaInvocation) => Effect.Effect<void>;
+/**
+ * Wait for the response to a specific invocation.
+ */
+export declare const waitForResponse: (state: RuntimeApiState) => Effect.Effect<LambdaResponse | LambdaError | LambdaInitError>;
+/**
+ * Notify all registered extensions about an invocation.
+ * This sends an INVOKE event to all extensions that registered for it.
+ */
+export declare const notifyExtensionsInvoke: (state: RuntimeApiState, invocation: LambdaInvocation) => Effect.Effect<void>;
+/**
+ * Notify all registered extensions about shutdown.
+ * This sends a SHUTDOWN event to all extensions that registered for it.
+ */
+export declare const notifyExtensionsShutdown: (state: RuntimeApiState, reason?: "SPINDOWN" | "TIMEOUT" | "FAILURE") => Effect.Effect<void>;
+export {};