sst 2.0.0-rc.3 → 2.0.0-rc.31

package/bootstrap.d.ts

@@ -1,6 +1,4 @@
-export declare const LATEST_VERSION = "3";
 export declare const useBootstrap: () => Promise<{
-    version: string | undefined;
-    bucket: string | undefined;
-    stack: string | undefined;
+    version: never;
+    bucket: never;
 }>;

package/bootstrap.js

@@ -1,79 +1,136 @@
-import { GetParametersCommand, SSMClient } from "@aws-sdk/client-ssm";
-import { Tags, Stack, RemovalPolicy, App } from "aws-cdk-lib";
+import url from "url";
+import path from "path";
+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";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { SqsQueue } from "aws-cdk-lib/aws-events-targets";
 import { BlockPublicAccess, Bucket, BucketEncryption, } from "aws-cdk-lib/aws-s3";
-import { ParameterTier, StringParameter } from "aws-cdk-lib/aws-ssm";
-import { useProject } from "./app.js";
+import { useProject } from "./project.js";
 import { createSpinner } from "./cli/spinner.js";
 import { Context } from "./context/context.js";
 import { useAWSClient } from "./credentials.js";
 import { VisibleError } from "./error.js";
 import { Logger } from "./logger.js";
 import { Stacks } from "./stacks/index.js";
