cdk-local-lambda 0.0.2

package/lib/cli/docker/container.js

@@ -0,0 +1,414 @@
+/**
+ * Docker container management utilities.
+ *
+ * Handles running Docker containers with the Lambda Runtime API
+ * environment configured. Uses @effect/platform Command for
+ * proper Effect-based process management.
+ */
+import * as os from "node:os";
+import { CommandExecutor, Command as PlatformCommand } from "@effect/platform";
+import { Context, Effect, Layer, Stream } from "effect";
+/**
+ * Detect the Docker runtime environment.
+ */
+export const detectDockerRuntime = () => Effect.try({
+    try: () => {
+        const platform = os.platform();
+        const isLinux = platform === "linux";
+        const isWsl = isLinux &&
+            (process.env.WSL_DISTRO_NAME !== undefined ||
+                process.env.WSL_INTEROP !== undefined);
+        // On Mac/Windows Docker Desktop, use host.docker.internal
+        // On Linux, we need to use the host's IP or --network=host
+        const isDockerDesktop = !isLinux || isWsl;
+        const hostAddress = isDockerDesktop
+            ? "host.docker.internal"
+            : "172.17.0.1"; // Default Docker bridge gateway
+        return {
+            dockerPath: "docker",
+            isLinux,
+            isWsl,
+            isDockerDesktop,
+            hostAddress,
+        };
+    },
+    catch: (error) => new Error(`Failed to detect Docker runtime: ${String(error)}`),
+});
+/**
+ * Build Docker run arguments from config.
+ */
+const buildDockerRunArgs = (config, runtime) => {
+    const args = ["run", "--rm"];
+    // Container name (add timestamp for uniqueness)
+    if (config.containerName) {
+        args.push("--name", `${config.containerName}-${Date.now()}`);
+    }
+    // Platform - allow running ARM64 images on x86_64 via QEMU
+    if (config.platform) {
+        args.push("--platform", config.platform);
+    }
+    // Memory limit
+    args.push("--memory", `${config.memoryMB}m`);
+    // Network mode
+    if (config.networkMode === "host") {
+        args.push("--network", "host");
+    }
+    else if (config.networkMode !== "none") {
+        // For bridge mode, add host mapping for non-Linux
+        if (runtime.isDockerDesktop) {
+            // host.docker.internal is automatically available on Docker Desktop
+        }
+        else {
+            // On Linux, add explicit host mapping and helper address
+            args.push("--add-host", `host.docker.internal:${runtime.hostAddress}`);
+            args.push("--add-host", `host.containers.internal:${runtime.hostAddress}`);
+            args.push("--add-host", `runtime.api:${runtime.hostAddress}`);
+        }
+    }
+    // Extra hosts
+    if (config.extraHosts) {
+        for (const host of config.extraHosts) {
+            args.push("--add-host", host);
+        }
+    }
+    // Environment variables
+    for (const [key, value] of Object.entries(config.environment)) {
+        args.push("-e", `${key}=${value}`);
+    }
+    // Working directory
+    if (config.workdir) {
+        args.push("-w", config.workdir);
+    }
+    // Additional arguments
+    if (config.additionalArgs) {
+        args.push(...config.additionalArgs);
+    }
+    // Entrypoint override
+    if (config.entrypoint && config.entrypoint.length > 0) {
+        args.push("--entrypoint", config.entrypoint[0]);
+    }
+    // Image
+    args.push(config.imageUri);
+    // Entrypoint additional args (after image)
+    if (config.entrypoint && config.entrypoint.length > 1) {
+        args.push(...config.entrypoint.slice(1));
+    }
+    // Command override (after image and entrypoint args)
+    if (config.command) {
+        args.push(...config.command);
+    }
+    return args;
+};
+/**
+ * Docker Service tag for dependency injection.
+ */
+export class Docker extends Context.Tag("Docker")() {
+}
+/**
+ * Create the live Docker service implementation.
+ */
+const makeDockerService = Effect.gen(function* () {
+    const runtime = yield* detectDockerRuntime();
+    const getRuntimeInfo = () => Effect.succeed(runtime);
+    const run = (config) => Effect.gen(function* () {
+        const args = buildDockerRunArgs(config, runtime);
+        yield* Effect.logDebug(`Running: docker ${args.join(" ")}`);
+        const command = PlatformCommand.make(runtime.dockerPath, ...args);
+        const stdout = [];
+        const stderr = [];
+        // Run the command and collect output
+        const proc = yield* PlatformCommand.start(command);
+        // Lambda RIC error/output patterns that are expected during poll timeout
+        // These are suppressed from output to avoid scary error messages
+        const isExpectedRicOutput = (line) => line.includes("LAMBDA_RUNTIME Failed to get next invocation") ||
+            line.includes("Failed to get next invocation, error 503") ||
+            // Filter out the Node.js stack trace from Lambda RIC exit
+            line.includes("triggerUncaughtException") ||
+            line.includes("[Error: Failed to get next invocation") ||
+            // "Node.js v" version line after error
+            line.startsWith("Node.js v") ||
+            line.includes("node:internal/process/promises") ||
+            // Stack trace caret line (just whitespace and ^)
+            /^\s*\^?\s*$/.test(line);
+        // Pattern to parse Lambda log format: TIMESTAMP\tREQUEST_ID\tLEVEL\tMESSAGE
+        // Lambda uses tabs between fields. Captures: [1] = request ID, [2] = level + message
+        const lambdaLogPattern = /^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)[\t\s]+([0-9a-f-]{36})[\t\s]+(.*)$/i;
+        // Helper to format log line with invocation prefix
+        const formatLine = (rawLine) => {
+            // Strip carriage returns that can cause terminal corruption
+            const line = rawLine.replace(/\r/g, "");
+            const match = lambdaLogPattern.exec(line);
+            if (match && config.invocationContexts) {
+                const requestId = match[2];
+                const ctx = config.invocationContexts.get(requestId);
+                if (ctx) {
+                    // Strip timestamp and request ID, keep just LEVEL MESSAGE
+                    return { prefix: `[${ctx.num}]`, content: match[3] };
+                }
+            }
+            return { prefix: "[Container]", content: line };
+        };
+        // Process stdout - filter expected errors, forward the rest
+        const stdoutFiber = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((rawLine) => Effect.sync(() => {
+            stdout.push(rawLine);
+            // Suppress expected RIC output (poll timeout errors)
+            if (!isExpectedRicOutput(rawLine)) {
+                const { prefix, content } = formatLine(rawLine);
+                process.stdout.write(`${prefix} ${content}\n`);
+            }
+        })), Effect.fork);
+        // Process stderr - filter expected errors, forward the rest
+        const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((rawLine) => Effect.sync(() => {
+            stderr.push(rawLine);
+            // Suppress expected RIC output (poll timeout errors)
+            if (!isExpectedRicOutput(rawLine)) {
+                const { prefix, content } = formatLine(rawLine);
+                process.stderr.write(`${prefix} ${content}\n`);
+            }
+        })), Effect.fork);
+        // Wait for both streams and exit code
+        yield* Effect.all([
+            Effect.fromFiber(stdoutFiber),
+            Effect.fromFiber(stderrFiber),
+        ]);
+        const exitCode = yield* proc.exitCode;
+        // Only suppress warnings for expected exit codes:
+        // - 0: Clean exit
+        // - 1: Lambda RIC exit after 503 poll timeout (expected)
+        // - 143 (128+15): SIGTERM from docker stop
+        // - 137 (128+9): SIGKILL from docker stop timeout
+        const expectedExitCodes = [0, 1, 143, 137];
+        if (!expectedExitCodes.includes(exitCode)) {
+            yield* Effect.logWarning(`Container exited with code ${exitCode}`);
+        }
+        else if (exitCode !== 0) {
+            yield* Effect.logDebug(`Container exited with code ${exitCode}`);
+        }
+        return {
+            exitCode,
+            stdout: stdout.join("\n"),
+            stderr: stderr.join("\n"),
+        };
+    });
+    const runScoped = (config) => Effect.gen(function* () {
+        const args = buildDockerRunArgs(config, runtime);
+        yield* Effect.logInfo(`Running (scoped): docker ${args.join(" ")}`);
+        const command = PlatformCommand.make(runtime.dockerPath, ...args);
+        const proc = yield* PlatformCommand.start(command);
+        // Fork output processing in background (will be interrupted when scope closes)
+        yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => {
+            process.stdout.write(`[Container] ${line}\n`);
+        })), Effect.fork);
+        yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => {
+            process.stderr.write(`[Container] ${line}\n`);
+        })), Effect.fork);
+        return proc;
+    });
+    const build = (options) => Effect.gen(function* () {
+        const args = [
+            "build",
+            "-t",
+            options.imageName,
+            "--platform",
+            options.platform ?? "linux/arm64",
+            options.contextPath,
+        ];
+        yield* Effect.logInfo(`Building image: ${options.imageName}`);
+        yield* Effect.logDebug(`Context: ${options.contextPath}`);
+        const command = PlatformCommand.make(runtime.dockerPath, ...args);
+        const proc = yield* PlatformCommand.start(command);
+        // Process stdout (debug only)
+        const stdoutFiber = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)), Effect.fork);
+        // Process stderr (debug only)
+        const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)), Effect.fork);
+        // Wait for streams and exit code
+        yield* Effect.all([
+            Effect.fromFiber(stdoutFiber),
+            Effect.fromFiber(stderrFiber),
+        ]);
+        const exitCode = yield* proc.exitCode;
+        if (exitCode !== 0) {
+            return yield* Effect.fail(new Error(`Docker build failed with code ${exitCode}`));
+        }
+        yield* Effect.logInfo(`Built image: ${options.imageName}`);
+    });
+    const pull = (imageUri) => Effect.gen(function* () {
+        yield* Effect.logInfo(`Pulling image: ${imageUri}`);
+        const command = PlatformCommand.make(runtime.dockerPath, "pull", imageUri);
+        const proc = yield* PlatformCommand.start(command);
+        // Process stdout (debug only)
+        const stdoutFiber = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)), Effect.fork);
+        // Process stderr (debug only)
+        const stderrFiber = yield* proc.stderr.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)), Effect.fork);
+        // Wait for streams and exit code
+        yield* Effect.all([
+            Effect.fromFiber(stdoutFiber),
+            Effect.fromFiber(stderrFiber),
+        ]);
+        const exitCode = yield* proc.exitCode;
+        if (exitCode !== 0) {
+            return yield* Effect.fail(new Error(`Docker pull failed with code ${exitCode}`));
+        }
+        yield* Effect.logInfo(`Pulled image: ${imageUri}`);
+    });
+    const list = (containerNameFilter) => Effect.gen(function* () {
+        const command = PlatformCommand.make(runtime.dockerPath, "ps", "-q", "--filter", `name=${containerNameFilter}`);
+        const proc = yield* PlatformCommand.start(command);
+        // Collect stdout
+        const containerIds = [];
+        yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.sync(() => {
+            const trimmed = line.trim();
+            if (trimmed) {
+                containerIds.push(trimmed);
+            }
+        })));
+        const exitCode = yield* proc.exitCode;
+        if (exitCode !== 0) {
+            return yield* Effect.fail(new Error(`Docker ps failed with code ${exitCode}`));
+        }
+        return containerIds;
+    });
+    const stop = (containerNameFilter, timeoutSeconds) => Effect.gen(function* () {
+        // First list matching containers
+        const containerIds = yield* list(containerNameFilter);
+        if (containerIds.length === 0) {
+            yield* Effect.logDebug(`No containers found matching: ${containerNameFilter}`);
+            return 0;
+        }
+        yield* Effect.logInfo(`Stopping containers: ${containerIds.join(", ")}`);
+        // Build stop command with optional timeout
+        // -t 0 sends SIGKILL immediately, useful for fast restarts
+        const timeoutArg = timeoutSeconds !== undefined ? ["-t", String(timeoutSeconds)] : [];
+        const command = PlatformCommand.make(runtime.dockerPath, "stop", ...timeoutArg, ...containerIds);
+        const proc = yield* PlatformCommand.start(command);
+        // Process output for logging
+        yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.runForEach((line) => Effect.logDebug(`[Docker stop] ${line.trim()}`)));
+        const exitCode = yield* proc.exitCode;
+        if (exitCode !== 0) {
+            yield* Effect.logWarning(`Docker stop exited with code ${exitCode} (some containers may have already stopped)`);
+        }
+        return containerIds.length;
+    });
+    const inspect = (imageUri) => Effect.gen(function* () {
+        const executor = yield* CommandExecutor.CommandExecutor;
+        // Get entrypoint
+        const entrypointCmd = PlatformCommand.make(runtime.dockerPath, "inspect", "--format", "{{json .Config.Entrypoint}}", imageUri);
+        const entrypointProc = yield* executor.start(entrypointCmd);
+        const entrypointOutput = yield* Stream.runCollect(Stream.decodeText(entrypointProc.stdout));
+        const entrypointExitCode = yield* entrypointProc.exitCode;
+        if (entrypointExitCode !== 0) {
+            yield* Effect.fail(new Error(`Failed to inspect image entrypoint: ${imageUri}`));
+        }
+        const entrypointJson = Array.from(entrypointOutput).join("").trim();
+        // Get cmd
+        const cmdCmd = PlatformCommand.make(runtime.dockerPath, "inspect", "--format", "{{json .Config.Cmd}}", imageUri);
+        const cmdProc = yield* executor.start(cmdCmd);
+        const cmdOutput = yield* Stream.runCollect(Stream.decodeText(cmdProc.stdout));
+        const cmdExitCode = yield* cmdProc.exitCode;
+        if (cmdExitCode !== 0) {
+            yield* Effect.fail(new Error(`Failed to inspect image cmd: ${imageUri}`));
+        }
+        const cmdJson = Array.from(cmdOutput).join("").trim();
+        // Parse JSON - null is valid, so handle that
+        const parseJsonArray = (json) => {
+            if (json === "null" || json === "")
+                return null;
+            try {
+                const parsed = JSON.parse(json);
+                return Array.isArray(parsed) ? parsed : null;
+            }
+            catch {
+                return null;
+            }
+        };
+        return {
+            entrypoint: parseJsonArray(entrypointJson),
+            cmd: parseJsonArray(cmdJson),
+        };
+    });
+    return {
+        run,
+        runScoped,
+        build,
+        pull,
+        stop,
+        list,
+        getRuntimeInfo,
+        inspect,
+    };
+});
+/**
+ * Live Docker service layer.
+ * Note: Does not require CommandExecutor in the layer - it's required
+ * when the service methods are called.
+ */
+export const DockerLive = Layer.effect(Docker, makeDockerService);
+/**
+ * Create a container config for running a Lambda container.
+ */
+export const makeLambdaContainerConfig = (options) => ({
+    imageUri: options.imageUri,
+    containerName: `lambda-${options.functionName.replace(/[^a-zA-Z0-9]/g, "-")}`,
+    platform: options.platform,
+    environment: {
+        AWS_LAMBDA_RUNTIME_API: `${options.runtimeApiHost}:${options.runtimeApiPort}`,
+        AWS_LAMBDA_FUNCTION_NAME: options.functionName,
+        AWS_LAMBDA_FUNCTION_VERSION: options.functionVersion,
+        AWS_LAMBDA_FUNCTION_MEMORY_SIZE: String(options.memoryMB),
+        AWS_REGION: options.awsRegion ?? "us-east-1",
+        AWS_DEFAULT_REGION: options.awsRegion ?? "us-east-1",
+        AWS_LAMBDA_LOG_GROUP_NAME: `/aws/lambda/${options.functionName}`,
+        AWS_LAMBDA_LOG_STREAM_NAME: "local",
+        _HANDLER: options.handler ?? "index.handler",
+        ...options.additionalEnv,
+    },
+    memoryMB: options.memoryMB,
+    timeoutSeconds: options.timeoutSeconds,
+    networkMode: "bridge",
+    invocationContexts: options.invocationContexts,
+});
+/**
+ * Shell-quote a string for safe inclusion in a shell command.
+ * Uses single quotes and escapes any embedded single quotes.
+ */
+const shellQuote = (s) => {
+    // Single quotes are safest - escape any embedded single quotes
+    return `'${s.replace(/'/g, "'\\''")}'`;
+};
+/**
+ * Build a wrapper command that starts Lambda extensions before the main app.
+ *
+ * This mimics AWS Lambda's behavior of automatically starting all executables
+ * in /opt/extensions/ as background processes before running the main command.
+ *
+ * @param originalEntrypoint - The image's original ENTRYPOINT
+ * @param originalCmd - The image's original CMD
+ * @returns Entrypoint and command arrays to pass to Docker
+ */
+export const buildExtensionWrapperCommand = (originalEntrypoint, originalCmd) => {
+    // Combine original entrypoint + cmd into the full command
+    // Docker behavior: ENTRYPOINT + CMD are concatenated
+    const originalCommand = [
+        ...(originalEntrypoint ?? []),
+        ...(originalCmd ?? []),
+    ];
+    // Script to start all executable files in /opt/extensions/ as background processes
+    const extensionStarter = 'for ext in /opt/extensions/*; do [ -x "$ext" ] && "$ext" & done';
+    // Build the full wrapper command
+    let fullCommand;
+    if (originalCommand.length > 0) {
+        // Quote each argument and join with spaces
+        const quotedOriginal = originalCommand.map(shellQuote).join(" ");
+        // Start extensions, then exec the original command
+        fullCommand = `${extensionStarter}; exec ${quotedOriginal}`;
+    }
+    else {
+        // No original command - just start extensions (unusual but handle it)
+        fullCommand = extensionStarter;
+    }
+    return {
+        entrypoint: ["/bin/sh"],
+        command: ["-c", fullCommand],
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.js","sourceRoot":"","sources":["../../../src/cli/docker/container.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Docker container management utilities.\n *\n * Handles running Docker containers with the Lambda Runtime API\n * environment configured. Uses @effect/platform Command for\n * proper Effect-based process management.\n */\n\nimport * as os from \"node:os\"\nimport { CommandExecutor, Command as PlatformCommand } from \"@effect/platform\"\nimport type { Process as EffectProcess } from \"@effect/platform/CommandExecutor\"\nimport { Context, Effect, Layer, type Scope, Stream } from \"effect\"\nimport type {\n  DockerImageConfig,\n  DockerRunConfig,\n  DockerRunResult,\n  DockerRuntimeInfo,\n} from \"./types.js\"\n\n/**\n * Detect the Docker runtime environment.\n */\nexport const detectDockerRuntime = (): Effect.Effect<\n  DockerRuntimeInfo,\n  Error\n> =>\n  Effect.try({\n    try: () => {\n      const platform = os.platform()\n      const isLinux = platform === \"linux\"\n      const isWsl =\n        isLinux &&\n        (process.env.WSL_DISTRO_NAME !== undefined ||\n          process.env.WSL_INTEROP !== undefined)\n\n      // On Mac/Windows Docker Desktop, use host.docker.internal\n      // On Linux, we need to use the host's IP or --network=host\n      const isDockerDesktop = !isLinux || isWsl\n\n      const hostAddress = isDockerDesktop\n        ? \"host.docker.internal\"\n        : \"172.17.0.1\" // Default Docker bridge gateway\n\n      return {\n        dockerPath: \"docker\",\n        isLinux,\n        isWsl,\n        isDockerDesktop,\n        hostAddress,\n      }\n    },\n    catch: (error) =>\n      new Error(`Failed to detect Docker runtime: ${String(error)}`),\n  })\n\n/**\n * Build Docker run arguments from config.\n */\nconst buildDockerRunArgs = (\n  config: DockerRunConfig,\n  runtime: DockerRuntimeInfo,\n): string[] => {\n  const args: string[] = [\"run\", \"--rm\"]\n\n  // Container name (add timestamp for uniqueness)\n  if (config.containerName) {\n    args.push(\"--name\", `${config.containerName}-${Date.now()}`)\n  }\n\n  // Platform - allow running ARM64 images on x86_64 via QEMU\n  if (config.platform) {\n    args.push(\"--platform\", config.platform)\n  }\n\n  // Memory limit\n  args.push(\"--memory\", `${config.memoryMB}m`)\n\n  // Network mode\n  if (config.networkMode === \"host\") {\n    args.push(\"--network\", \"host\")\n  } else if (config.networkMode !== \"none\") {\n    // For bridge mode, add host mapping for non-Linux\n    if (runtime.isDockerDesktop) {\n      // host.docker.internal is automatically available on Docker Desktop\n    } else {\n      // On Linux, add explicit host mapping and helper address\n      args.push(\"--add-host\", `host.docker.internal:${runtime.hostAddress}`)\n      args.push(\"--add-host\", `host.containers.internal:${runtime.hostAddress}`)\n      args.push(\"--add-host\", `runtime.api:${runtime.hostAddress}`)\n    }\n  }\n\n  // Extra hosts\n  if (config.extraHosts) {\n    for (const host of config.extraHosts) {\n      args.push(\"--add-host\", host)\n    }\n  }\n\n  // Environment variables\n  for (const [key, value] of Object.entries(config.environment)) {\n    args.push(\"-e\", `${key}=${value}`)\n  }\n\n  // Working directory\n  if (config.workdir) {\n    args.push(\"-w\", config.workdir)\n  }\n\n  // Additional arguments\n  if (config.additionalArgs) {\n    args.push(...config.additionalArgs)\n  }\n\n  // Entrypoint override\n  if (config.entrypoint && config.entrypoint.length > 0) {\n    args.push(\"--entrypoint\", config.entrypoint[0])\n  }\n\n  // Image\n  args.push(config.imageUri)\n\n  // Entrypoint additional args (after image)\n  if (config.entrypoint && config.entrypoint.length > 1) {\n    args.push(...config.entrypoint.slice(1))\n  }\n\n  // Command override (after image and entrypoint args)\n  if (config.command) {\n    args.push(...config.command)\n  }\n\n  return args\n}\n\n/**\n * Docker Service interface for Effect-based Docker operations.\n * All scoped operations require both Scope and CommandExecutor.\n */\nexport interface DockerService {\n  /**\n   * Run a Docker container and wait for it to complete.\n   * Output is streamed to stdout/stderr.\n   */\n  readonly run: (\n    config: DockerRunConfig,\n  ) => Effect.Effect<\n    DockerRunResult,\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n\n  /**\n   * Run a Docker container with scoped lifecycle management.\n   * Returns the running process which can be interrupted via scope.\n   */\n  readonly runScoped: (\n    config: DockerRunConfig,\n  ) => Effect.Effect<\n    EffectProcess,\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n\n  /**\n   * Build a Docker image from a local context directory.\n   */\n  readonly build: (options: {\n    contextPath: string\n    imageName: string\n    platform?: string\n  }) => Effect.Effect<\n    void,\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n\n  /**\n   * Pull a Docker image if not already present.\n   */\n  readonly pull: (\n    imageUri: string,\n  ) => Effect.Effect<void, Error, Scope.Scope | CommandExecutor.CommandExecutor>\n\n  /**\n   * Stop Docker containers matching a name filter.\n   * Returns the number of containers stopped.\n   * @param containerNameFilter - Filter to match container names\n   * @param timeoutSeconds - Seconds to wait before SIGKILL (default: 10)\n   */\n  readonly stop: (\n    containerNameFilter: string,\n    timeoutSeconds?: number,\n  ) => Effect.Effect<\n    number,\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n\n  /**\n   * List Docker container IDs matching a name filter.\n   */\n  readonly list: (\n    containerNameFilter: string,\n  ) => Effect.Effect<\n    string[],\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n\n  /**\n   * Get the detected Docker runtime info.\n   */\n  readonly getRuntimeInfo: () => Effect.Effect<DockerRuntimeInfo, Error>\n\n  /**\n   * Inspect a Docker image to get its configuration.\n   * Returns the ENTRYPOINT and CMD from the image.\n   */\n  readonly inspect: (\n    imageUri: string,\n  ) => Effect.Effect<\n    DockerImageConfig,\n    Error,\n    Scope.Scope | CommandExecutor.CommandExecutor\n  >\n}\n\n/**\n * Docker Service tag for dependency injection.\n */\nexport class Docker extends Context.Tag(\"Docker\")<Docker, DockerService>() {}\n\n/**\n * Create the live Docker service implementation.\n */\nconst makeDockerService: Effect.Effect<DockerService, Error> = Effect.gen(\n  function* () {\n    const runtime = yield* detectDockerRuntime()\n\n    const getRuntimeInfo: DockerService[\"getRuntimeInfo\"] = () =>\n      Effect.succeed(runtime)\n\n    const run: DockerService[\"run\"] = (config) =>\n      Effect.gen(function* () {\n        const args = buildDockerRunArgs(config, runtime)\n\n        yield* Effect.logDebug(`Running: docker ${args.join(\" \")}`)\n\n        const command = PlatformCommand.make(runtime.dockerPath, ...args)\n\n        const stdout: string[] = []\n        const stderr: string[] = []\n\n        // Run the command and collect output\n        const proc = yield* PlatformCommand.start(command)\n\n        // Lambda RIC error/output patterns that are expected during poll timeout\n        // These are suppressed from output to avoid scary error messages\n        const isExpectedRicOutput = (line: string): boolean =>\n          line.includes(\"LAMBDA_RUNTIME Failed to get next invocation\") ||\n          line.includes(\"Failed to get next invocation, error 503\") ||\n          // Filter out the Node.js stack trace from Lambda RIC exit\n          line.includes(\"triggerUncaughtException\") ||\n          line.includes(\"[Error: Failed to get next invocation\") ||\n          // \"Node.js v\" version line after error\n          line.startsWith(\"Node.js v\") ||\n          line.includes(\"node:internal/process/promises\") ||\n          // Stack trace caret line (just whitespace and ^)\n          /^\\s*\\^?\\s*$/.test(line)\n\n        // Pattern to parse Lambda log format: TIMESTAMP\\tREQUEST_ID\\tLEVEL\\tMESSAGE\n        // Lambda uses tabs between fields. Captures: [1] = request ID, [2] = level + message\n        const lambdaLogPattern =\n          /^(\\d{4}-\\d{2}-\\d{2}T[\\d:.]+Z)[\\t\\s]+([0-9a-f-]{36})[\\t\\s]+(.*)$/i\n\n        // Helper to format log line with invocation prefix\n        const formatLine = (\n          rawLine: string,\n        ): { prefix: string; content: string } => {\n          // Strip carriage returns that can cause terminal corruption\n          const line = rawLine.replace(/\\r/g, \"\")\n          const match = lambdaLogPattern.exec(line)\n          if (match && config.invocationContexts) {\n            const requestId = match[2]\n            const ctx = config.invocationContexts.get(requestId)\n            if (ctx) {\n              // Strip timestamp and request ID, keep just LEVEL MESSAGE\n              return { prefix: `[${ctx.num}]`, content: match[3] }\n            }\n          }\n          return { prefix: \"[Container]\", content: line }\n        }\n\n        // Process stdout - filter expected errors, forward the rest\n        const stdoutFiber = yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((rawLine) =>\n            Effect.sync(() => {\n              stdout.push(rawLine)\n              // Suppress expected RIC output (poll timeout errors)\n              if (!isExpectedRicOutput(rawLine)) {\n                const { prefix, content } = formatLine(rawLine)\n                process.stdout.write(`${prefix} ${content}\\n`)\n              }\n            }),\n          ),\n          Effect.fork,\n        )\n\n        // Process stderr - filter expected errors, forward the rest\n        const stderrFiber = yield* proc.stderr.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((rawLine) =>\n            Effect.sync(() => {\n              stderr.push(rawLine)\n              // Suppress expected RIC output (poll timeout errors)\n              if (!isExpectedRicOutput(rawLine)) {\n                const { prefix, content } = formatLine(rawLine)\n                process.stderr.write(`${prefix} ${content}\\n`)\n              }\n            }),\n          ),\n          Effect.fork,\n        )\n\n        // Wait for both streams and exit code\n        yield* Effect.all([\n          Effect.fromFiber(stdoutFiber),\n          Effect.fromFiber(stderrFiber),\n        ])\n\n        const exitCode = yield* proc.exitCode\n\n        // Only suppress warnings for expected exit codes:\n        // - 0: Clean exit\n        // - 1: Lambda RIC exit after 503 poll timeout (expected)\n        // - 143 (128+15): SIGTERM from docker stop\n        // - 137 (128+9): SIGKILL from docker stop timeout\n        const expectedExitCodes = [0, 1, 143, 137]\n        if (!expectedExitCodes.includes(exitCode)) {\n          yield* Effect.logWarning(`Container exited with code ${exitCode}`)\n        } else if (exitCode !== 0) {\n          yield* Effect.logDebug(`Container exited with code ${exitCode}`)\n        }\n\n        return {\n          exitCode,\n          stdout: stdout.join(\"\\n\"),\n          stderr: stderr.join(\"\\n\"),\n        }\n      })\n\n    const runScoped: DockerService[\"runScoped\"] = (config) =>\n      Effect.gen(function* () {\n        const args = buildDockerRunArgs(config, runtime)\n\n        yield* Effect.logInfo(`Running (scoped): docker ${args.join(\" \")}`)\n\n        const command = PlatformCommand.make(runtime.dockerPath, ...args)\n\n        const proc = yield* PlatformCommand.start(command)\n\n        // Fork output processing in background (will be interrupted when scope closes)\n        yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) =>\n            Effect.sync(() => {\n              process.stdout.write(`[Container] ${line}\\n`)\n            }),\n          ),\n          Effect.fork,\n        )\n\n        yield* proc.stderr.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) =>\n            Effect.sync(() => {\n              process.stderr.write(`[Container] ${line}\\n`)\n            }),\n          ),\n          Effect.fork,\n        )\n\n        return proc\n      })\n\n    const build: DockerService[\"build\"] = (options) =>\n      Effect.gen(function* () {\n        const args = [\n          \"build\",\n          \"-t\",\n          options.imageName,\n          \"--platform\",\n          options.platform ?? \"linux/arm64\",\n          options.contextPath,\n        ]\n\n        yield* Effect.logInfo(`Building image: ${options.imageName}`)\n        yield* Effect.logDebug(`Context: ${options.contextPath}`)\n\n        const command = PlatformCommand.make(runtime.dockerPath, ...args)\n\n        const proc = yield* PlatformCommand.start(command)\n\n        // Process stdout (debug only)\n        const stdoutFiber = yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)),\n          Effect.fork,\n        )\n\n        // Process stderr (debug only)\n        const stderrFiber = yield* proc.stderr.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)),\n          Effect.fork,\n        )\n\n        // Wait for streams and exit code\n        yield* Effect.all([\n          Effect.fromFiber(stdoutFiber),\n          Effect.fromFiber(stderrFiber),\n        ])\n\n        const exitCode = yield* proc.exitCode\n\n        if (exitCode !== 0) {\n          return yield* Effect.fail(\n            new Error(`Docker build failed with code ${exitCode}`),\n          )\n        }\n\n        yield* Effect.logInfo(`Built image: ${options.imageName}`)\n      })\n\n    const pull: DockerService[\"pull\"] = (imageUri) =>\n      Effect.gen(function* () {\n        yield* Effect.logInfo(`Pulling image: ${imageUri}`)\n\n        const command = PlatformCommand.make(\n          runtime.dockerPath,\n          \"pull\",\n          imageUri,\n        )\n\n        const proc = yield* PlatformCommand.start(command)\n\n        // Process stdout (debug only)\n        const stdoutFiber = yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)),\n          Effect.fork,\n        )\n\n        // Process stderr (debug only)\n        const stderrFiber = yield* proc.stderr.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) => Effect.logDebug(`[Docker] ${line}`)),\n          Effect.fork,\n        )\n\n        // Wait for streams and exit code\n        yield* Effect.all([\n          Effect.fromFiber(stdoutFiber),\n          Effect.fromFiber(stderrFiber),\n        ])\n\n        const exitCode = yield* proc.exitCode\n\n        if (exitCode !== 0) {\n          return yield* Effect.fail(\n            new Error(`Docker pull failed with code ${exitCode}`),\n          )\n        }\n\n        yield* Effect.logInfo(`Pulled image: ${imageUri}`)\n      })\n\n    const list: DockerService[\"list\"] = (containerNameFilter) =>\n      Effect.gen(function* () {\n        const command = PlatformCommand.make(\n          runtime.dockerPath,\n          \"ps\",\n          \"-q\",\n          \"--filter\",\n          `name=${containerNameFilter}`,\n        )\n\n        const proc = yield* PlatformCommand.start(command)\n\n        // Collect stdout\n        const containerIds: string[] = []\n        yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) =>\n            Effect.sync(() => {\n              const trimmed = line.trim()\n              if (trimmed) {\n                containerIds.push(trimmed)\n              }\n            }),\n          ),\n        )\n\n        const exitCode = yield* proc.exitCode\n\n        if (exitCode !== 0) {\n          return yield* Effect.fail(\n            new Error(`Docker ps failed with code ${exitCode}`),\n          )\n        }\n\n        return containerIds\n      })\n\n    const stop: DockerService[\"stop\"] = (containerNameFilter, timeoutSeconds) =>\n      Effect.gen(function* () {\n        // First list matching containers\n        const containerIds = yield* list(containerNameFilter)\n\n        if (containerIds.length === 0) {\n          yield* Effect.logDebug(\n            `No containers found matching: ${containerNameFilter}`,\n          )\n          return 0\n        }\n\n        yield* Effect.logInfo(`Stopping containers: ${containerIds.join(\", \")}`)\n\n        // Build stop command with optional timeout\n        // -t 0 sends SIGKILL immediately, useful for fast restarts\n        const timeoutArg =\n          timeoutSeconds !== undefined ? [\"-t\", String(timeoutSeconds)] : []\n        const command = PlatformCommand.make(\n          runtime.dockerPath,\n          \"stop\",\n          ...timeoutArg,\n          ...containerIds,\n        )\n\n        const proc = yield* PlatformCommand.start(command)\n\n        // Process output for logging\n        yield* proc.stdout.pipe(\n          Stream.decodeText(),\n          Stream.splitLines,\n          Stream.runForEach((line) =>\n            Effect.logDebug(`[Docker stop] ${line.trim()}`),\n          ),\n        )\n\n        const exitCode = yield* proc.exitCode\n\n        if (exitCode !== 0) {\n          yield* Effect.logWarning(\n            `Docker stop exited with code ${exitCode} (some containers may have already stopped)`,\n          )\n        }\n\n        return containerIds.length\n      })\n\n    const inspect: DockerService[\"inspect\"] = (imageUri) =>\n      Effect.gen(function* () {\n        const executor = yield* CommandExecutor.CommandExecutor\n\n        // Get entrypoint\n        const entrypointCmd = PlatformCommand.make(\n          runtime.dockerPath,\n          \"inspect\",\n          \"--format\",\n          \"{{json .Config.Entrypoint}}\",\n          imageUri,\n        )\n        const entrypointProc = yield* executor.start(entrypointCmd)\n        const entrypointOutput = yield* Stream.runCollect(\n          Stream.decodeText(entrypointProc.stdout),\n        )\n        const entrypointExitCode = yield* entrypointProc.exitCode\n        if (entrypointExitCode !== 0) {\n          yield* Effect.fail(\n            new Error(`Failed to inspect image entrypoint: ${imageUri}`),\n          )\n        }\n        const entrypointJson = Array.from(entrypointOutput).join(\"\").trim()\n\n        // Get cmd\n        const cmdCmd = PlatformCommand.make(\n          runtime.dockerPath,\n          \"inspect\",\n          \"--format\",\n          \"{{json .Config.Cmd}}\",\n          imageUri,\n        )\n        const cmdProc = yield* executor.start(cmdCmd)\n        const cmdOutput = yield* Stream.runCollect(\n          Stream.decodeText(cmdProc.stdout),\n        )\n        const cmdExitCode = yield* cmdProc.exitCode\n        if (cmdExitCode !== 0) {\n          yield* Effect.fail(\n            new Error(`Failed to inspect image cmd: ${imageUri}`),\n          )\n        }\n        const cmdJson = Array.from(cmdOutput).join(\"\").trim()\n\n        // Parse JSON - null is valid, so handle that\n        const parseJsonArray = (json: string): string[] | null => {\n          if (json === \"null\" || json === \"\") return null\n          try {\n            const parsed = JSON.parse(json)\n            return Array.isArray(parsed) ? parsed : null\n          } catch {\n            return null\n          }\n        }\n\n        return {\n          entrypoint: parseJsonArray(entrypointJson),\n          cmd: parseJsonArray(cmdJson),\n        }\n      })\n\n    return {\n      run,\n      runScoped,\n      build,\n      pull,\n      stop,\n      list,\n      getRuntimeInfo,\n      inspect,\n    } satisfies DockerService\n  },\n)\n\n/**\n * Live Docker service layer.\n * Note: Does not require CommandExecutor in the layer - it's required\n * when the service methods are called.\n */\nexport const DockerLive: Layer.Layer<Docker, Error> = Layer.effect(\n  Docker,\n  makeDockerService,\n)\n\n/**\n * Create a container config for running a Lambda container.\n */\nexport const makeLambdaContainerConfig = (options: {\n  imageUri: string\n  runtimeApiHost: string\n  runtimeApiPort: number\n  functionName: string\n  functionVersion: string\n  memoryMB: number\n  timeoutSeconds: number\n  handler?: string\n  awsRegion?: string\n  platform?: string\n  additionalEnv?: Record<string, string>\n  invocationContexts?: Map<string, { num: number }>\n}): DockerRunConfig => ({\n  imageUri: options.imageUri,\n  containerName: `lambda-${options.functionName.replace(/[^a-zA-Z0-9]/g, \"-\")}`,\n  platform: options.platform,\n  environment: {\n    AWS_LAMBDA_RUNTIME_API: `${options.runtimeApiHost}:${options.runtimeApiPort}`,\n    AWS_LAMBDA_FUNCTION_NAME: options.functionName,\n    AWS_LAMBDA_FUNCTION_VERSION: options.functionVersion,\n    AWS_LAMBDA_FUNCTION_MEMORY_SIZE: String(options.memoryMB),\n    AWS_REGION: options.awsRegion ?? \"us-east-1\",\n    AWS_DEFAULT_REGION: options.awsRegion ?? \"us-east-1\",\n    AWS_LAMBDA_LOG_GROUP_NAME: `/aws/lambda/${options.functionName}`,\n    AWS_LAMBDA_LOG_STREAM_NAME: \"local\",\n    _HANDLER: options.handler ?? \"index.handler\",\n    ...options.additionalEnv,\n  },\n  memoryMB: options.memoryMB,\n  timeoutSeconds: options.timeoutSeconds,\n  networkMode: \"bridge\",\n  invocationContexts: options.invocationContexts,\n})\n\n/**\n * Stream output from a Docker container.\n */\nexport interface ContainerOutput {\n  type: \"stdout\" | \"stderr\"\n  data: string\n}\n\n/**\n * Shell-quote a string for safe inclusion in a shell command.\n * Uses single quotes and escapes any embedded single quotes.\n */\nconst shellQuote = (s: string): string => {\n  // Single quotes are safest - escape any embedded single quotes\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`\n}\n\n/**\n * Build a wrapper command that starts Lambda extensions before the main app.\n *\n * This mimics AWS Lambda's behavior of automatically starting all executables\n * in /opt/extensions/ as background processes before running the main command.\n *\n * @param originalEntrypoint - The image's original ENTRYPOINT\n * @param originalCmd - The image's original CMD\n * @returns Entrypoint and command arrays to pass to Docker\n */\nexport const buildExtensionWrapperCommand = (\n  originalEntrypoint: string[] | null,\n  originalCmd: string[] | null,\n): { entrypoint: string[]; command: string[] } => {\n  // Combine original entrypoint + cmd into the full command\n  // Docker behavior: ENTRYPOINT + CMD are concatenated\n  const originalCommand = [\n    ...(originalEntrypoint ?? []),\n    ...(originalCmd ?? []),\n  ]\n\n  // Script to start all executable files in /opt/extensions/ as background processes\n  const extensionStarter =\n    'for ext in /opt/extensions/*; do [ -x \"$ext\" ] && \"$ext\" & done'\n\n  // Build the full wrapper command\n  let fullCommand: string\n  if (originalCommand.length > 0) {\n    // Quote each argument and join with spaces\n    const quotedOriginal = originalCommand.map(shellQuote).join(\" \")\n    // Start extensions, then exec the original command\n    fullCommand = `${extensionStarter}; exec ${quotedOriginal}`\n  } else {\n    // No original command - just start extensions (unusual but handle it)\n    fullCommand = extensionStarter\n  }\n\n  return {\n    entrypoint: [\"/bin/sh\"],\n    command: [\"-c\", fullCommand],\n  }\n}\n"]}

