sst 2.0.0-rc.39 → 2.0.0-rc.40

package/bootstrap.js

@@ -1,5 +1,7 @@
 import url from "url";
 import path from "path";
+import { bold, dim } from "colorette";
+import { spawn } from "child_process";
 import { DescribeStacksCommand, CloudFormationClient, } from "@aws-sdk/client-cloudformation";
 import { Tags, Stack, RemovalPolicy, App, CfnOutput } from "aws-cdk-lib";
 import { Function, Runtime, Code } from "aws-cdk-lib/aws-lambda";
@@ -16,134 +18,181 @@ import { useAWSClient, useAWSCredentials, useSTSIdentity, } from "./credentials.
 import { VisibleError } from "./error.js";
 import { Logger } from "./logger.js";
 import { Stacks } from "./stacks/index.js";
-import { spawnSync } from "child_process";
 const STACK_NAME = "SSTBootstrap";
 const OUTPUT_VERSION = "Version";
 const OUTPUT_BUCKET = "BucketName";
-const LATEST_VERSION = "5";
+const LATEST_VERSION = "6";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const BootstrapContext = Context.create();
 export const useBootstrap = BootstrapContext.use;
 export async function initBootstrap() {
     Logger.debug("Initializing bootstrap context");
-    await assertCDKToolkit();
-    const status = await (async () => {
-        const status = await load();
-        if (status && status.version === LATEST_VERSION)
-            return status;
-        const project = useProject();
+    let [cdkStatus, sstStatus] = await Promise.all([
+        loadCDKStatus(),
+        loadSSTStatus(),
+    ]);
+    const needToBootstrapCDK = !cdkStatus;
+    const needToBootstrapSST = !sstStatus || sstStatus.version !== LATEST_VERSION;
+    if (needToBootstrapCDK || needToBootstrapSST) {
         const spinner = createSpinner("Deploying bootstrap stack, this only needs to happen once").start();
-        // Create bootstrap stack
-        const app = new App();
-        const stack = new Stack(app, STACK_NAME, {
-            env: {
-                region: project.config.region,
-            },
-        });
-        // Add tags to stack
-        const tags = {};
-        for (const [key, value] of Object.entries(tags)) {
-            Tags.of(app).add(key, value);
+        if (needToBootstrapCDK) {
+            await bootstrapCDK();
         }
-        // Create S3 bucket to store stacks metadata
-        const bucket = new Bucket(stack, project.config.region, {
-            encryption: BucketEncryption.S3_MANAGED,
-            removalPolicy: RemovalPolicy.DESTROY,
-            autoDeleteObjects: true,
-            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
-        });
-        // Create Function and subscribe to CloudFormation events
-        const fn = new Function(stack, "MetadataHandler", {
-            code: Code.fromAsset(path.resolve(__dirname, "support/bootstrap-metadata-function")),
-            handler: "index.handler",
-            runtime: Runtime.NODEJS_18_X,
-            initialPolicy: [
-                new PolicyStatement({
-                    actions: ["cloudformation:DescribeStacks"],
-                    resources: ["*"],
-                }),
-                new PolicyStatement({
-                    actions: ["s3:PutObject", "s3:DeleteObject"],
-                    resources: [bucket.bucketArn + "/*"],
-                }),
-                new PolicyStatement({
-                    actions: ["iot:Publish"],
-                    resources: [
-                        `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`,
-                    ],
-                }),
-            ],
-        });
-        const queue = new Queue(stack, "MetadataQueue");
-        fn.addEventSource(new SqsEventSource(queue));
-        const rule = new Rule(stack, "MetadataRule", {
-            eventPattern: {
-                source: ["aws.cloudformation"],
-                detailType: ["CloudFormation Stack Status Change"],
-                detail: {
-                    "status-details": {
-                        status: [
-                            "CREATE_COMPLETE",
-                            "UPDATE_COMPLETE",
-                            "UPDATE_ROLLBACK_COMPLETE",
-                            "ROLLBACK_COMPLETE",
-                            "DELETE_COMPLETE",
-                        ],
-                    },
-                },
-            },
-        });
-        rule.addTarget(new SqsQueue(queue, {
-            retryAttempts: 10,
-        }));
-        // Create stack outputs to store bootstrap stack info
-        new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
-        new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
-        // Deploy bootstrap stack
-        const asm = app.synth();
-        const result = await Stacks.deploy(asm.stacks[0]);
-        if (Stacks.isFailed(result.status)) {
-            throw new VisibleError(`Failed to deploy bootstrap stack:\n${JSON.stringify(result.errors, null, 4)}`);
+        if (needToBootstrapSST) {
+            await bootstrapSST();
+            // fetch bootstrap status
+            sstStatus = await loadSSTStatus();
+            if (!sstStatus)
+                throw new VisibleError("Failed to load bootstrap stack status");
         }
         spinner.succeed();
-        // Fetch bootstrap status
-        const ret = await load();
-        if (!ret)
-            throw new VisibleError("Failed to load bootstrap stack status");
-        return ret;
-    })();
-    BootstrapContext.provide(status);
-    Logger.debug("Bootstrap context initialized", status);
+    }
+    BootstrapContext.provide(sstStatus);
+    Logger.debug("Bootstrap context initialized", sstStatus);
 }
-async function assertCDKToolkit() {
+async function loadCDKStatus() {
     const client = useAWSClient(CloudFormationClient);
-    const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
-        StackName: "CDKToolkit",
+    try {
+        const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
+            StackName: "CDKToolkit",
+        }));
+        if (stacks && stacks.length > 0 && [
+            "CREATE_COMPLETE",
+            "UPDATE_COMPLETE",
+        ].includes(stacks[0].StackStatus)) {
+            return true;
+        }
+    }
+    catch (e) {
+        if (e.name === "ValidationError"
+            && e.message === "Stack with id CDKToolkit does not exist") {
+            return false;
+        }
+        else {
+            throw e;
+        }
+    }
+    return false;
+}
+async function bootstrapSST() {
+    // Create bootstrap stack
+    const project = useProject();
+    const app = new App();
+    const stack = new Stack(app, STACK_NAME, {
+        env: {
+            region: project.config.region,
+        },
+    });
+    // Add tags to stack
+    const tags = {};
+    for (const [key, value] of Object.entries(tags)) {
+        Tags.of(app).add(key, value);
+    }
+    // Create S3 bucket to store stacks metadata
+    const bucket = new Bucket(stack, project.config.region, {
+        encryption: BucketEncryption.S3_MANAGED,
+        removalPolicy: RemovalPolicy.DESTROY,
+        autoDeleteObjects: true,
+        blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
+    });
+    // Create Function and subscribe to CloudFormation events
+    const fn = new Function(stack, "MetadataHandler", {
+        code: Code.fromAsset(path.resolve(__dirname, "support/bootstrap-metadata-function")),
+        handler: "index.handler",
+        runtime: Runtime.NODEJS_18_X,
+        initialPolicy: [
+            new PolicyStatement({
+                actions: ["cloudformation:DescribeStacks"],
+                resources: ["*"],
+            }),
+            new PolicyStatement({
+                actions: ["s3:PutObject", "s3:DeleteObject"],
+                resources: [bucket.bucketArn + "/*"],
+            }),
+            new PolicyStatement({
+                actions: ["iot:Publish"],
+                resources: [
+                    `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`,
+                ],
+            }),
+        ],
+    });
+    const queue = new Queue(stack, "MetadataQueue");
+    fn.addEventSource(new SqsEventSource(queue));
+    const rule = new Rule(stack, "MetadataRule", {
+        eventPattern: {
+            source: ["aws.cloudformation"],
+            detailType: ["CloudFormation Stack Status Change"],
+            detail: {
+                "status-details": {
+                    status: [
+                        "CREATE_COMPLETE",
+                        "UPDATE_COMPLETE",
+                        "UPDATE_ROLLBACK_COMPLETE",
+                        "ROLLBACK_COMPLETE",
+                        "DELETE_COMPLETE",
+                    ],
+                },
+            },
+        },
+    });
+    rule.addTarget(new SqsQueue(queue, {
+        retryAttempts: 10,
     }));
-    if (!stacks || stacks.length === 0) {
-        const identity = await useSTSIdentity();
-        const credentials = await useAWSCredentials();
-        const project = useProject();
-        spawnSync([
+    // Create stack outputs to store bootstrap stack info
+    new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
+    new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
+    // Deploy bootstrap stack
+    const asm = app.synth();
+    const result = await Stacks.deploy(asm.stacks[0]);
+    if (Stacks.isFailed(result.status)) {
+        throw new VisibleError(`Failed to deploy bootstrap stack:\n${JSON.stringify(result.errors, null, 4)}`);
+    }
+}
+async function bootstrapCDK() {
+    const identity = await useSTSIdentity();
+    const credentials = await useAWSCredentials();
+    const { region, profile } = useProject().config;
+    await new Promise((resolve, reject) => {
+        const proc = spawn([
             "npx",
             "cdk",
             "bootstrap",
-            `aws://${identity.Account}/${useProject().config.region}`,
+            `aws://${identity.Account}/${region}`,
+            "--no-version-reporting",
         ].join(" "), {
             env: {
                 ...process.env,
                 AWS_ACCESS_KEY_ID: credentials.accessKeyId,
                 AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
                 AWS_SESSION_TOKEN: credentials.sessionToken,
-                AWS_REGION: project.config.region,
-                AWS_PROFILE: project.config.profile,
+                AWS_REGION: region,
+                AWS_PROFILE: profile,
             },
-            stdio: "inherit",
+            stdio: "pipe",
             shell: process.env.SHELL || true,
         });
-    }
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            Logger.debug(data.toString());
+        });
+        proc.stderr.on("data", (data) => {
+            Logger.debug(data.toString());
+            stderr += data;
+        });
+        proc.on("exit", (code) => {
+            Logger.debug("CDK bootstrap exited with code " + code);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                console.log(bold(dim(stderr)));
+                reject(new VisibleError(`Failed to bootstrap`));
+            }
+        });
+    });
 }
