@intelligems/sst 2.49.6-ig.1 → 2.49.6-ig.10

package/runtime/debug-file-logger.js

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+// Active loggers registry (for cleanup)
+const activeLoggers = new Map();
+// Cleanup on process exit
+process.on("exit", () => {
+    for (const stream of activeLoggers.values()) {
+        try {
+            stream.end();
+        }
+        catch { }
+    }
+});
+/**
+ * Create a debug file logger with consistent formatting
+ *
+ * Features:
+ * - File-based logging to configurable path
+ * - Optional enable/disable via environment variable
+ * - Session start/end markers
+ * - Consistent timestamp formatting (HH:MM:SS.mmm)
+ * - Automatic directory creation
+ *
+ * @example
+ * ```ts
+ * const logger = createDebugFileLogger({
+ *   filePath: ".sst/debug-workers.log",
+ *   envVar: "SST_DEBUG_WORKERS",
+ *   sessionName: "WORKERS",
+ * });
+ *
+ * logger.log("REQUEST", { path: "/api/test", elapsed: 50 });
+ * // Output: [14:30:45.123] REQUEST path=/api/test elapsed=50
+ * ```
+ */
+export function createDebugFileLogger(config) {
+    const { filePath, envVar, sessionName, sessionHeader, width = 80 } = config;
+    let stream = null;
+    let initialized = false;
+    function isEnabled() {
+        // If no envVar specified, always enabled
+        if (!envVar)
+            return true;
+        return process.env[envVar] === "true";
+    }
+    function initLogFile() {
+        if (initialized)
+            return stream !== null;
+        initialized = true;
+        if (!isEnabled())
+            return false;
+        try {
+            const logDir = path.dirname(filePath);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            stream = fs.createWriteStream(filePath, { flags: "w" });
+            activeLoggers.set(filePath, stream);
+            // Write session start marker
+            const header = sessionHeader ? ` | ${sessionHeader}` : "";
+            stream.write("\n" +
+                "=".repeat(width) +
+                "\n" +
+                `[${sessionName} SESSION START] ${new Date().toISOString()}${header}\n` +
+                "=".repeat(width) +
+                "\n");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function formatTimestamp() {
+        return new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    }
+    function formatDetails(details) {
+        return Object.entries(details)
+            .filter(([_, v]) => v !== undefined)
+            .map(([k, v]) => {
+            if (typeof v === "object") {
+                return `${k}=${JSON.stringify(v)}`;
+            }
+            return `${k}=${v}`;
+        })
+            .join(" ");
+    }
+    return {
+        log(action, details = {}) {
+            if (!initLogFile() || !stream)
+                return;
+            const timestamp = formatTimestamp();
+            const detailStr = formatDetails(details);
+            const line = `[${timestamp}] ${action.padEnd(20)} ${detailStr}\n`;
+            stream.write(line);
+        },
+        logRaw(line) {
+            if (!initLogFile() || !stream)
+                return;
+            stream.write(line.endsWith("\n") ? line : line + "\n");
+        },
+        isEnabled,
+        close(summary) {
+            if (!stream)
+                return;
+            const endMarker = "\n" +
+                "-".repeat(width) +
+                "\n" +
+                `[${sessionName} SESSION END] ${new Date().toISOString()}\n` +
+                (summary ? summary + "\n" : "") +
+                "-".repeat(width) +
+                "\n";
+            stream.write(endMarker);
+            stream.end();
+            activeLoggers.delete(filePath);
+            stream = null;
+        },
+        getStream() {
+            initLogFile();
+            return stream;
+        },
+    };
+}
+/**
+ * Create a logger that writes to both console and a file
+ * Always writes to console, writes to file when SST_DEBUG_BRIDGE is set
+ */
+export function createConsoleFileLogger(config) {
+    const { filePath, prefix, sessionName } = config;
+    const fileLogger = createDebugFileLogger({
+        filePath,
+        envVar: "SST_DEBUG_BRIDGE",
+        sessionName,
+        width: 100,
+    });
+    return {
+        log(message) {
+            // Always log to console
+            console.log(`${prefix} ${message}`);
+            // Also log to file if enabled
+            if (fileLogger.isEnabled()) {
+                const timestamp = new Date().toISOString().slice(11, 23);
+                fileLogger.logRaw(`[${timestamp}] ${prefix} ${message}`);
+            }
+        },
+        isEnabled: fileLogger.isEnabled,
+        close: () => fileLogger.close(),
+    };
+}

package/runtime/event-trace-logging.d.ts

@@ -0,0 +1,27 @@
+type EventType = "IOT_RECEIVED" | "IOT_ACK" | "WORKER_START" | "WORKER_LOG" | "WORKER_END";
+interface EventTraceDetails {
+    requestID: string;
+    functionID?: string;
+    workerID?: string;
+    message?: string;
+    status?: "success" | "error";
+    elapsed?: number;
+    [key: string]: any;
+}
+/**
+ * Log an event trace entry with requestID as the common identifier
+ *
+ * @param event - The event type
+ * @param details - Event details including requestID (required)
+ *
+ * @example
+ * logEventTrace("IOT_RECEIVED", { requestID: "abc123", functionID: "MyFunc" });
+ * logEventTrace("WORKER_LOG", { requestID: "abc123", message: "[LOG] User action" });
+ * logEventTrace("WORKER_END", { requestID: "abc123", status: "success", elapsed: 150 });
+ */
+export declare function logEventTrace(event: EventType, details: EventTraceDetails): void;
+/**
+ * Check if event trace logging is enabled
+ */
+export declare function isEventTraceEnabled(): boolean;
+export {};

package/runtime/event-trace-logging.js

@@ -0,0 +1,69 @@
+import { createDebugFileLogger } from "./debug-file-logger.js";
+/**
+ * Event Trace Logging for SST Dev Bridge
+ *
+ * Tracks the complete lifecycle of a request from IOT reception to worker completion.
+ * All events share a common `requestID` for end-to-end tracing.
+ *
+ * Enable with: SST_EVENT_TRACE=true
+ *
+ * Log file: .sst/event-trace.log
+ *
+ * Event Types:
+ * - IOT_RECEIVED     : IOT event received from Lambda
+ * - IOT_ACK          : IOT acknowledgment published
+ * - WORKER_START     : Worker function started
+ * - WORKER_LOG       : Worker function log with [LOG] prefix
+ * - WORKER_END       : Worker function completed (success/error)
+ *
+ * Tracing from Frontend:
+ * - Send X-Correlation-ID header from frontend for easy correlation
+ * - Or use the path to filter by endpoint
+ * - Or use apiGwReqId (visible in browser as x-amzn-requestid response header)
+ */
+const EVENT_TRACE_ENABLED = process.env.SST_EVENT_TRACE === "true";
+let eventLogger = null;
+function getEventLogger() {
+    if (!EVENT_TRACE_ENABLED)
+        return null;
+    if (!eventLogger) {
+        eventLogger = createDebugFileLogger({
+            filePath: ".sst/event-trace.log",
+            sessionName: "EVENT_TRACE",
+            width: 140,
+        });
+    }
+    return eventLogger;
+}
+/**
+ * Log an event trace entry with requestID as the common identifier
+ *
+ * @param event - The event type
+ * @param details - Event details including requestID (required)
+ *
+ * @example
+ * logEventTrace("IOT_RECEIVED", { requestID: "abc123", functionID: "MyFunc" });
+ * logEventTrace("WORKER_LOG", { requestID: "abc123", message: "[LOG] User action" });
+ * logEventTrace("WORKER_END", { requestID: "abc123", status: "success", elapsed: 150 });
+ */
+export function logEventTrace(event, details) {
+    const logger = getEventLogger();
+    if (!logger)
+        return;
+    // Format requestID for consistent display (first 8 chars)
+    const reqId = details.requestID?.slice(0, 8) || "N/A";
+    // Build the log message with requestID prominently displayed
+    const logDetails = {
+        reqId,
+        ...details,
+    };
+    // Remove the full requestID since we're using the shortened version
+    delete logDetails.requestID;
+    logger.log(event, logDetails);
+}
+/**
+ * Check if event trace logging is enabled
+ */
+export function isEventTraceEnabled() {
+    return EVENT_TRACE_ENABLED;
+}

package/runtime/handlers/node.js

@@ -11,6 +11,7 @@ import { useRuntimeWorkers } from "../workers.js";
 import { Colors } from "../../cli/colors.js";
 import { Logger } from "../../logger.js";
 import { findAbove } from "../../util/fs.js";
+import { useMonoBuildConfig } from "../mono-build-config.js";
 export const useNodeHandler = () => {
     const rebuildCache = {};
     process.on("exit", () => {
@@ -34,33 +35,72 @@ export const useNodeHandler = () => {
         canHandle: (input) => input.startsWith("nodejs"),
         startWorker: async (input) => {
             const workers = await useRuntimeWorkers();
-            new Promise(async () => {
-                const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
-                    env: {
-                        ...input.environment,
-                        IS_LOCAL: "true",
-                    },
-                    execArgv: ["--enable-source-maps"],
-                    workerData: input,
-                    stderr: true,
-                    stdin: true,
-                    stdout: true,
-                });
-                worker.stdout.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.stderr.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.on("exit", () => workers.exited(input.workerID));
-                threads.set(input.workerID, worker);
+            const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
+                env: {
+                    ...input.environment,
+                    IS_LOCAL: "true",
+                },
+                execArgv: ["--enable-source-maps"],
+                workerData: input,
+                stderr: true,
+                stdin: true,
+                stdout: true,
             });
+            worker.stdout.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            worker.stderr.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            worker.on("exit", () => workers.exited(input.workerID));
+            threads.set(input.workerID, worker);
         },
         stopWorker: async (workerID) => {
             const worker = threads.get(workerID);
             await worker?.terminate();
         },
         build: async (input) => {
+            // Check for dev mode mono-bundle using global config
+            const monoBuildConfig = useMonoBuildConfig();
+            if (input.mode === "start" && monoBuildConfig.enabled) {
+                Colors.line(Colors.prefix, Colors.dim.bold("MonoBundle"), Colors.dim(`mode=${input.mode}, handler=${input.props.handler}`));
+                // Symlink node_modules to mono-bundle dir for external dependencies
+                // Only create if symlink doesn't exist or points to wrong location (avoid redundant I/O)
+                const parsed = path.parse(input.props.handler);
+                const handlerFunctionsDir = path.join(project.paths.root, parsed.dir);
+                const root = await findAbove(handlerFunctionsDir, "package.json");
+                if (root) {
+                    const sourceNodeModules = path.resolve(root, "node_modules");
+                    const monoBundleNodeModules = path.join(monoBuildConfig.dir, "node_modules");
+                    try {
+                        const existingTarget = await fs.readlink(monoBundleNodeModules);
+                        if (existingTarget === sourceNodeModules) {
+                            // Symlink already correct, skip
+                        }
+                        else {
+                            // Symlink points to wrong location, recreate
+                            await fs.rm(monoBundleNodeModules, { recursive: true, force: true });
+                            await fs.symlink(sourceNodeModules, monoBundleNodeModules, "dir");
+                            Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                        }
+                    }
+                    catch {
+                        // Symlink doesn't exist, create it
+                        try {
+                            await fs.symlink(sourceNodeModules, monoBundleNodeModules, "dir");
+                            Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                        }
+                        catch (err) {
+                            Logger.debug("Failed to symlink node_modules for mono-bundle:", err);
+                        }
+                    }
+                }
+                return {
+                    type: "success",
+                    handler: monoBuildConfig.handler,
+                    out: monoBuildConfig.dir,
+                };
+            }
             const parsed = path.parse(input.props.handler);
             const file = [
                 ".ts",
@@ -108,7 +148,8 @@ export const useNodeHandler = () => {
                 try {
                     await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
                 }
-                catch { }
+                catch {
+                }
             }
             // Rebuilt using existing esbuild context
             let ctx = rebuildCache[input.functionID]?.ctx;

package/runtime/handlers.d.ts

@@ -6,6 +6,7 @@ declare module "../bus.js" {
         };
         "function.build.success": {
             functionID: string;
+            monoBundle?: boolean;
         };
         "function.build.failed": {
             functionID: string;
@@ -27,6 +28,8 @@ export interface StartWorkerInput {
     out: string;
     handler: string;
     runtime: string;
+    /** Whether this worker is using mono build mode */
+    isMonoBuild?: boolean;
 }
 interface ShouldBuildInput {
     file: string;
@@ -41,6 +44,7 @@ export interface RuntimeHandler {
         type: "success";
         handler: string;
         sourcemap?: string;
+        out?: string;
     } | {
         type: "error";
         errors: string[];
@@ -57,10 +61,10 @@ export declare const useRuntimeHandlers: () => {
         type: "error";
         errors: string[];
     } | {
-        out: string;
-        sourcemap: string | undefined;
         type: "success";
         handler: string;
+        out: string;
+        sourcemap: string | undefined;
     }>;
 };
 interface Artifact {

package/runtime/handlers.js

@@ -14,6 +14,9 @@ import { usePythonHandler } from "./handlers/python.js";
 import { useRustHandler } from "./handlers/rust.js";
 import { lazy } from "../util/lazy.js";
 import { Semaphore } from "../util/semaphore.js";
+import { isMonoBuildPath } from "./mono-build-config.js";
+// Build concurrency semaphore - only used for actual builds, not mono-build lookups
+const buildSemaphore = new Semaphore(parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10));
 export const useRuntimeHandlers = lazy(() => {
     const handlers = [
         useNodeHandler(),
@@ -39,64 +42,110 @@ export const useRuntimeHandlers = lazy(() => {
             return result;
         },
         async build(functionID, mode) {
-            async function task() {
+            // Fast path for mono-bundle: check without semaphore since no actual build work
+            async function tryMonoBundleFastPath() {
                 const func = useFunctions().fromID(functionID);
                 if (!func)
-                    return {
-                        type: "error",
-                        errors: [`Function with ID "${functionID}" not found`],
-                    };
+                    return null;
                 const handler = result.for(func.runtime);
                 const out = path.join(project.paths.artifacts, functionID);
-                await fs.rm(out, { recursive: true, force: true });
-                await fs.mkdir(out, { recursive: true });
-                bus.publish("function.build.started", { functionID });
-                if (func.hooks?.beforeBuild)
-                    await func.hooks.beforeBuild(func, out);
-                const built = await handler.build({
+                // Check for mono-bundle mode by doing a preliminary build call
+                // In mono-bundle mode, handler returns its own out path immediately without building
+                const monoBundleCheck = await handler.build({
                     functionID,
                     out,
                     mode,
                     props: func,
                 });
-                if (built.type === "error") {
-                    bus.publish("function.build.failed", {
+                // If mono-bundle detected (handler returned custom out), skip all artifact work
+                // Don't fire build events - mono-bundle is built externally by esbuild watch
+                // Worker pool invalidation is handled separately when bundle file actually changes
+                if (monoBundleCheck.type === "success" && monoBundleCheck.out) {
+                    return {
+                        type: "success",
+                        handler: monoBundleCheck.handler,
+                        out: monoBundleCheck.out,
+                        sourcemap: monoBundleCheck.sourcemap,
+                    };
+                }
+                return null; // Not mono-bundle, need full build
+            }
+            // Full build with semaphore protection for actual compilation work
+            async function fullBuild() {
+                const func = useFunctions().fromID(functionID);
+                if (!func)
+                    return {
+                        type: "error",
+                        errors: [`Function with ID "${functionID}" not found`],
+                    };
+                const handler = result.for(func.runtime);
+                const out = path.join(project.paths.artifacts, functionID);
+                // Acquire semaphore only for actual build work
+                const unlock = await buildSemaphore.lock();
+                try {
+                    // Non-mono-bundle: follow original flow
+                    await fs.rm(out, { recursive: true, force: true });
+                    await fs.mkdir(out, { recursive: true });
+                    bus.publish("function.build.started", { functionID });
+                    if (func.hooks?.beforeBuild)
+                        await func.hooks.beforeBuild(func, out);
+                    const built = await handler.build({
                         functionID,
-                        errors: built.errors,
+                        out,
+                        mode,
+                        props: func,
                     });
-                    return built;
-                }
-                if (func.copyFiles) {
-                    await Promise.all(func.copyFiles.map(async (entry) => {
-                        const fromPath = path.join(project.paths.root, entry.from);
-                        const to = entry.to || entry.from;
-                        if (path.isAbsolute(to))
-                            throw new Error(`Copy destination path "${to}" must be relative`);
-                        const toPath = path.join(out, to);
-                        if (mode === "deploy")
-                            await fs.cp(fromPath, toPath, {
-                                recursive: true,
-                            });
-                        if (mode === "start") {
-                            try {
-                                const dir = path.dirname(toPath);
-                                await fs.mkdir(dir, { recursive: true });
-                                await fs.symlink(fromPath, toPath);
+                    if (built.type === "error") {
+                        bus.publish("function.build.failed", {
+                            functionID,
+                            errors: built.errors,
+                        });
+                        return built;
+                    }
+                    if (func.copyFiles) {
+                        await Promise.all(func.copyFiles.map(async (entry) => {
+                            const fromPath = path.join(project.paths.root, entry.from);
+                            const to = entry.to || entry.from;
+                            if (path.isAbsolute(to))
+                                throw new Error(`Copy destination path "${to}" must be relative`);
+                            const toPath = path.join(out, to);
+                            if (mode === "deploy")
+                                await fs.cp(fromPath, toPath, {
+                                    recursive: true,
+                                });
+                            if (mode === "start") {
+                                try {
+                                    const dir = path.dirname(toPath);
+                                    await fs.mkdir(dir, { recursive: true });
+                                    await fs.symlink(fromPath, toPath);
+                                }
+                                catch (ex) {
+                                    Logger.debug("Failed to symlink", fromPath, toPath, ex);
+                                }
                             }
-                            catch (ex) {
-                                Logger.debug("Failed to symlink", fromPath, toPath, ex);
-                            }
-                        }
-                    }));
+                        }));
+                    }
+                    if (func.hooks?.afterBuild)
+                        await func.hooks.afterBuild(func, out);
+                    bus.publish("function.build.success", { functionID });
+                    return {
+                        ...built,
+                        out,
+                        sourcemap: built.sourcemap,
+                    };
+                }
+                finally {
+                    unlock();
                 }
-                if (func.hooks?.afterBuild)
-                    await func.hooks.afterBuild(func, out);
-                bus.publish("function.build.success", { functionID });
-                return {
-                    ...built,
-                    out,
-                    sourcemap: built.sourcemap,
-                };
+            }
+            async function task() {
+                // Try mono-bundle fast path first (no semaphore needed)
+                const monoBundleResult = await tryMonoBundleFastPath();
+                if (monoBundleResult) {
+                    return monoBundleResult;
+                }
+                // Fall back to full build with semaphore protection
+                return fullBuild();
             }
             if (pendingBuilds.has(functionID)) {
                 Logger.debug("Waiting on pending build", functionID);
@@ -118,27 +167,43 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
-    const semaphore = new Semaphore(4);
+    // Track pending builds to prevent duplicate concurrent builds for same function
+    const pendingArtifactBuilds = new Map();
     const result = {
         artifact: (functionID) => {
+            // Fast path: already cached - return immediately without any async work
             if (artifacts.has(functionID))
                 return artifacts.get(functionID);
             return result.build(functionID);
         },
         build: async (functionID) => {
-            const unlock = await semaphore.lock();
-            try {
-                const result = await handlers.build(functionID, "start");
-                if (!result)
-                    return;
-                if (result.type === "error")
-                    return;
-                artifacts.set(functionID, result);
+            // Fast path: already cached (check again in case of concurrent calls)
+            if (artifacts.has(functionID))
                 return artifacts.get(functionID);
-            }
-            finally {
-                unlock();
-            }
+            // Deduplication: if build already in progress for this function, wait for it
+            const pending = pendingArtifactBuilds.get(functionID);
+            if (pending)
+                return pending;
+            const buildTask = async () => {
+                try {
+                    // handlers.build() handles semaphore internally:
+                    // - mono-build: no semaphore (fast path)
+                    // - non-mono-build: semaphore protected
+                    const buildResult = await handlers.build(functionID, "start");
+                    if (!buildResult)
+                        return;
+                    if (buildResult.type === "error")
+                        return;
+                    artifacts.set(functionID, buildResult);
+                    return artifacts.get(functionID);
+                }
+                finally {
+                    pendingArtifactBuilds.delete(functionID);
+                }
+            };
+            const promise = buildTask();
+            pendingArtifactBuilds.set(functionID, promise);
+            return promise;
         },
     };
     const watcher = useWatcher();
@@ -146,6 +211,11 @@ export const useFunctionBuilder = lazy(() => {
         try {
             const functions = useFunctions();
             for (const [functionID, info] of Object.entries(functions.all)) {
+                // Optimization: For mono-build, the artifact path is stable and build is handled externally.
+                // We can skip the potentially expensive shouldBuild check and rebuild call.
+                const existing = artifacts.get(functionID);
+                if (existing && isMonoBuildPath(existing.out))
+                    continue;
                 const handler = handlers.for(info.runtime);
                 if (!handler?.shouldBuild({
                     functionID,
@@ -156,7 +226,8 @@ export const useFunctionBuilder = lazy(() => {
                 Logger.debug("Rebuilt function", functionID);
             }
         }
-        catch { }
+        catch {
+        }
     });
     return result;
 });