@intelligems/sst 2.49.3 → 2.49.6-ig.10

package/support/nodejs-runtime/index.mjs

@@ -6,11 +6,32 @@ import path from "path";
 import fs from "fs";
 import http from "http";
 import url from "url";
+import os from "os";
+try {
+  const mod = await import("node:module");
+  if (typeof mod.enableCompileCache === "function") {
+    const cacheDir = path.join(os.tmpdir(), "sst-compile-cache");
+    mod.enableCompileCache(cacheDir);
+  }
+} catch {
+}
 var input = workerData;
-var parsed = path.parse(input.handler);
-var file = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((file2) => {
-  return fs.existsSync(file2);
-});
+var monoBundlePath = path.join(input.out, "index.mjs");
+var useMonoBundle = input.isMonoBuild ?? (input.handler === "index.handler" && fs.existsSync(monoBundlePath));
+var file;
+var handlerName;
+if (useMonoBundle) {
+  file = monoBundlePath;
+  handlerName = "handler";
+} else {
+  const parsed = path.parse(input.handler);
+  const foundFile = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((f) => fs.existsSync(f));
+  if (!foundFile) {
+    throw new Error(`Could not find handler file for "${input.handler}"`);
+  }
+  file = foundFile;
+  handlerName = parsed.ext.substring(1);
+}
 var fn;
 function fetch(req) {
   return new Promise((resolve, reject) => {
@@ -44,13 +65,15 @@ function fetch(req) {
 try {
   const { href } = url.pathToFileURL(file);
   const mod = await import(href);
-  const handler = parsed.ext.substring(1);
-  fn = mod[handler];
+  fn = mod[handlerName];
   if (!fn) {
     throw new Error(
-      `Function "${handler}" not found in "${input.handler}". Found ${Object.keys(mod).join(", ")}`
+      useMonoBundle ? `Mono-bundle handler "${handlerName}" not found in "${file}". Found: ${Object.keys(mod).join(", ")}` : `Function "${handlerName}" not found in "${input.handler}". Found: ${Object.keys(mod).join(", ")}`
     );
   }
+  if (useMonoBundle && mod.warmUp) {
+    await mod.warmUp();
+  }
 } catch (ex) {
   await fetch({
     path: `/runtime/init/error`,
@@ -97,6 +120,15 @@ while (true) {
       method: "GET",
       headers: {}
     });
+    const sstFunctionId = result.headers["lambda-runtime-sst-function-id"];
+    if (sstFunctionId) {
+      process.env.SST_FUNCTION_ID = sstFunctionId;
+    }
+    const parsed = JSON.parse(result.body);
+    const invocationEnv = parsed.env;
+    if (invocationEnv && typeof invocationEnv === "object") {
+      Object.assign(process.env, invocationEnv);
+    }
     context = {
       awsRequestId: result.headers["lambda-runtime-aws-request-id"],
       invokedFunctionArn: result.headers["lambda-runtime-invoked-function-arn"],
@@ -108,9 +140,10 @@ while (true) {
       identity: JSON.parse(result.headers["lambda-runtime-cognito-identity"]) ?? void 0,
       // If clientContext is null, we want to mimick AWS behavior and return undefined
       clientContext: JSON.parse(result.headers["lambda-runtime-client-context"]) ?? void 0,
-      functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
-      functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION,
-      memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,
+      // Per-invocation function context from headers (essential for mono-build shared workers)
+      functionName: result.headers["lambda-runtime-function-name"] || process.env.AWS_LAMBDA_FUNCTION_NAME,
+      functionVersion: result.headers["lambda-runtime-function-version"] || process.env.AWS_LAMBDA_FUNCTION_VERSION,
+      memoryLimitInMB: result.headers["lambda-runtime-function-memory-size"] || process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,
       logGroupName: result.headers["lambda-runtime-log-group-name"],
       logStreamName: result.headers["lambda-runtime-log-stream-name"],
       callbackWaitsForEmptyEventLoop: {
@@ -139,7 +172,7 @@ while (true) {
         );
       }
     };
-    request = JSON.parse(result.body);
+    request = parsed.event;
   } catch {
     continue;
   }

package/support/python-runtime/runtime.py

@@ -4,8 +4,9 @@ import json
 import logging
 import argparse
 import traceback
-from urllib import request, parse
-from time import strftime, time
+import signal
+from urllib import request
+from time import time
 from importlib import import_module
 
 class Identity(object):
@@ -22,15 +23,15 @@ class ClientContext(object):
 
 class Context(object):
     def __init__(self, invoked_function_arn, aws_request_id, deadline_ms, identity, client_context, log_group_name, log_stream_name):
-        self.function_name = os.environ['AWS_LAMBDA_FUNCTION_NAME']
+        self.function_name = os.environ.get('AWS_LAMBDA_FUNCTION_NAME', 'local')
         self.invoked_function_arn = invoked_function_arn
         self.aws_request_id = aws_request_id
-        self.memory_limit_in_mb = os.environ['AWS_LAMBDA_FUNCTION_MEMORY_SIZE']
+        self.memory_limit_in_mb = os.environ.get('AWS_LAMBDA_FUNCTION_MEMORY_SIZE', '128')
         self.deadline_ms = deadline_ms
         # If identity is null, we want to mimick AWS behavior and return an object with None values
-        self.identity = Identity(**json.loads(identity)) if identity != 'null' else Identity(cognito_identity_id = None, cognito_identity_pool_id = None)
+        self.identity = Identity(**json.loads(identity)) if identity and identity != 'null' else Identity(cognito_identity_id=None, cognito_identity_pool_id=None)
         # If client_context is null, we want to mimick AWS behavior and return None
-        self.client_context = ClientContext(**json.loads(client_context)) if client_context != 'null' else None
+        self.client_context = ClientContext(**json.loads(client_context)) if client_context and client_context != 'null' else None
         self.log_group_name = log_group_name
         self.log_stream_name = log_stream_name
 
@@ -42,15 +43,17 @@ class Context(object):
 
 
 def handleUnserializable(obj):
-    print(
-        "Unserializable {}: {} when returning result {!r}".format(
-            type(obj), repr(obj), result
-        )
-    )
-
     raise TypeError("Unserializable {}: {!r}".format(type(obj), obj))
 
 
+# Idle timeout handler
+class IdleTimeoutError(Exception):
+    pass
+
+def idle_timeout_handler(signum, frame):
+    raise IdleTimeoutError("Worker idle timeout")
+
+
 logging.basicConfig()
 
 parser = argparse.ArgumentParser(
@@ -64,15 +67,69 @@ parser.add_argument('handler_module',
 parser.add_argument('src_path', help='SrcPath of the handler function')
 parser.add_argument('handler_name', help='Name of the handler function')
 
+# Idle timeout in seconds (15 minutes, matching Node.js runtime)
+IDLE_TIMEOUT = 15 * 60
+
 if __name__ == '__main__':
     args = parser.parse_args()
 
     # this is needed because you need to import from where you've executed sst
     sys.path.append('.')
 
-    # fetch request
-    url = "http://{}/2018-06-01/runtime/invocation/next".format(os.environ['AWS_LAMBDA_RUNTIME_API'])
-    r = request.urlopen(url)
+    # set the sys.path to the src_path. Otherwise importing a local file
+    # would fail with error ModuleNotFoundError
+    sys.path.append(args.src_path)
+
+    # Import handler module once at startup (warm start optimization)
+    handler = None
+    try:
+        # remove leading zeros for relative imports
+        if args.handler_module.startswith('.'):
+            module = import_module(args.handler_module[1:])
+        else:
+            module = import_module(args.handler_module)
+
+        handler = getattr(module, args.handler_name)
+    except Exception as e:
+        # Report init error and exit
+        traceback.print_exc()
+        try:
+            init_error_url = "http://{}/2018-06-01/runtime/init/error".format(
+                os.environ['AWS_LAMBDA_RUNTIME_API']
+            )
+            ex_type, ex_value, ex_traceback = sys.exc_info()
+            error_data = json.dumps({
+                "errorType": ex_type.__name__ if ex_type else "ImportError",
+                "errorMessage": str(ex_value),
+                "trace": traceback.format_tb(ex_traceback) if ex_traceback else [],
+            }).encode("utf-8")
+            req = request.Request(init_error_url, method="POST", data=error_data)
+            req.add_header('Content-Type', 'application/json')
+            request.urlopen(req)
+        except Exception:
+            pass
+        sys.exit(1)
+
+    # Main event loop - handle multiple invocations
+    while True:
+        context = None
+
+        try:
+            # Set up idle timeout using SIGALRM (Unix only)
+            if hasattr(signal, 'SIGALRM'):
+                signal.signal(signal.SIGALRM, idle_timeout_handler)
+                signal.alarm(IDLE_TIMEOUT)
+
+            # Fetch next invocation (blocks until one is available)
+            next_url = "http://{}/2018-06-01/runtime/invocation/next".format(
+                os.environ['AWS_LAMBDA_RUNTIME_API']
+            )
+            r = request.urlopen(next_url)
+
+            # Cancel idle timeout once we have work
+            if hasattr(signal, 'SIGALRM'):
+                signal.alarm(0)
+
     event = json.loads(r.read())
     context = Context(
         r.getheader('Lambda-Runtime-Invoked-Function-Arn'),
@@ -84,44 +141,58 @@ if __name__ == '__main__':
         r.getheader('Lambda-Runtime-Log-Stream-Name')
     )
 
-    # invoke handler
-    has_error = False
+            # Invoke handler
     try:
-        # set the sys.path to the src_path. Other wise importing a local file
-        # would fail with error ModuleNotFoundError
-        sys.path.append(args.src_path)
-
-        # remove leading zeros for relative imports
-        if args.handler_module.startswith('.'):
-          module = import_module(args.handler_module[1:])
-        else: 
-          module = import_module(args.handler_module)
-
-        handler = getattr(module, args.handler_name)
         result = handler(event, context)
         data = json.dumps(result, default=handleUnserializable).encode("utf-8")
-
+                url_destination = '/response'
     except Exception as e:
-        has_error = True
-        # print error in bootstrap because we won't be able to print the Python
-        # stack trace in the correct format in NodeJS
+                # Handler error - report but keep worker alive
         traceback.print_exc()
-        # build error response
         ex_type, ex_value, ex_traceback = sys.exc_info()
-        result = {
-            "errorType": ex_type.__name__,
+                error_result = {
+                    "errorType": ex_type.__name__ if ex_type else "Error",
             "errorMessage": str(ex_value),
-            "trace": traceback.format_tb(ex_traceback),
+                    "trace": traceback.format_tb(ex_traceback) if ex_traceback else [],
         }
-        data = json.dumps(result).encode("utf-8")
-
-    # send response
-    if has_error == False:
-        url_destination = '/response'
-    else:
+                data = json.dumps(error_result).encode("utf-8")
         url_destination = '/error'
-    url = "http://{}/2018-06-01/runtime/invocation/{}{}".format(os.environ['AWS_LAMBDA_RUNTIME_API'], context.aws_request_id, url_destination)
-    req =  request.Request(url, method="POST", data=data)
+
+            # Send response
+            response_url = "http://{}/2018-06-01/runtime/invocation/{}{}".format(
+                os.environ['AWS_LAMBDA_RUNTIME_API'],
+                context.aws_request_id,
+                url_destination
+            )
+            req = request.Request(response_url, method="POST", data=data)
     req.add_header('Content-Type', 'application/json')
-    r = request.urlopen(req, data=data)
 
+            # Retry sending response (matching Node.js behavior)
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    request.urlopen(req)
+                    break
+                except Exception as e:
+                    if attempt < max_retries - 1:
+                        import time as time_module
+                        time_module.sleep(0.5)
+                    else:
+                        print(f"Failed to send response after {max_retries} attempts: {e}", file=sys.stderr)
+
+        except IdleTimeoutError:
+            # Idle timeout - exit gracefully
+            print("Worker idle timeout, exiting", file=sys.stderr)
+            sys.exit(0)
+
+        except KeyboardInterrupt:
+            # Graceful shutdown
+            print("Worker interrupted, exiting", file=sys.stderr)
+            sys.exit(0)
+
+        except Exception as e:
+            # Unexpected error in the runtime loop itself
+            print(f"Runtime error: {e}", file=sys.stderr)
+            traceback.print_exc()
+            # Continue to next iteration - don't crash the worker
+            continue

package/util/user-configuration.js

@@ -1,16 +1,28 @@
-// @ts-nocheck
 import * as os from "os";
 import * as fs_path from "path";
 import * as fs from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
 export const PROJECT_CONFIG = "cdk.json";
 export const USER_DEFAULTS = "~/.cdk.json";
 const CONTEXT_KEY = "context";
-const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-const { ToolkitError } = await import(cdkToolkitPath);
-const { Context, PROJECT_CONTEXT } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "context.js"));
-const { Settings } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "settings.js"));
-const { Tags } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "tags", "index.js"));
+let cdkToolkitPath = "";
+let cdkToolkitUrl = "";
+try {
+    cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
+    cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+}
+catch (e) {
+    // Fallback for test environment where import.meta.resolve is not available
+    const module = await import("module");
+    const require = module.createRequire(import.meta.url);
+    cdkToolkitPath = require.resolve("@aws-cdk/toolkit-lib");
+    cdkToolkitUrl = pathToFileURL(cdkToolkitPath).href;
+}
+const { ToolkitError } = await import(cdkToolkitUrl);
+const { Context, PROJECT_CONTEXT } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "context.js")).href);
+const { Settings } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "settings.js"))
+    .href);
+const { Tags } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "tags", "index.js")).href);
 export var Command;
 (function (Command) {
     Command["LS"] = "ls";

package/README.md

@@ -1,43 +0,0 @@
-# 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)

package/package.json.bak

@@ -1,156 +0,0 @@
-{
-  "publishConfig": {
-    "directory": "dist",
-    "access": "public"
-  },
-  "sideEffects": false,
-  "name": "@intelligems/sst",
-  "version": "2.49.3",
-  "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",
-    "directory": "packages/cli"
-  },
-  "exports": {
-    "./constructs/deprecated": "./constructs/deprecated/index.js",
-    "./constructs/future": "./constructs/future/index.js",
-    "./constructs": "./constructs/index.js",
-    "./context": "./context/index.js",
-    "./node/future/*": "./node/future/*/index.js",
-    "./node/*": "./node/*/index.js",
-    ".": "./index.js",
-    "./*": "./*"
-  },
-  "homepage": "https://sst.dev",
-  "dependencies": {
-    "@aws-cdk/aws-lambda-python-alpha": "2.201.0-alpha.0",
-    "@aws-cdk/cloud-assembly-schema": "44.5.0",
-    "@aws-cdk/cloudformation-diff": "2.182.0",
-    "@aws-cdk/cx-api": "2.201.0",
-    "@aws-cdk/toolkit-lib": "1.1.1",
-    "@aws-crypto/sha256-js": "^5.2.0",
-    "@aws-sdk/client-cloudformation": "3.699.0",
-    "@aws-sdk/client-ecs": "3.699.0",
-    "@aws-sdk/client-eventbridge": "3.699.0",
-    "@aws-sdk/client-iam": "3.699.0",
-    "@aws-sdk/client-iot": "3.699.0",
-    "@aws-sdk/client-iot-data-plane": "3.699.0",
-    "@aws-sdk/client-lambda": "3.699.0",
-    "@aws-sdk/client-rds-data": "3.699.0",
-    "@aws-sdk/client-s3": "3.699.0",
-    "@aws-sdk/client-ssm": "3.699.0",
-    "@aws-sdk/client-sts": "3.699.0",
-    "@aws-sdk/config-resolver": "3.374.0",
-    "@aws-sdk/credential-providers": "3.699.0",
-    "@aws-sdk/middleware-retry": "3.374.0",
-    "@aws-sdk/middleware-signing": "3.451.0",
-    "@aws-sdk/signature-v4-crt": "3.451.0",
-    "@aws-sdk/smithy-client": "3.374.0",
-    "@babel/core": "^7.0.0-0",
-    "@babel/generator": "^7.20.5",
-    "@babel/plugin-syntax-typescript": "^7.21.4",
-    "@smithy/signature-v4": "2.0.16",
-    "@trpc/server": "9.18.0",
-    "adm-zip": "0.5.14",
-    "aws-cdk-lib": "2.201.0",
-    "aws-iot-device-sdk": "^2.2.13",
-    "aws-sdk": "^2.1501.0",
-    "builtin-modules": "3.2.0",
-    "cdk-assets": "3.3.1",
-    "chalk": "^5.2.0",
-    "chokidar": "^3.5.3",
-    "ci-info": "^3.7.0",
-    "colorette": "^2.0.19",
-    "conf": "^10.2.0",
-    "constructs": "10.3.0",
-    "cross-spawn": "^7.0.3",
-    "dendriform-immer-patch-optimiser": "^2.1.0",
-    "dotenv": "^16.0.3",
-    "esbuild": "0.18.13",
-    "express": "^4.18.2",
-    "fast-jwt": "^5.0.5",
-    "get-port": "^6.1.2",
-    "glob": "^10.0.0",
-    "graphql": "*",
-    "graphql-yoga": "^3.9.0",
-    "immer": "9",
-    "ink": "^4.0.0",
-    "ink-spinner": "^5.0.0",
-    "kysely": "^0.25.0",
-    "kysely-codegen": "^0.10.1",
-    "kysely-data-api": "^0.2.1",
-    "minimatch": "^6.1.6",
-    "openid-client": "^5.1.8",
-    "ora": "^6.1.2",
-    "react": "^18.0.0",
-    "remeda": "^1.3.0",
-    "tree-kill": "^1.2.2",
-    "undici": "^5.12.0",
-    "uuid": "^9.0.0",
-    "ws": "^8.11.0",
-    "yargs": "^17.6.2",
-    "zod": "^3.21.4"
-  },
-  "devDependencies": {
-    "dotenv-cli": "^8.0.0",
-    "@aws-sdk/client-api-gateway": "3.699.0",
-    "@aws-sdk/client-cloudfront": "3.699.0",
-    "@aws-sdk/client-codebuild": "3.699.0",
-    "@aws-sdk/client-sqs": "3.699.0",
-    "@aws-sdk/types": "3.451.0",
-    "@graphql-tools/merge": "^8.3.16",
-    "@sls-next/lambda-at-edge": "^3.7.0",
-    "@smithy/types": "4.1.0",
-    "@tsconfig/node16": "^1.0.3",
-    "@tsconfig/node18": "^18.2.2",
-    "@types/adm-zip": "^0.5.0",
-    "@types/async": "^3.2.24",
-    "@types/aws-iot-device-sdk": "^2.2.8",
-    "@types/aws-lambda": "^8.10.128",
-    "@types/babel__core": "^7.1.20",
-    "@types/babel__generator": "^7.6.4",
-    "@types/cross-spawn": "^6.0.2",
-    "@types/express": "^4.17.14",
-    "@types/node": "18.11.9",
-    "@types/react": "^18.0.28",
-    "@types/uuid": "^8.3.4",
-    "@types/ws": "8.5.3",
-    "@types/yargs": "^17.0.13",
-    "archiver": "^5.3.1",
-    "astro-sst": "2.45.1",
-    "async": "^3.2.4",
-    "tsx": "^3.12.1",
-    "typescript": "5.2.2",
-    "vitest": "^0.33.0",
-    "tsc-watch": "^6.2.1"
-  },
-  "peerDependencies": {
-    "@sls-next/lambda-at-edge": "^3.7.0"
-  },
-  "peerDependenciesMeta": {
-    "@sls-next/lambda-at-edge": {
-      "optional": true
-    }
-  },
-  "bugs": {
-    "url": "https://github.com/sst/v2/issues"
-  },
-  "main": "index.js",
-  "directories": {
-    "test": "test"
-  },
-  "keywords": [],
-  "author": ""
-}