@intelligems/sst 2.49.6-ig.7 → 2.49.6-ig.9

package/cli/commands/dev.js

@@ -151,23 +151,11 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 if (info.enableLiveDev === false)
                     return;
                 Colors.gap();
-                Colors.line(Colors.danger("═".repeat(60)));
-                Colors.line(Colors.danger("  FUNCTION BUILD FAILED - SST IS EXITING"));
-                Colors.line(Colors.danger("═".repeat(60)));
-                Colors.gap();
-                Colors.line(Colors.danger("✖ "), "Handler:", info.handler);
-                Colors.line(Colors.danger("✖ "), "Function ID:", evt.properties.functionID);
-                Colors.gap();
-                Colors.line(Colors.danger("  Errors:"));
+                Colors.line(Colors.danger("✖ "), "Build failed", info.handler);
                 for (const line of evt.properties.errors) {
-                    Colors.line(Colors.danger("    → "), line);
+                    Colors.line("  ", line);
                 }
                 Colors.gap();
-                Colors.line(Colors.danger("═".repeat(60)));
-                Colors.line(Colors.danger("  Fix the error above and restart `sst dev`"));
-                Colors.line(Colors.danger("═".repeat(60)));
-                Colors.gap();
-                process.exit(1);
             });
             bus.subscribe("function.success", async (evt) => {
                 // Skip warmup request logs

package/iot.d.ts

@@ -4,4 +4,35 @@ export declare const useIOT: () => Promise<{
     prefix: string;
     publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
 }>;
+/**
+ * A second connection, carrying only small control messages.
+ *
+ * `useIOT` also carries response bodies. Those are fragmented into 50KB chunks
+ * and published at QoS 1, so every chunk waits on a broker round trip, and they
+ * queue on the same socket as everything else.
+ *
+ * `function.ack` cannot afford to wait behind them. The Lambda re-invokes if the
+ * ack does not arrive within two seconds, and each re-invocation re-runs the
+ * handler and puts another response body on the socket that is already busy —
+ * so a late ack makes the next ack later still. Measured on one machine before
+ * this change: ack publish went from 105ms to 10.2s inside a minute, publishes
+ * in flight from 15 to 439, and a single request executed fifteen times before
+ * the gateway returned 504 at 29s.
+ *
+ * Round-trip latency decides who sees it. A chunk costs a round trip to the
+ * region — roughly 90ms from Europe against 15ms from the US — so the same
+ * payload lands either side of the two second budget depending on where the
+ * developer sits.
+ *
+ * **The client id must differ from `useIOT`'s.** AWS IoT drops an existing
+ * connection when a new one presents the same id, so a shared id would make the
+ * two sockets disconnect each other in a loop.
+ *
+ * This connection deliberately does not subscribe. Inbound traffic still arrives
+ * on `useIOT`; this one only publishes.
+ */
+export declare const useIOTControl: () => Promise<{
+    prefix: string;
+    publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
+}>;
 export declare const isSupported: () => boolean;

package/iot.js

@@ -22,6 +22,59 @@ import { useBus } from "./bus.js";
 import { useProject } from "./project.js";
 import { useBootstrap } from "./bootstrap.js";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+/**
+ * Re-sign the next reconnect with credentials that are still alive.
+ *
+ * The device is built with resolved credential *values*, because
+ * `aws-iot-device-sdk` takes strings rather than a provider. It keeps them in
+ * closure variables and re-signs the WebSocket URL from those on every
+ * reconnect, and nothing ever writes to them again except this call. So once
+ * the session expires, every retry presents a dead `sessionToken`, AWS IoT
+ * rejects the upgrade, and the socket closes again — forever.
+ *
+ * Measured on one machine: the connection dropped routinely five times in the
+ * first fifteen minutes and recovered each time; an hour later the credentials
+ * expired, and the next drop began **93 consecutive failed reconnects over five
+ * hours**, none of which emitted an `error` event. Nothing in the CLI said
+ * anything, and every request through the Live Lambda bridge 504'd.
+ *
+ * Every other AWS call in the process is unaffected, because `useAWSClient`
+ * passes the *provider* and the SDK calls it per request. This is the one path
+ * that holds values, so it is the one path that needs telling.
+ *
+ * **Why `close` and not `reconnect`.** The signing is synchronous and this
+ * refresh is not, so the two race. `emit("reconnect")` runs its handlers and
+ * returns — it does not await them — and `_setupStream()` signs on the next
+ * line, from whatever the variables hold at that instant. A refresh started
+ * there always loses. `close` fires one backoff interval earlier (the SDK
+ * manages its own, from `baseReconnectTimeMs` of 1s up to 128s, ignoring the
+ * `reconnectPeriod` passed in), which is ample for the resolve to land before
+ * the next attempt signs.
+ *
+ * So this wins the race by margin, not by construction. Two things bound it:
+ * `close` fires on **every** failed reconnect, not once per outage, so the
+ * values can never be more than one backoff interval stale; and the retry loop
+ * is unconditional. Making it airtight would mean keeping the stored
+ * credentials warm so the synchronous path can never read a stale one — a
+ * timer, which is machinery duplicating what the memoized provider already
+ * does. Measured recovery is five seconds, so that is not worth it yet.
+ *
+ * The provider only reaches the network within five minutes of expiry, so this
+ * is an in-memory read on most drops and one real refresh per session.
+ */
+async function refreshWebSocketCredentials(device, label) {
+    try {
+        const fresh = await useAWSCredentials();
+        // The typings mark `expiration` as required, but the implementation only
+        // assigns the three credential strings and never reads it — so this passes
+        // what the provider gave rather than inventing a date to satisfy a
+        // parameter nothing uses.
+        device.updateWebSocketCredentials(fresh.accessKeyId, fresh.secretAccessKey, fresh.sessionToken, fresh.expiration);
+    }
+    catch (err) {
+        Logger.debug(`${label} credential refresh failed`, err);
+    }
+}
 export const useIOT = lazy(async () => {
     const bus = useBus();
     const endpoint = await useIOTEndpoint();
@@ -116,6 +169,7 @@ export const useIOT = lazy(async () => {
     });
     device.on("close", () => {
         Logger.debug("IoT closed");
+        void refreshWebSocketCredentials(device, "IoT");
     });
     device.on("reconnect", () => {
         Logger.debug("IoT reconnecting...");
@@ -189,6 +243,86 @@ export const useIOT = lazy(async () => {
         },
     };
 });
+/**
+ * A second connection, carrying only small control messages.
+ *
+ * `useIOT` also carries response bodies. Those are fragmented into 50KB chunks
+ * and published at QoS 1, so every chunk waits on a broker round trip, and they
+ * queue on the same socket as everything else.
+ *
+ * `function.ack` cannot afford to wait behind them. The Lambda re-invokes if the
+ * ack does not arrive within two seconds, and each re-invocation re-runs the
+ * handler and puts another response body on the socket that is already busy —
+ * so a late ack makes the next ack later still. Measured on one machine before
+ * this change: ack publish went from 105ms to 10.2s inside a minute, publishes
+ * in flight from 15 to 439, and a single request executed fifteen times before
+ * the gateway returned 504 at 29s.
+ *
+ * Round-trip latency decides who sees it. A chunk costs a round trip to the
+ * region — roughly 90ms from Europe against 15ms from the US — so the same
+ * payload lands either side of the two second budget depending on where the
+ * developer sits.
+ *
+ * **The client id must differ from `useIOT`'s.** AWS IoT drops an existing
+ * connection when a new one presents the same id, so a shared id would make the
+ * two sockets disconnect each other in a loop.
+ *
+ * This connection deliberately does not subscribe. Inbound traffic still arrives
+ * on `useIOT`; this one only publishes.
+ */
+export const useIOTControl = lazy(async () => {
+    const bus = useBus();
+    const endpoint = await useIOTEndpoint();
+    const creds = await useAWSCredentials();
+    const project = useProject();
+    const device = new iot.device({
+        protocol: "wss",
+        host: endpoint,
+        region: project.config.region,
+        accessKeyId: creds.accessKeyId,
+        secretKey: creds.secretAccessKey,
+        sessionToken: creds.sessionToken,
+        reconnectPeriod: 1,
+        keepalive: 60,
+        clientId: `sst-control-${Math.random().toString(16).slice(2)}`,
+    });
+    const PREFIX = `/sst/${project.config.name}/${project.config.stage}`;
+    device.on("connect", () => {
+        Logger.debug("IoT control connected");
+    });
+    device.on("error", (err) => {
+        Logger.debug("IoT control error", err);
+    });
+    device.on("close", () => {
+        Logger.debug("IoT control closed");
+        void refreshWebSocketCredentials(device, "IoT control");
+    });
+    device.on("reconnect", () => {
+        Logger.debug("IoT control reconnecting...");
+    });
+    return {
+        prefix: PREFIX,
+        async publish(topic, type, properties) {
+            const payload = {
+                type,
+                properties,
+                sourceID: bus.sourceID,
+            };
+            // Control messages sit far below the fragment size, but the envelope has
+            // to match what the Lambda reassembles, so it is built the same way
+            // rather than assumed to be a single part.
+            const json = JSON.stringify(payload);
+            const parts = json.match(/.{1,50000}/g) ?? [];
+            const id = Math.random().toString();
+            await Promise.all(parts.map((data, index) => new Promise((r) => {
+                device.publish(topic, JSON.stringify({ id, index, count: parts.length, data }), { qos: 1 }, () => {
+                    r();
+                });
+            })));
+            Logger.debug("IOT Control Published", topic, type);
+        },
+    };
+});
 export const isSupported = () => [
     "eu-central-1",
     "eu-west-1",

package/package.json

@@ -1,13 +1,19 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.7",
+  "version": "2.49.6-ig.9",
   "bin": {
     "sst": "cli/sst.js"
   },
   "description": "A CLI to help deploy SST apps.",
   "type": "module",
   "license": "MIT",
+  "scripts": {
+    "prepare": "",
+    "build": "node build.mjs && tsc",
+    "test": "vitest run",
+    "dev": "source .env && tsc-watch --onSuccess \"rsync -av dist/* ${TO} --checksum\""
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sst/v2.git",
@@ -142,10 +148,5 @@
     "test": "test"
   },
   "keywords": [],
-  "author": "",
-  "scripts": {
-    "build": "node build.mjs && tsc",
-    "test": "vitest run",
-    "dev": "source .env && tsc-watch --onSuccess \"rsync -av dist/* ${TO} --checksum\""
-  }
-}
+  "author": ""
+}

package/package.json.bak

@@ -5,7 +5,7 @@
   },
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.7",
+  "version": "2.49.6-ig.9",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/iot.js

@@ -1,5 +1,5 @@
 import { useBus } from "../bus.js";
-import { useIOT } from "../iot.js";
+import { useIOT, useIOTControl } from "../iot.js";
 import { lazy } from "../util/lazy.js";
 import { logInvokeTrace } from "./worker-pool-logging.js";
 import { logIot } from "./debug-bridge-logging.js";
@@ -7,6 +7,9 @@ import { logEventTrace } from "./event-trace-logging.js";
 export const useIOTBridge = lazy(async () => {
     const bus = useBus();
     const iot = await useIOT();
+    // The ack goes out on its own socket so it can never queue behind a response
+    // body. See `useIOTControl`.
+    const control = await useIOTControl();
     const topic = `${iot.prefix}/events`;
     bus.subscribe("function.success", async (evt) => {
         const { workerID, requestID } = evt.properties;
@@ -27,7 +30,7 @@ export const useIOTBridge = lazy(async () => {
         logIot(`reqId=${requestID?.slice(0, 8)} Publishing function.ack to worker ${workerID.slice(0, 8)}`);
         logInvokeTrace("IOT_ACK_START", workerID, `worker=${workerID.slice(0, 8)}`);
         const startTime = Date.now();
-        await iot.publish(topic + "/" + workerID, "function.ack", evt.properties);
+        await control.publish(topic + "/" + workerID, "function.ack", evt.properties);
         const elapsed = Date.now() - startTime;
         logIot(`reqId=${requestID?.slice(0, 8)} function.ack published in ${elapsed}ms`);
         logInvokeTrace("IOT_ACK_DONE", workerID, `worker=${workerID.slice(0, 8)}`);

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 SST
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.