package/lib/cli/docker/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Types for Docker container management.
+ */
+/**
+ * Configuration for running a Docker container.
+ */
+export interface DockerRunConfig {
+    /** The Docker image URI to run */
+    imageUri: string;
+    /** Container name (optional) */
+    containerName?: string;
+    /** Platform (e.g., linux/arm64, linux/amd64) for cross-platform execution */
+    platform?: string;
+    /** Environment variables to pass to the container */
+    environment: Record<string, string>;
+    /** Memory limit in MB */
+    memoryMB: number;
+    /** Timeout in seconds */
+    timeoutSeconds: number;
+    /** Network mode (bridge, host, none) */
+    networkMode: "bridge" | "host" | "none";
+    /** Extra host entries (--add-host) */
+    extraHosts?: string[];
+    /** Working directory inside the container */
+    workdir?: string;
+    /** Additional Docker run arguments */
+    additionalArgs?: string[];
+    /** Optional invocation context map for log prefixing (requestId -> { num }) */
+    invocationContexts?: Map<string, {
+        num: number;
+    }>;
+    /** Override the container's entrypoint */
+    entrypoint?: string[];
+    /** Override the container's command (arguments after the image) */
+    command?: string[];
+}
+/**
+ * Docker image configuration from inspection.
+ */
+export interface DockerImageConfig {
+    /** The image's ENTRYPOINT */
+    entrypoint: string[] | null;
+    /** The image's CMD */
+    cmd: string[] | null;
+}
+/**
+ * Result of running a Docker container.
+ */
+export interface DockerRunResult {
+    /** Exit code of the container */
+    exitCode: number;
+    /** Stdout from the container */
+    stdout: string;
+    /** Stderr from the container */
+    stderr: string;
+}
+/**
+ * Docker runtime detection result.
+ */
+export interface DockerRuntimeInfo {
+    /** Path to Docker executable */
+    dockerPath: string;
+    /** Whether running on Linux */
+    isLinux: boolean;
+    /** Whether running in WSL */
+    isWsl: boolean;
+    /** Whether Docker Desktop is detected */
+    isDockerDesktop: boolean;
+    /** Host address to use for container-to-host communication */
+    hostAddress: string;
+}

package/lib/cli/docker/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for Docker container management.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/docker/watcher.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 { Stream } from "effect";
+/**
+ * Event emitted when a file changes in a Docker context.
+ */
+export interface DockerContextChangeEvent {
+    /** The function ID that owns this Docker context */
+    functionId: string;
+    /** The absolute path to the file that changed */
+    filePath: string;
+    /** Type of change */
+    type: "add" | "change" | "unlink";
+}
+/**
+ * Configuration for a Docker function to watch.
+ */
+export interface WatchedDockerFunction {
+    /** Unique function identifier (Lambda function name) */
+    functionId: string;
+    /** Absolute path to the Docker context directory */
+    dockerContextPath: string;
+}
+/**
+ * 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 declare const watchDockerContexts: (functions: WatchedDockerFunction[], debounceMs?: number) => Stream.Stream<DockerContextChangeEvent, Error>;
+/**
+ * Create a watcher for a single Docker function.
+ * Convenience wrapper around watchDockerContexts for single-function use.
+ */
+export declare const watchSingleDockerContext: (functionId: string, dockerContextPath: string, debounceMs?: number) => Stream.Stream<DockerContextChangeEvent, Error>;