-async function load() {
+async function loadSSTStatus() {
     // Get bootstrap CloudFormation stack
     const cf = useAWSClient(CloudFormationClient);
     let result;

package/cli/commands/console.js

@@ -2,14 +2,13 @@ export const consoleCommand = async (program) => program.command("console", "Sta
     const { blue } = await import("colorette");
     const { useRuntimeServer } = await import("../../runtime/server.js");
     const { useLocalServer } = await import("../local/server.js");
-    await Promise.all([
+    const [_, local] = await Promise.all([
         useRuntimeServer(),
         useLocalServer({
             key: "",
             cert: "",
             live: false,
-            port: 13557,
         }),
     ]);
-    console.log(`Console started: ${blue(`https://console.sst.dev`)}`);
+    console.log(`Console started: ${blue(local.url)}`);
 });

package/cli/commands/dev.js

@@ -208,12 +208,17 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     const project = useProject();
     const primary = chalk.hex("#E27152");
     const link = chalk.cyan;
+    const local = await useLocalServer({
+        key: "",
+        cert: "",
+        live: true,
+    });
     console.clear();
     console.log();
     console.log(`  ${Colors.primary(`${bold(`SST`)} v${project.version}`)}  ${dim(`ready!`)}`);
     console.log();
     console.log(`  ${primary(`➜`)}  ${bold(`Stage:`)}   ${dim(project.config.stage)}`);
-    console.log(`  ${primary(`➜`)}  ${bold(`Console:`)} ${link(`https://console.sst.dev/${project.config.name}/${project.config.stage}`)}`);
+    console.log(`  ${primary(`➜`)}  ${bold(`Console:`)} ${link(local.url)}`);
     /*
     console.log(`  ${primary(`➜`)}  ${bold(dim(`Outputs:`))}`);
     for (let i = 0; i < 3; i++) {
@@ -226,12 +231,6 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     }
     */
     await Promise.all([
-        useLocalServer({
-            key: "",
-            cert: "",
-            live: true,
-            port: 13557,
-        }),
         useRuntimeWorkers(),
         useIOTBridge(),
         useRuntimeServer(),

package/cli/local/server.d.ts

@@ -2,7 +2,6 @@ import { FunctionState, State } from "./router.js";
 import { WritableDraft } from "immer/dist/internal.js";
 import { DendriformPatch } from "dendriform-immer-patch-optimiser";
 type Opts = {
-    port: number;
     key: any;
     cert: any;
     live: boolean;
@@ -14,6 +13,7 @@ declare module "../../bus.js" {
 }
 export declare function useLocalServer(opts: Opts): Promise<{
     port: number;
+    url: string;
     updateState: (cb: (draft: WritableDraft<State>) => void) => void;
     updateFunction: (id: string, cb: (draft: WritableDraft<FunctionState>) => void) => void;
 }>;

package/cli/local/server.js

@@ -11,8 +11,12 @@ import { optimise } from "dendriform-immer-patch-optimiser";
 import { sync } from "cross-spawn";
 import { useProject } from "../../project.js";
 import { useBus } from "../../bus.js";
+import getPort from "get-port";
 export async function useLocalServer(opts) {
     const project = useProject();
+    const port = await getPort({
+        port: 13557,
+    });
     let state = {
         app: project.config.name,
         stage: project.config.stage,
@@ -102,7 +106,7 @@ export async function useLocalServer(opts) {
         console.log("Rejecting unauthorized connection from " + req.headers.origin);
         socket.terminate();
     });
-    server.listen(opts.port);
+    server.listen(port);
     const handler = applyWSSHandler({
         wss,
         router,
@@ -199,7 +203,8 @@ export async function useLocalServer(opts) {
         });
     });
     const result = {
-        port: opts.port,
+        port,
+        url: `https://console.sst.dev/${project.config.name}/${project.config.stage}${port !== 13557 ? `?port=${port}` : ""}`,
         updateState,
         updateFunction,
     };

package/cli/ui/deploy.js

@@ -83,7 +83,7 @@ export function printDeploymentResults(assembly, results) {
                 return false;
             if (key.includes("SstSiteEnv"))
                 return false;
-            if (key === "SstMetadata")
+            if (key === "SSTMetadata")
                 return false;
             return true;
         });

package/constructs/App.js

@@ -303,7 +303,7 @@ export class App extends cdk.App {
             if (child instanceof Stack) {
                 const stackName = child.node.id;
                 child.addOutputs({
-                    SstMetadata: JSON.stringify({
+                    SSTMetadata: JSON.stringify({
                         app: this.name,
                         stage: this.stage,
                         version: useProject().version,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.0-rc.39",
+  "version": "2.0.0-rc.40",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -66,6 +66,7 @@
     "esbuild": "0.16.13",
     "express": "^4.18.2",
     "fast-jwt": "^1.6.1",
+    "get-port": "^6.1.2",
     "glob": "^8.0.3",
     "graphql": "*",
     "graphql-helix": "^1.12.0",

package/runtime/handlers/dotnet.d.ts

@@ -1 +1 @@
-export declare const useDotnetHandler: () => void;
+export declare const useDotnetHandler: () => Promise<void>;

package/runtime/handlers/dotnet.js

@@ -21,10 +21,10 @@ const BOOTSTRAP_MAP = {
     "dotnetcore3.1": "dotnet31-bootstrap",
     dotnet6: "dotnet6-bootstrap",
 };
-export const useDotnetHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useDotnetHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/go.d.ts

@@ -1 +1 @@
-export declare const useGoHandler: () => void;
+export declare const useGoHandler: () => Promise<void>;

package/runtime/handlers/go.js

@@ -9,10 +9,10 @@ import { promisify } from "util";
 import { useRuntimeServerConfig } from "../server.js";
 import { isChild } from "../../util/fs.js";
 const execAsync = promisify(exec);
-export const useGoHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useGoHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/java.d.ts

@@ -1 +1 @@
-export declare const useJavaHandler: () => void;
+export declare const useJavaHandler: () => Promise<void>;

package/runtime/handlers/java.js

@@ -11,10 +11,10 @@ import { existsAsync, findBelow, isChild } from "../../util/fs.js";
 import { useProject } from "../../project.js";
 import { execAsync } from "../../util/process.js";
 import url from "url";
-export const useJavaHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useJavaHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/node.d.ts

@@ -1 +1 @@
-export declare const useNodeHandler: () => void;
+export declare const useNodeHandler: () => Promise<void>;

package/runtime/handlers/node.js

@@ -10,8 +10,8 @@ import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
-export const useNodeHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useNodeHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
     const handlers = useRuntimeHandlers();
     const cache = {};
     const project = useProject();

package/runtime/handlers/python.d.ts

@@ -1 +1 @@
-export declare const usePythonHandler: () => void;
+export declare const usePythonHandler: () => Promise<void>;

package/runtime/handlers/python.js

@@ -18,10 +18,10 @@ const RUNTIME_MAP = {
     "python3.8": Runtime.PYTHON_3_8,
     "python3.9": Runtime.PYTHON_3_9,
 };
-export const usePythonHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const usePythonHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     handlers.register({

package/runtime/server.d.ts

@@ -1,6 +1,6 @@
-export declare const useRuntimeServerConfig: () => {
+export declare const useRuntimeServerConfig: () => Promise<{
     API_VERSION: string;
-    url: string;
     port: number;
-};
+    url: string;
+}>;
 export declare const useRuntimeServer: () => Promise<void>;

package/runtime/server.js

@@ -4,18 +4,22 @@ import { useBus } from "../bus.js";
 import { Logger } from "../logger.js";
 import { useRuntimeWorkers } from "./workers.js";
 import https from "https";
-export const useRuntimeServerConfig = Context.memo(() => {
+import getPort from "get-port";
+export const useRuntimeServerConfig = Context.memo(async () => {
+    const port = await getPort({
+        port: 12557,
+    });
     return {
         API_VERSION: "2018-06-01",
-        url: "http://localhost:12557",
-        port: 12557,
+        port,
+        url: `http://localhost:${port}`,
     };
 });
 export const useRuntimeServer = Context.memo(async () => {
     const bus = useBus();
     const app = express();
-    const workers = useRuntimeWorkers();
-    const cfg = useRuntimeServerConfig();
+    const workers = await useRuntimeWorkers();
+    const cfg = await useRuntimeServerConfig();
     const workersWaiting = new Map();
     const invocationsQueued = new Map();
     function next(workerID) {

package/runtime/workers.d.ts

@@ -24,7 +24,7 @@ interface Worker {
     workerID: string;
     functionID: string;
 }
-export declare const useRuntimeWorkers: () => {
+export declare const useRuntimeWorkers: () => Promise<{
     fromID(workerID: string): Worker;
     setCurrentRequestID(workerID: string, requestID: string): void;
     stdout(workerID: string, message: string): void;
@@ -33,5 +33,5 @@ export declare const useRuntimeWorkers: () => {
         type: keyof import("../bus.js").Events;
         cb: (payload: any) => void;
     };
-};
+}>;
 export {};

package/runtime/workers.js

@@ -3,12 +3,12 @@ import { useBus } from "../bus.js";
 import { useFunctionBuilder, useRuntimeHandlers } from "./handlers.js";
 import { useRuntimeServerConfig } from "./server.js";
 import { useFunctions } from "../constructs/Function.js";
-export const useRuntimeWorkers = Context.memo(() => {
+export const useRuntimeWorkers = Context.memo(async () => {
     const workers = new Map();
     const bus = useBus();
     const handlers = useRuntimeHandlers();
     const builder = useFunctionBuilder();
-    const server = useRuntimeServerConfig();
+    const server = await useRuntimeServerConfig();
     handlers.subscribe("function.build.success", async (evt) => {
         for (const [_, worker] of workers) {
             if (worker.functionID === evt.properties.functionID) {