@intelligems/sst 2.49.8-ig.2 → 2.49.8-ig.3

package/README.md

@@ -0,0 +1,60 @@
+# sst
+
+[SST](https://sst.dev) makes it easy to build modern full-stack applications on AWS.
+
+The `sst` package is made up of the following.
+
+- [`sst`](https://docs.sst.dev/packages/sst) CLI
+- [`sst/node`](https://docs.sst.dev/clients) Node.js client
+- [`sst/constructs`](https://docs.sst.dev/constructs) CDK constructs
+
+## Installation
+
+Install the `sst` package in your project root.
+
+```bash
+npm install sst --save-exact
+```
+
+## Usage
+
+Once installed, you can run the CLI commands using.
+
+```bash
+npx sst <command>
+```
+
+Import the Node.js client in your functions. For example, you can import the `Bucket` client.
+
+```ts
+import { Bucket } from "sst/node/bucket";
+```
+
+And import the constructs you need in your stacks code. For example, you can add an API.
+
+```ts
+import { Api } from "sst/constructs";
+```
+
+For more details, [head over to our docs](https://docs.sst.dev).
+
+---
+
+**Join our community** [Discord](https://sst.dev/discord) | [YouTube](https://www.youtube.com/c/sst-dev) | [Twitter](https://twitter.com/SST_dev)
+
+## Dev mode tuning (Intelligems fork)
+
+`sst dev` runs Node functions as worker threads inside the CLI process. In mono-build mode every worker loads
+the whole `.mono-build` bundle, so the number of live workers is what decides memory use. These variables
+control it (defaults in `src/runtime/worker-config.ts`):
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `SST_WORKER_POOL_SIZE` | `4` | Max live workers per pool (one shared pool for all mono-build Node functions). Requests beyond that wait for a free worker instead of spawning a new one. |
+| `SST_WORKER_CONCURRENCY` | `10` | Invocations one Node worker runs at the same time. Each invocation gets its own `process.env`. Set to `1` to fall back to one request per worker. |
+| `SST_WORKER_IDLE_TIMEOUT` | `300000` | Milliseconds an idle worker is kept before it is terminated. |
+| `SST_WARMUP_COUNT` | pool size | Warm pings sent at startup (capped at the pool size). `0` disables warmup. |
+| `SST_WORKER_MAX_HEAP_MB` | `1024` | V8 old-space cap per worker. A worker that exceeds it exits and its in-flight requests fail; the dev session keeps running. `0` removes the cap. |
+| `SST_SOURCE_MAPS` | unset | `true` runs workers with `--enable-source-maps` (costs memory per worker). |
+| `SST_DEBUG_MEMORY` | unset | `true` samples process and worker memory to `.sst/memory.log` every 10s and adds peaks to the pool session summary. |
+| `SST_DEBUG_POOL` | unset | `true` logs pool events (`CREATE`, `REUSE`, `POOL_WAIT`, `TERMINATE`, …) to `.sst/worker-pool.log`. |

package/cli/commands/dev.js

@@ -401,7 +401,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             import("./plugins/warmer.js").then((mod) => mod.useRDSWarmer()),
             useFunctionLogger(),
         ]);
-        // Warm the pool through the real request flow. SST_WARMUP_COUNT=0
+        // Warm SST_WARMUP_COUNT workers through the real request flow. 0
         // turns this off; the count is capped at the pool size so warmup can
         // never hold more isolates than steady state would.
         const { WARMUP_COUNT } = await import("../../runtime/worker-config.js");

package/cli/local/server.js

@@ -103,11 +103,19 @@ export async function useLocalServer(opts) {
     const wss = new WebSocketServer({ noServer: true });
     const wss2 = new WebSocketServer({ noServer: true });
     const sockets = new Set();
+    // Replayed to console clients on connect. Bounded: every entry keeps its
+    // full event payload and every log line, so an unbounded list grows for the
+    // life of the dev session.
+    const MAX_INVOCATIONS = 200;
     let invocations = [];
     function publish(invocation) {
         const index = invocations.findLastIndex((i) => i.id === invocation.id);
-        if (index < 0)
+        if (index < 0) {
             invocations.push(invocation);
+            if (invocations.length > MAX_INVOCATIONS) {
+                invocations.splice(0, invocations.length - MAX_INVOCATIONS);
+            }
+        }
         else
             invocations[index] = invocation;
         const json = JSON.stringify({

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.8-ig.2",
+  "version": "2.49.8-ig.3",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/dev-env-overrides.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Keys of the `sst dev` process environment that override the environment a
+ * deployed stub forwards with each invocation.
+ *
+ * The stub Lambda snapshots ITS OWN `process.env` and sends it along
+ * (`support/bridge/live-lambda.ts`), and the local worker runs with exactly
+ * that map. So anything a developer wants to change per session — which
+ * database, which frontend — either had to be on the stub's function config
+ * (a CloudFormation update of every stub each time it changed) or could not
+ * reach the handler at all.
+ *
+ * `SST_DEV_ENV_OVERRIDES=KEY1,KEY2` names the keys the dev process supplies
+ * instead. Only listed keys that are set in the dev process are applied; the
+ * rest of the stub's environment (AWS credentials, function metadata) stays
+ * as forwarded.
+ */
+export declare const SST_DEV_ENV_OVERRIDES_KEY = "SST_DEV_ENV_OVERRIDES";
+export declare function devEnvOverrides(env?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function applyDevEnvOverrides(forwarded: Record<string, string> | undefined, env?: NodeJS.ProcessEnv): Record<string, string>;

package/runtime/dev-env-overrides.js

@@ -0,0 +1,32 @@
+/**
+ * Keys of the `sst dev` process environment that override the environment a
+ * deployed stub forwards with each invocation.
+ *
+ * The stub Lambda snapshots ITS OWN `process.env` and sends it along
+ * (`support/bridge/live-lambda.ts`), and the local worker runs with exactly
+ * that map. So anything a developer wants to change per session — which
+ * database, which frontend — either had to be on the stub's function config
+ * (a CloudFormation update of every stub each time it changed) or could not
+ * reach the handler at all.
+ *
+ * `SST_DEV_ENV_OVERRIDES=KEY1,KEY2` names the keys the dev process supplies
+ * instead. Only listed keys that are set in the dev process are applied; the
+ * rest of the stub's environment (AWS credentials, function metadata) stays
+ * as forwarded.
+ */
+export const SST_DEV_ENV_OVERRIDES_KEY = "SST_DEV_ENV_OVERRIDES";
+export function devEnvOverrides(env = process.env) {
+    const list = env[SST_DEV_ENV_OVERRIDES_KEY];
+    if (!list)
+        return {};
+    const overrides = {};
+    for (const key of list.split(",").map((k) => k.trim()).filter(Boolean)) {
+        const value = env[key];
+        if (value !== undefined)
+            overrides[key] = value;
+    }
+    return overrides;
+}
+export function applyDevEnvOverrides(forwarded, env = process.env) {
+    return { ...(forwarded ?? {}), ...devEnvOverrides(env) };
+}

package/runtime/handlers/node.js

@@ -14,6 +14,7 @@ import { findAbove } from "../../util/fs.js";
 import { useMonoBuildConfig } from "../mono-build-config.js";
 import { SOURCE_MAPS, WORKER_MAX_HEAP_MB } from "../worker-config.js";
 import { forgetWorkerMemory, recordWorkerMemory } from "../memory-logging.js";
+import { applyDevEnvOverrides } from "../dev-env-overrides.js";
 export const useNodeHandler = () => {
     const rebuildCache = {};
     process.on("exit", () => {
@@ -39,7 +40,7 @@ export const useNodeHandler = () => {
             const workers = await useRuntimeWorkers();
             const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
                 env: {
-                    ...input.environment,
+                    ...applyDevEnvOverrides(input.environment),
                     IS_LOCAL: "true",
                 },
                 // Source maps cost memory in every isolate; opt in with SST_SOURCE_MAPS=true

package/runtime/server.js

@@ -9,6 +9,7 @@ import { lazy } from "../util/lazy.js";
 import { getRequestPath } from "./request-utils.js";
 import { logServer } from "./debug-bridge-logging.js";
 import { logEventTrace } from "./event-trace-logging.js";
+import { applyDevEnvOverrides } from "./dev-env-overrides.js";
 export const useRuntimeServerConfig = lazy(async () => {
     const port = await getPort({
         port: 12557,
@@ -128,7 +129,8 @@ export const useRuntimeServer = lazy(async () => {
         // This prevents env leakage when workers are reused across different functions
         res.json({
             event: payload.event,
-            env: payload.env,
+            // The dev process's own axes win over what the stub forwarded.
+            env: applyDevEnvOverrides(payload.env),
         });
     });
     app.post(`/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`, express.json({

package/runtime/worker-config.d.ts

@@ -8,7 +8,7 @@ export declare const POOL_SIZE: number;
 export declare const IDLE_TIMEOUT: number;
 /** Invocations one Node worker may run at the same time. */
 export declare const WORKER_CONCURRENCY: number;
-/** Warm pings sent at dev start. 0 disables warmup. Capped at POOL_SIZE. */
+/** Workers to warm at dev start. 0 disables warmup. Capped at POOL_SIZE. */
 export declare const WARMUP_COUNT: number;
 /** V8 old-space cap for each Node worker thread, in MB. 0 leaves it unbounded. */
 export declare const WORKER_MAX_HEAP_MB: number;

package/runtime/worker-config.js

@@ -14,9 +14,9 @@ export const POOL_SIZE = int("SST_WORKER_POOL_SIZE", 4);
 /** How long an idle worker is kept before it is terminated. */
 export const IDLE_TIMEOUT = int("SST_WORKER_IDLE_TIMEOUT", 5 * 60 * 1000);
 /** Invocations one Node worker may run at the same time. */
-export const WORKER_CONCURRENCY = Math.max(1, int("SST_WORKER_CONCURRENCY", 5));
-/** Warm pings sent at dev start. 0 disables warmup. Capped at POOL_SIZE. */
-export const WARMUP_COUNT = Math.min(POOL_SIZE, Math.max(0, int("SST_WARMUP_COUNT", POOL_SIZE)));
+export const WORKER_CONCURRENCY = Math.max(1, int("SST_WORKER_CONCURRENCY", 10));
+/** Workers to warm at dev start. 0 disables warmup. Capped at POOL_SIZE. */
+export const WARMUP_COUNT = Math.min(POOL_SIZE, Math.max(0, int("SST_WARMUP_COUNT", 1)));
 /** V8 old-space cap for each Node worker thread, in MB. 0 leaves it unbounded. */
 export const WORKER_MAX_HEAP_MB = int("SST_WORKER_MAX_HEAP_MB", 1024);
 /** Run Node workers with --enable-source-maps (costs memory per worker). */

package/runtime/worker-pool.d.ts

@@ -52,9 +52,12 @@ export declare class WorkerPool {
     liveCount(poolKey: string): number;
     canCreate(poolKey: string): boolean;
     /**
-     * Least-loaded live worker with spare capacity, or undefined. Workers whose
-     * bundle is older than `currentMtime` are retired on the way: idle ones now,
-     * busy ones once they drain.
+     * The busiest live worker that still has spare capacity, or undefined.
+     * Packing invocations into as few workers as possible is what keeps memory
+     * down: every worker that serves traffic grows to hold the handlers it has
+     * loaded, so an idle spare is a few hundred MB doing nothing. Workers whose
+     * bundle is older than `currentMtime` are retired on the way: idle ones
+     * now, busy ones once they drain.
      */
     pick(poolKey: string, currentMtime?: number): PoolWorker | undefined;
     /** Hand an invocation to a worker. */

package/runtime/worker-pool.js

@@ -44,9 +44,12 @@ export class WorkerPool {
         return this.liveCount(poolKey) < this.opts.maxWorkers;
     }
     /**
-     * Least-loaded live worker with spare capacity, or undefined. Workers whose
-     * bundle is older than `currentMtime` are retired on the way: idle ones now,
-     * busy ones once they drain.
+     * The busiest live worker that still has spare capacity, or undefined.
+     * Packing invocations into as few workers as possible is what keeps memory
+     * down: every worker that serves traffic grows to hold the handlers it has
+     * loaded, so an idle spare is a few hundred MB doing nothing. Workers whose
+     * bundle is older than `currentMtime` are retired on the way: idle ones
+     * now, busy ones once they drain.
      */
     pick(poolKey, currentMtime) {
         const pool = this.pools.get(poolKey);
@@ -66,7 +69,7 @@ export class WorkerPool {
                 continue;
             if (worker.inFlight >= worker.maxConcurrency)
                 continue;
-            if (!best || worker.inFlight < best.inFlight)
+            if (!best || worker.inFlight > best.inFlight)
                 best = worker;
         }
         return best;

package/runtime/workers.d.ts

@@ -71,16 +71,20 @@ export declare const useRuntimeWorkers: () => Promise<{
         cb: (payload: any) => void;
     };
     /**
-     * Warm the pool by invoking a Node function with warm pings.
+     * Warm `workersToWarm` pooled workers by invoking a Node function with
+     * concurrent warm pings.
      *
      * Each ping is marked as a fan-out *child* (`__WARMER_INVOCATION__ > 1`)
      * so the app's lambda-warmer preloads its handlers and returns instead of
      * fanning out to `concurrency` more Lambdas, which is what turned the old
-     * 30 pings into ~900 worker creations. The count is capped at the pool
-     * size, and pings go through the normal pool path, so warmup can never
-     * hold more isolates than steady state.
+     * 30 pings into ~900 worker creations. Pings go through the normal pool
+     * path, so warmup can never hold more isolates than steady state.
+     *
+     * In mono-build mode this waits for the bundle to settle first: dev start
+     * kicks off the bundle's first watch build, and a worker loaded before it
+     * lands is retired as stale seconds later, which wasted every warm worker.
      */
-    triggerWarmup(count: number): Promise<{
+    triggerWarmup(workersToWarm: number): Promise<{
         warmed: number;
         elapsed?: undefined;
     } | {

package/runtime/workers.js

@@ -137,6 +137,44 @@ function isPoolableRuntime(runtime, env) {
     return (POOLABLE_RUNTIMES.has(runtime) ||
         [...POOLABLE_RUNTIMES].some((r) => runtime.startsWith(r)));
 }
+/**
+ * Resolve once `.mono-build/.last-rebuild` exists and has not changed for
+ * `quietMs`. No-op when mono-build is off. Gives up after `maxWaitMs`.
+ *
+ * Dev start writes the timestamp twice about 7s apart (the app's initial
+ * rebuild, then the watcher's first pass), so the quiet window has to be
+ * longer than that gap or the warm worker is retired as stale right away.
+ */
+async function waitForStableBundle(quietMs = 10_000, maxWaitMs = 120_000) {
+    const config = useMonoBuildConfig();
+    const timestampFile = path.join(config.dir, ".last-rebuild");
+    const started = Date.now();
+    let last;
+    let lastChange = Date.now();
+    while (Date.now() - started < maxWaitMs) {
+        if (!config.enabled) {
+            // Not (yet) a mono-build project; nothing to wait for unless it appears
+            if (Date.now() - started > quietMs)
+                return;
+        }
+        else {
+            let current;
+            try {
+                current = fs.readFileSync(timestampFile, "utf-8");
+            }
+            catch { }
+            if (current !== last) {
+                last = current;
+                lastChange = Date.now();
+            }
+            else if (current !== undefined && Date.now() - lastChange >= quietMs) {
+                return;
+            }
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    logPool("WARMUP_BUNDLE_TIMEOUT", { waitedMs: Date.now() - started });
+}
 /** Only the Node runtime shim knows how to run invocations side by side. */
 function concurrencyFor(runtime) {
     return runtime.startsWith("nodejs") ? WORKER_CONCURRENCY : 1;
@@ -689,19 +727,25 @@ export const useRuntimeWorkers = lazy(async () => {
         stats,
         subscribe: bus.forward("worker.started", "worker.stopped", "worker.exited", "worker.stdout", "worker.reused"),
         /**
-         * Warm the pool by invoking a Node function with warm pings.
+         * Warm `workersToWarm` pooled workers by invoking a Node function with
+         * concurrent warm pings.
          *
          * Each ping is marked as a fan-out *child* (`__WARMER_INVOCATION__ > 1`)
          * so the app's lambda-warmer preloads its handlers and returns instead of
          * fanning out to `concurrency` more Lambdas, which is what turned the old
-         * 30 pings into ~900 worker creations. The count is capped at the pool
-         * size, and pings go through the normal pool path, so warmup can never
-         * hold more isolates than steady state.
+         * 30 pings into ~900 worker creations. Pings go through the normal pool
+         * path, so warmup can never hold more isolates than steady state.
+         *
+         * In mono-build mode this waits for the bundle to settle first: dev start
+         * kicks off the bundle's first watch build, and a worker loaded before it
+         * lands is retired as stale seconds later, which wasted every warm worker.
          */
-        async triggerWarmup(count) {
-            count = Math.min(count, POOL_SIZE);
-            if (count <= 0)
+        async triggerWarmup(workersToWarm) {
+            workersToWarm = Math.min(workersToWarm, POOL_SIZE);
+            if (workersToWarm <= 0)
                 return { warmed: 0 };
+            const count = workersToWarm * WORKER_CONCURRENCY;
+            await waitForStableBundle();
             const functions = useFunctions();
             const allFunctions = functions.all;
             // Find a nodejs function to use as the warmup target
@@ -721,7 +765,7 @@ export const useRuntimeWorkers = lazy(async () => {
                 return { warmed: 0 };
             }
             const { functionName } = targetFunction;
-            logPool("WARMUP_START", { count, functionName });
+            logPool("WARMUP_START", { count, workersToWarm, functionName });
             bus.publish("warmup.start", { count });
             const startTime = Date.now();
             let success = 0;

package/stacks/build.js

@@ -1,6 +1,7 @@
 import esbuild from "esbuild";
 import fs from "fs/promises";
 import path from "path";
+import crypto from "crypto";
 import { dynamicImport } from "../util/module.js";
 import { findAbove } from "../util/fs.js";
 import { VisibleError } from "../error.js";
@@ -9,6 +10,14 @@ const _ = await import("@babel/generator");
 const generate = _.default?.default ?? _.default;
 // @ts-expect-error
 import ts from "@babel/plugin-syntax-typescript";
+/**
+ * The last config module we imported, keyed by the hash of its bundled
+ * source. An ES module can never be unloaded, so every `import()` of a fresh
+ * `.sst.config.<time>.mjs` stays in memory for the life of `sst dev`. Dev
+ * rebuilds the config on every change to a file inside its bundle (all the
+ * stack code), so reuse the module when the bundle did not actually change.
+ */
+let cached;
 export async function load(input, shallow) {
     const parsed = path.parse(input);
     const root = await findAbove(input, "package.json");
@@ -81,6 +90,7 @@ export async function load(input, shallow) {
             ],
             absWorkingDir: root,
             outfile,
+            write: false,
             banner: {
                 js: [
                     `import { createRequire as topLevelCreateRequire } from 'module';`,
@@ -97,12 +107,19 @@ export async function load(input, shallow) {
             //  },
             entryPoints: [input],
         });
-        // Logger.debug("built", input);
+        const output = result.outputFiles?.find((f) => f.path === outfile) ?? result.outputFiles?.[0];
+        if (!output)
+            throw new VisibleError("Config build produced no output");
+        const hash = crypto.createHash("sha256").update(output.contents).digest("hex");
+        if (cached && cached.hash === hash && cached.shallow === Boolean(shallow)) {
+            return [cached.metafile, cached.mod];
+        }
+        await fs.writeFile(outfile, output.contents);
         const mod = await dynamicImport(outfile);
-        // Logger.debug("imported", input);
         await fs.rm(outfile, {
             force: true,
         });
+        cached = { hash, metafile: result.metafile, mod: mod.default, shallow: Boolean(shallow) };
         if (!mod.default?.config)
             throw new VisibleError(`The config file is improperly formatted.`, `Example:`, `export default {`, `  config() {`, `    return {`, `      name: "my-app",`, `      region: "us-east-1"`, `    }`, `  },`, `  stacks(app) {`, `  }`, `}`);
         return [result.metafile, mod.default];