@intelligems/sst 2.49.3 → 2.49.6-ig.10

package/runtime/debug-file-logger.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" resolution-mode="require"/>
+import fs from "fs";
+/**
+ * Configuration for creating a debug file logger
+ */
+export interface DebugFileLoggerConfig {
+    /** Log file path (relative paths are relative to CWD) */
+    filePath: string;
+    /** Optional environment variable to enable/disable logging (if not set, logging is always enabled) */
+    envVar?: string;
+    /** Name for session markers (e.g., "POOL", "TRACE") */
+    sessionName: string;
+    /** Optional header line content for session start */
+    sessionHeader?: string;
+    /** Column width for padding (default: 80) */
+    width?: number;
+}
+/**
+ * Debug file logger instance
+ */
+export interface DebugFileLogger {
+    /** Log a message with timestamp and formatted details */
+    log: (action: string, details?: Record<string, any>) => void;
+    /** Log a raw line (no formatting) */
+    logRaw: (line: string) => void;
+    /** Check if logging is enabled */
+    isEnabled: () => boolean;
+    /** Write session end marker and close the stream */
+    close: (summary?: string) => void;
+    /** Get the write stream (for advanced use cases) */
+    getStream: () => fs.WriteStream | null;
+}
+/**
+ * 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 declare function createDebugFileLogger(config: DebugFileLoggerConfig): DebugFileLogger;
+/**
+ * Create a simple console+file logger for debug output
+ * Logs to both console and a file with consistent formatting
+ */
+export interface ConsoleFileLoggerConfig {
+    /** Log file path */
+    filePath: string;
+    /** Prefix for console output (e.g., "[WORKERS]") */
+    prefix: string;
+    /** Session name for file markers */
+    sessionName: string;
+}
+export interface ConsoleFileLogger {
+    /** Log a message to both console and file */
+    log: (message: string) => void;
+    /** Check if file logging is enabled */
+    isEnabled: () => boolean;
+    /** Close the file stream */
+    close: () => void;
+}
+/**
+ * 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 declare function createConsoleFileLogger(config: ConsoleFileLoggerConfig): ConsoleFileLogger;

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 {