-const SSM_NAME_VERSION = `/sst/bootstrap/version`;
-const SSM_NAME_STACK_NAME = `/sst/bootstrap/stack-name`;
-const SSM_NAME_BUCKET_NAME = `/sst/bootstrap/bucket-name`;
-export const LATEST_VERSION = "3";
+const STACK_NAME = "SSTBootstrap";
+const OUTPUT_VERSION = "Version";
+const OUTPUT_BUCKET = "BucketName";
+const LATEST_VERSION = "4";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export const useBootstrap = Context.memo(async () => {
     Logger.debug("Initializing bootstrap context");
-    const ret = await ssm();
-    if (!ret.version ||
-        !ret.bucket ||
-        !ret.stack ||
-        ret.version !== LATEST_VERSION) {
+    let status = await loadBootstrapStatus();
+    if (!status || status.version !== LATEST_VERSION) {
         const project = useProject();
         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, "SSTBootstrap", {
+        const stack = new Stack(app, STACK_NAME, {
             env: {
-                region: project.region,
+                region: project.config.region,
             },
         });
+        // Add tags to stack
         const tags = {};
         for (const [key, value] of Object.entries(tags)) {
             Tags.of(app).add(key, value);
         }
-        const bucket = new Bucket(stack, project.region, {
+        // 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,
         });
-        new StringParameter(stack, SSM_NAME_VERSION, {
-            parameterName: SSM_NAME_VERSION,
-            stringValue: LATEST_VERSION,
-            tier: ParameterTier.STANDARD,
+        // 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_16_X,
+            initialPolicy: [
+                new PolicyStatement({
+                    actions: ["cloudformation:DescribeStacks"],
+                    resources: ["*"],
+                }),
+                new PolicyStatement({
+                    actions: ["s3:PutObject", "s3:DeleteObject"],
+                    resources: [bucket.bucketArn + "/*"],
+                }),
+            ],
         });
-        new StringParameter(stack, SSM_NAME_STACK_NAME, {
-            parameterName: SSM_NAME_STACK_NAME,
-            stringValue: stack.stackName,
-            tier: ParameterTier.STANDARD,
-        });
-        new StringParameter(stack, SSM_NAME_BUCKET_NAME, {
-            parameterName: SSM_NAME_BUCKET_NAME,
-            stringValue: bucket.bucketName,
-            tier: ParameterTier.STANDARD,
+        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)}`);
         }
         spinner.succeed();
-        return ssm();
+        // Fetch bootstrap status
+        status = await loadBootstrapStatus();
+        if (!status) {
+            throw new VisibleError("Failed to deploy bootstrap stack");
+        }
     }
-    Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
-    return ret;
+    Logger.debug("Loaded bootstrap info: ", JSON.stringify(status));
+    return status;
 });
-async function ssm() {
-    const ssm = useAWSClient(SSMClient);
-    const result = await ssm.send(new GetParametersCommand({
-        Names: [SSM_NAME_VERSION, SSM_NAME_STACK_NAME, SSM_NAME_BUCKET_NAME],
-    }));
-    return {
-        version: result.Parameters.find((p) => p.Name === SSM_NAME_VERSION)?.Value,
-        bucket: result.Parameters.find((p) => p.Name === SSM_NAME_BUCKET_NAME)
-            ?.Value,
-        stack: result.Parameters.find((p) => p.Name === SSM_NAME_STACK_NAME)
-            ?.Value,
-    };
+async function loadBootstrapStatus() {
+    // Get bootstrap CloudFormation stack
+    const cf = useAWSClient(CloudFormationClient);
+    let result;
+    try {
+        result = await cf.send(new DescribeStacksCommand({
+            StackName: STACK_NAME,
+        }));
+    }
+    catch (e) {
+        if (e.Code === "ValidationError"
+            && e.message === `Stack with id ${STACK_NAME} does not exist`) {
+            return null;
+        }
+        throw e;
+    }
+    // Parse stack outputs
+    let version, bucket;
+    (result.Stacks[0].Outputs || []).forEach((o) => {
+        if (o.OutputKey === OUTPUT_VERSION) {
+            version = o.OutputValue;
+        }
+        else if (o.OutputKey === OUTPUT_BUCKET) {
+            bucket = o.OutputValue;
+        }
+    });
+    if (!version || !bucket) {
+        return null;
+    }
+    return { version, bucket };
 }

package/bus.d.ts

@@ -1,12 +1,12 @@
 export interface Events {
 }
-export declare type EventTypes = keyof Events;
-export declare type EventPayload<Type extends EventTypes = EventTypes> = {
+export type EventTypes = keyof Events;
+export type EventPayload<Type extends EventTypes = EventTypes> = {
     type: Type;
     sourceID: string;
     properties: Events[Type];
 };
-declare type Subscription = {
+type Subscription = {
     type: EventTypes;
     cb: (payload: any) => void;
 };

package/cache.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs/promises";
-import { useProject } from "./app.js";
+import { useProject } from "./project.js";
 import { Logger } from "./logger.js";
 import { Context } from "./context/context.js";
 export const useCache = Context.memo(async () => {

package/cdk/deploy-stack.d.ts

@@ -4,7 +4,7 @@ import { ISDK, SdkProvider } from "aws-cdk/lib/api/aws-auth/index.js";
 import { ToolkitInfo } from "aws-cdk/lib/api/toolkit-info.js";
 import { ResourcesToImport } from "aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
-declare type TemplateBodyParameter = {
+type TemplateBodyParameter = {
     TemplateBody?: string;
     TemplateURL?: string;
 };
@@ -166,7 +166,7 @@ export interface DeployStackOptions {
      */
     readonly assetParallelism?: boolean;
 }
-export declare type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
+export type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
 export interface DirectDeploymentMethod {
     readonly method: "direct";
 }

package/cdk/deploy-stack.js

@@ -10,7 +10,6 @@ import { contentHash } from "aws-cdk/lib/util/content-hash.js";
 import { CfnEvaluationException } from "aws-cdk/lib/api/evaluate-cloudformation-template.js";
 import { tryHotswapDeployment } from "aws-cdk/lib/api/hotswap-deployments.js";
 import { changeSetHasNoChanges, CloudFormationStack, TemplateParameters, waitForChangeSet, waitForStackDeploy, waitForStackDelete, } from "aws-cdk/lib/api/util/cloudformation.js";
-import { StackActivityMonitor, } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 import { blue } from "colorette";
 const LARGE_TEMPLATE_SIZE_KB = 50;
 export async function deployStack(options) {
@@ -261,14 +260,19 @@ class FullCloudFormationDeployment {
         }
     }
     async monitorDeployment(startTime, expectedChanges) {
-        const monitor = this.options.quiet
-            ? undefined
-            : StackActivityMonitor.withDefaultPrinter(this.cfn, this.stackName, this.stackArtifact, {
-                resourcesTotal: expectedChanges,
-                progress: this.options.progress,
-                changeSetCreationTime: startTime,
-                ci: this.options.ci,
-            }).start();
+        // const monitor = this.options.quiet
+        //   ? undefined
+        //   : StackActivityMonitor.withDefaultPrinter(
+        //       this.cfn,
+        //       this.stackName,
+        //       this.stackArtifact,
+        //       {
+        //         resourcesTotal: expectedChanges,
+        //         progress: this.options.progress,
+        //         changeSetCreationTime: startTime,
+        //         ci: this.options.ci,
+        //       }
+        //     ).start();
         let finalState = this.cloudFormationStack;
         try {
             const successStack = await waitForStackDeploy(this.cfn, this.stackName);
@@ -279,10 +283,10 @@ class FullCloudFormationDeployment {
             finalState = successStack;
         }
         catch (e) {
-            throw new Error(suffixWithErrors(e.message, monitor?.errors));
+            throw new Error(suffixWithErrors(e.message /*, monitor?.errors*/));
         }
         finally {
-            await monitor?.stop();
+            // await monitor?.stop();
         }
         debug("Stack %s has completed updating", this.stackName);
         return {
@@ -399,11 +403,13 @@ export async function destroyStack(options) {
     if (!currentStack.exists) {
         return;
     }
+    /*
     const monitor = options.quiet
-        ? undefined
-        : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
-            ci: options.ci,
+      ? undefined
+      : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
+          ci: options.ci,
         }).start();
+    */
     try {
         await cfn
             .deleteStack({ StackName: deployName, RoleARN: options.roleArn })
@@ -415,12 +421,14 @@ export async function destroyStack(options) {
         }
     }
     catch (e) {
-        throw new Error(suffixWithErrors(e.message, monitor?.errors));
+        throw new Error(suffixWithErrors(e.message /* , monitor?.errors */));
     }
     finally {
+        /*
         if (monitor) {
-            await monitor.stop();
+          await monitor.stop();
         }
+        */
     }
 }
 /**

package/cli/commands/bind.js

@@ -1,23 +1,26 @@
-import { useProject } from "../../app.js";
-export const bind = (program) => program.command("bind <command>", "Binds blah", (yargs) => yargs.positional("command", {
+export const bind = (program) => program.command("bind <command>", "Bind your app's resources to a command", (yargs) => yargs
+    .positional("command", {
     type: "string",
-    describe: "Command to bind to",
+    describe: "The command to bind to",
     demandOption: true,
-}), async (args) => {
+})
+    .example(`sst bind "vitest run"`, "Bind your resources to your tests")
+    .example(`sst bind "tsx scripts/myscript.ts"`, "Bind your resources to a script"), async (args) => {
     const { Config } = await import("../../config.js");
-    const { spawnSync, spawn } = await import("child_process");
+    const { spawnSync } = await import("child_process");
     const { useAWSCredentials } = await import("../../credentials.js");
+    const { useProject } = await import("../../project.js");
     const env = await Config.env();
     const project = useProject();
     const credentials = await useAWSCredentials();
     const result = spawnSync(args.command, {
         env: {
+            ...process.env,
             ...env,
             AWS_ACCESS_KEY_ID: credentials.accessKeyId,
             AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
             AWS_SESSION_TOKEN: credentials.sessionToken,
-            AWS_REGION: project.region,
-            PATH: process.env.PATH,
+            AWS_REGION: project.config.region,
         },
         stdio: "inherit",
         shell: process.env.SHELL || true,

package/cli/commands/build.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const build: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
@@ -7,5 +7,5 @@ export declare const build: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    from: string | undefined;
+    to: string | undefined;
 }>;

package/cli/commands/build.js

@@ -1,11 +1,15 @@
-import { createSpinner } from "../spinner.js";
-export const build = (program) => program.command("build", "Build stacks code", yargs => yargs.option("from", { type: "string" }), async () => {
+export const build = (program) => program.command("build", "Build your app", (yargs) => yargs.option("to", {
+    type: "string",
+    describe: "Output directory, defaults to .sst/dist",
+}), async (args) => {
+    const { useProject } = await import("../../project.js");
+    const { createSpinner } = await import("../spinner.js");
     const { Stacks } = await import("../../stacks/index.js");
     const spinner = createSpinner("Building stacks").start();
-    const fn = await Stacks.build();
     await Stacks.synth({
-        fn,
-        mode: "deploy"
+        fn: useProject().stacks,
+        buildDir: args.to,
+        mode: "deploy",
     });
     spinner.succeed();
     process.exit(0);

package/cli/commands/console.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const consoleCommand: (program: Program) => Promise<import("yargs").Argv<{
     stage: string | undefined;
 } & {

package/cli/commands/console.js

@@ -1,7 +1,7 @@
-import { blue } from "colorette";
-import { useRuntimeServer } from "../../runtime/server.js";
-import { useLocalServer } from "../local/server.js";
-export const consoleCommand = async (program) => program.command("console", "Start the sst console", (yargs) => yargs, async () => {
+export const consoleCommand = async (program) => program.command("console", "Start the SST Console", (yargs) => yargs, async () => {
+    const { blue } = await import("colorette");
+    const { useRuntimeServer } = await import("../../runtime/server.js");
+    const { useLocalServer } = await import("../local/server.js");
     await Promise.all([
         useRuntimeServer(),
         useLocalServer({

package/cli/commands/deploy.js

@@ -1,48 +1,63 @@
-import { printDeploymentResults } from "../ui/deploy.js";
-export const deploy = (program) => program.command("deploy [filter]", "Work on your SST app locally", (yargs) => yargs
-    .option("from", { type: "string" })
+export const deploy = (program) => program.command("deploy [filter]", "Deploy your app to AWS", (yargs) => yargs
+    .option("from", {
+    type: "string",
+    describe: "Deploy using previously built output",
+})
     .option("fullscreen", {
     type: "boolean",
     describe: "Disable full screen UI",
     default: true,
 })
-    .positional("filter", { type: "string" }), async (args) => {
+    .positional("filter", {
+    type: "string",
+    describe: "Optionally filter stacks to deploy",
+}), async (args) => {
     const React = await import("react");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { createSpinner } = await import("../spinner.js");
     const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
     const { blue, bold } = await import("colorette");
-    const { useProject } = await import("../../app.js");
+    const { useProject } = await import("../../project.js");
     const { Stacks } = await import("../../stacks/index.js");
     const { render } = await import("ink");
     const { DeploymentUI } = await import("../ui/deploy.js");
+    const project = useProject();
     const assembly = await (async function () {
         if (args.from) {
             const result = new CloudAssembly(args.from);
             return result;
         }
-        const fn = await Stacks.build();
-        return await Stacks.synth({
-            fn,
+        const spinner = createSpinner("Building stacks");
+        const result = await Stacks.synth({
+            fn: project.stacks,
             mode: "deploy",
         });
+        spinner.succeed();
+        return result;
     })();
-    const project = useProject();
     const target = assembly.stacks.filter((s) => !args.filter ||
         s.stackName.toLowerCase().includes(args.filter.toLowerCase()));
     if (!target.length) {
         console.log(`No stacks found matching ${blue(args.filter)}`);
         process.exit(1);
-        return;
-    }
-    console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.stage)}...`);
-    let component = undefined;
-    if (args.fullscreen) {
-        process.stdout.write("\x1b[?1049h");
-        component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
     }
+    console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.config.stage)}...`);
+    const cleanup = (() => {
+        if (args.fullscreen) {
+            process.stdout.write("\x1b[?1049h");
+            const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+            return () => {
+                component.unmount();
+                process.stdout.write("\x1b[?1049l");
+            };
+        }
+        const spinner = createSpinner("Deploying stacks");
+        return () => spinner.succeed();
+    })();
     const results = await Stacks.deployMany(target);
-    if (component)
-        component.unmount();
-    process.stdout.write("\x1b[?1049l");
+    cleanup();
     printDeploymentResults(results);
+    if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
+        process.exit(1);
     process.exit(0);
 });

package/cli/commands/dev.js

@@ -1,15 +1,4 @@
-import path from "path";
-import fs from "fs/promises";
-import crypto from "crypto";
-import { printDeploymentResults } from "../ui/deploy.js";
-import { useFunctions } from "../../constructs/Function.js";
-import { dim, gray, yellow } from "colorette";
-import { useProject } from "../../app.js";
-import { SiteEnv } from "../../site-env.js";
-import { usePothosBuilder } from "./plugins/pothos.js";
-import { useKyselyTypeGenerator } from "./plugins/kysely.js";
-import { useRDSWarmer } from "./plugins/warmer.js";
-export const dev = (program) => program.command(["start", "dev"], "Work on your SST app locally", (yargs) => yargs.option("fullscreen", {
+export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("fullscreen", {
     type: "boolean",
     describe: "Disable full screen UI",
     default: true,
@@ -28,19 +17,31 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
     const { Context } = await import("../../context/context.js");
     const { DeploymentUI } = await import("../ui/deploy.js");
     const { useLocalServer } = await import("../local/server.js");
+    const path = await import("path");
+    const fs = await import("fs/promises");
+    const crypto = await import("crypto");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { useFunctions } = await import("../../constructs/Function.js");
+    const { dim, gray, yellow } = await import("colorette");
+    const { SiteEnv } = await import("../../site-env.js");
+    const { usePothosBuilder } = await import("./plugins/pothos.js");
+    const { useKyselyTypeGenerator } = await import("./plugins/kysely.js");
+    const { useRDSWarmer } = await import("./plugins/warmer.js");
+    const { useProject } = await import("../../project.js");
+    const { useMetadata } = await import("../../stacks/metadata.js");
     if (args._[0] === "start") {
         console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
     }
     const useFunctionLogger = Context.memo(async () => {
         const bus = useBus();
         bus.subscribe("function.invoked", async (evt) => {
-            console.log(bold(magenta(`Invoked `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(bold(magenta(`Invoked `)), useFunctions().fromID(evt.properties.functionID).handler);
         });
         bus.subscribe("function.build.success", async (evt) => {
-            console.log(bold(gray(`Built   `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(bold(gray(`Built   `)), useFunctions().fromID(evt.properties.functionID).handler);
         });
         bus.subscribe("function.build.failed", async (evt) => {
-            console.log(bold(red(`Build failed `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(bold(red(`Build failed `)), useFunctions().fromID(evt.properties.functionID).handler);
             console.log(dim(evt.properties.errors.join("\n")));
         });
         bus.subscribe("worker.stdout", async (evt) => {
@@ -50,14 +51,14 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
                 const line = lines[i];
                 lines[i] = "         " + line;
             }
-            console.log(bold(blue(`Log     `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(bold(blue(`Log     `)), useFunctions().fromID(evt.properties.functionID).handler);
             console.log(dim(lines.join("\n")));
         });
         bus.subscribe("function.success", async (evt) => {
-            console.log(bold(green(`Success `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(bold(green(`Success `)), useFunctions().fromID(evt.properties.functionID).handler);
         });
         bus.subscribe("function.error", async (evt) => {
-            console.log(bold(red(`Error   `)), bold(useFunctions().fromID(evt.properties.functionID).handler), evt.properties.errorMessage);
+            console.log(bold(red(`Error   `)), useFunctions().fromID(evt.properties.functionID).handler, evt.properties.errorMessage);
             for (const line of evt.properties.trace || []) {
                 console.log(`         ${dim(line)}`);
             }
@@ -65,17 +66,19 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
     });
     const useStackBuilder = Context.memo(async () => {
         const watcher = useWatcher();
-        const bus = useBus();
         const project = useProject();
+        const bus = useBus();
         let lastDeployed;
         let pending;
         let isDeploying = false;
         async function build() {
             const spinner = createSpinner("Building stacks").start();
             try {
-                const fn = await Stacks.build();
+                const [metafile, sstConfig] = await Stacks.load(project.paths.config);
+                project.metafile = metafile;
+                project.stacks = sstConfig.stacks;
                 const assembly = await Stacks.synth({
-                    fn,
+                    fn: project.stacks,
                     outDir: `.sst/cdk.out`,
                     mode: "dev",
                 });
@@ -105,15 +108,20 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
             const assembly = pending;
             const nextChecksum = await checksum(assembly.directory);
             pending = undefined;
-            let component = undefined;
-            if (args.fullscreen) {
-                process.stdout.write("\x1b[?1049h");
-                component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-            }
+            const cleanup = (() => {
+                if (args.fullscreen) {
+                    process.stdout.write("\x1b[?1049h");
+                    const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+                    return () => {
+                        component.unmount();
+                        process.stdout.write("\x1b[?1049l");
+                    };
+                }
+                const spinner = createSpinner("Deploying stacks");
+                return () => spinner.succeed();
+            })();
             const results = await Stacks.deployMany(assembly.stacks);
-            if (component)
-                component.unmount();
-            process.stdout.write("\x1b[?1049l");
+            cleanup();
             lastDeployed = nextChecksum;
             printDeploymentResults(results);
             const keys = await SiteEnv.keys();
@@ -151,14 +159,10 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
                 .digest("hex");
             return hash;
         }
-        let metafile;
-        bus.subscribe("stack.built", async (evt) => {
-            metafile = evt.properties.metafile;
-        });
         watcher.subscribe("file.changed", async (evt) => {
-            if (!metafile)
+            if (!project.metafile)
                 return;
-            if (!metafile.inputs[evt.properties.relative])
+            if (!project.metafile.inputs[evt.properties.relative])
                 return;
             build();
         });
@@ -180,6 +184,7 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
         useIOTBridge(),
         useRuntimeServer(),
         usePothosBuilder(),
+        useMetadata(),
         useKyselyTypeGenerator(),
         useRDSWarmer(),
         useFunctionLogger(),