sst 2.0.0-rc.8 → 2.0.0

package/stacks/app-metadata.d.ts

@@ -0,0 +1,7 @@
+interface Metadata {
+    mode: "deploy" | "dev";
+}
+export declare function saveAppMetadata(data: Metadata): Promise<void>;
+export declare function clearAppMetadata(): Promise<void>;
+export declare const useAppMetadata: () => Promise<Metadata | undefined>;
+export {};

package/stacks/app-metadata.js

@@ -0,0 +1,78 @@
+import { useBootstrap } from "../bootstrap.js";
+import { useAWSCredentials } from "../credentials.js";
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, } from "@aws-sdk/client-s3";
+import { json } from "stream/consumers";
+import { Context } from "../context/context.js";
+import { Logger } from "../logger.js";
+import { useProject } from "../project.js";
+async function metadata() {
+    Logger.debug("Fetching app metadata");
+    const [project, credentials, bootstrap] = await Promise.all([
+        useProject(),
+        useAWSCredentials(),
+        useBootstrap(),
+    ]);
+    const s3 = new S3Client({
+        region: project.config.region,
+        credentials,
+    });
+    try {
+        const result = await s3
+            .send(new GetObjectCommand({
+            Key: useS3Key(),
+            Bucket: bootstrap.bucket,
+        }))
+            .then((result) => json(result.Body));
+        return result;
+    }
+    catch (ex) {
+        Logger.debug("Fetching app metadata: not found");
+    }
+}
+export async function saveAppMetadata(data) {
+    Logger.debug("Saving app metadata");
+    const [project, credentials, bootstrap] = await Promise.all([
+        useProject(),
+        useAWSCredentials(),
+        useBootstrap(),
+    ]);
+    const s3 = new S3Client({
+        region: project.config.region,
+        credentials,
+    });
+    try {
+        await s3.send(new PutObjectCommand({
+            Key: useS3Key(),
+            Bucket: bootstrap.bucket,
+            Body: JSON.stringify(data),
+        }));
+    }
+    catch (ex) {
+        Logger.debug("Saving app metadata: not found");
+    }
+}
+export async function clearAppMetadata() {
+    Logger.debug("Clearing app metadata");
+    const [project, credentials, bootstrap] = await Promise.all([
+        useProject(),
+        useAWSCredentials(),
+        useBootstrap(),
+    ]);
+    const s3 = new S3Client({
+        region: project.config.region,
+        credentials,
+    });
+    await s3.send(new DeleteObjectCommand({
+        Key: useS3Key(),
+        Bucket: bootstrap.bucket,
+    }));
+}
+function useS3Key() {
+    const project = useProject();
+    return `appMetadata/app.${project.config.name}/stage.${project.config.stage}.json`;
+}
+const MetadataContext = Context.create(async () => {
+    const data = await metadata();
+    return data;
+});
+export const useAppMetadata = MetadataContext.use;

package/stacks/assembly.d.ts

@@ -0,0 +1 @@
+export declare function loadAssembly(from: string): Promise<import("aws-cdk-lib/cx-api").CloudAssembly>;

package/stacks/assembly.js

@@ -0,0 +1,4 @@
+export async function loadAssembly(from) {
+    const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
+    return new CloudAssembly(from);
+}

package/stacks/build.d.ts

@@ -6,4 +6,4 @@ declare module "../bus.js" {
         };
     }
 }
-export declare function build(): Promise<any>;
+export declare function load(input: string): Promise<readonly [esbuild.Metafile, any]>;

package/stacks/build.js

@@ -1,60 +1,53 @@
 import esbuild from "esbuild";
 import fs from "fs/promises";
 import path from "path";
-import { Logger } from "../logger.js";
-import { useBus } from "../bus.js";
-import { useProject } from "../app.js";
 import { dynamicImport } from "../util/module.js";
-export async function build() {
-    const project = useProject();
-    const bus = useBus();
-    const pkg = JSON.parse(await fs
-        .readFile(path.join(project.paths.root, "package.json"))
-        .then((x) => x.toString()));
-    const outfile = path.join(project.paths.out, `stacks.${Math.random()}.mjs`);
-    Logger.debug("Running esbuild on", project.main, "to", outfile);
-    const result = await esbuild.build({
-        keepNames: true,
-        bundle: true,
-        sourcemap: "inline",
-        platform: "node",
-        target: "esnext",
-        metafile: true,
-        format: "esm",
-        external: [
-            "aws-cdk-lib",
-            "sst",
-            ...Object.keys({
-                ...pkg.devDependencies,
-                ...pkg.dependencies,
-                ...pkg.peerDependencies,
-            }),
-        ],
-        absWorkingDir: project.paths.root,
-        outfile,
-        banner: {
-            js: [
-                `import { createRequire as topLevelCreateRequire } from 'module';`,
-                `const require = topLevelCreateRequire(import.meta.url);`,
-            ].join(""),
-        },
-        // The entry can have any file name (ie. "stacks/anything.ts"). We want the
-        // build output to be always named "lib/index.js". This allow us to always
-        // import from "buildDir" without needing to pass "anything" around.
-        entryPoints: [project.main],
-    });
-    Logger.debug("Finished esbuild");
-    Logger.debug("Sourcing stacks");
+import { findAbove } from "../util/fs.js";
+import { VisibleError } from "../error.js";
+export async function load(input) {
+    const parsed = path.parse(input);
+    const root = await findAbove(input, "package.json");
+    const outfile = path.join(parsed.dir, `.${parsed.name}.${Date.now()}.mjs`);
+    const pkg = JSON.parse(await fs.readFile(path.join(root, "package.json")).then((x) => x.toString()));
     try {
+        const result = await esbuild.build({
+            keepNames: true,
+            bundle: true,
+            sourcemap: "inline",
+            platform: "node",
+            target: "esnext",
+            metafile: true,
+            format: "esm",
+            logLevel: "silent",
+            external: [
+                "aws-cdk-lib",
+                "sst",
+                ...Object.keys({
+                    ...pkg.devDependencies,
+                    ...pkg.dependencies,
+                    ...pkg.peerDependencies,
+                }),
+            ],
+            absWorkingDir: root,
+            outfile,
+            banner: {
+                js: [
+                    `import { createRequire as topLevelCreateRequire } from 'module';`,
+                    `const require = topLevelCreateRequire(import.meta.url);`,
+                ].join(""),
+            },
+            // The entry can have any file name (ie. "stacks/anything.ts"). We want the
+            // build output to be always named "lib/index.js". This allow us to always
+            // import from "buildDir" without needing to pass "anything" around.
+            entryPoints: [input],
+        });
         const mod = await dynamicImport(outfile);
-        Logger.debug("Finished sourcing stacks");
         await fs.rm(outfile, {
             force: true,
         });
-        bus.publish("stack.built", {
-            metafile: result.metafile,
-        });
-        return mod.default;
+        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];
     }
     catch (e) {
         await fs.rm(outfile, {

package/stacks/deploy.d.ts

@@ -1,5 +1,6 @@
 import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
 import { StackDeploymentResult } from "./monitor.js";
+export declare function publishAssets(stacks: CloudFormationStackArtifact[]): Promise<Record<string, any>>;
 export declare function deployMany(stacks: CloudFormationStackArtifact[]): Promise<Record<string, {
     status: string;
     outputs: Record<string, string>;

package/stacks/deploy.js

@@ -1,7 +1,24 @@
 import { useBus } from "../bus.js";
-import { useAWSProvider } from "../credentials.js";
+import { useAWSClient, useAWSProvider } from "../credentials.js";
 import { Logger } from "../logger.js";
-import { isFailed, monitor } from "./monitor.js";
+import { filterOutputs, isFailed, monitor, } from "./monitor.js";
+export async function publishAssets(stacks) {
+    Logger.debug("Publishing assets");
+    const provider = await useAWSProvider();
+    const { publishDeployAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
+    const results = {};
+    for (const stack of stacks) {
+        const result = await publishDeployAssets(provider, {
+            stack: stack,
+            quiet: false,
+            deploymentMethod: {
+                method: "direct",
+            },
+        });
+        results[stack.stackName] = result;
+    }
+    return results;
+}
 export async function deployMany(stacks) {
     Logger.debug("Deploying stacks", stacks.map((s) => s.stackName));
     const { CloudFormationStackArtifact } = await import("aws-cdk-lib/cx-api");
@@ -9,11 +26,7 @@ export async function deployMany(stacks) {
     const bus = useBus();
     const complete = new Set();
     const todo = new Set(stacks.map((s) => s.id));
-    const pending = new Set();
     const results = {};
-    bus.subscribe("stack.updated", (evt) => {
-        pending.add(evt.properties.stackID);
-    });
     return new Promise((resolve) => {
         async function trigger() {
             for (const stack of stacks) {
@@ -62,6 +75,7 @@ export async function deploy(stack) {
         sdkProvider: provider,
     });
     try {
+        await addInUseExports(stack);
         const result = await deployment.deployStack({
             stack: stack,
             quiet: true,
@@ -76,7 +90,7 @@ export async function deploy(stack) {
             });
             return {
                 errors: {},
-                outputs: result.outputs,
+                outputs: filterOutputs(result.outputs),
                 status: "SKIPPED",
             };
         }
@@ -103,3 +117,110 @@ export async function deploy(stack) {
         };
     }
 }
+async function addInUseExports(stack) {
+    // Get old outputs
+    const oldOutputs = await getCloudFormationStackOutputs(stack);
+    if (!oldOutputs)
+        return;
+    // Get new exports
+    // note: that we only want to handle outputs exported by CDK.
+    // ie.
+    // "Outputs": {
+    //   "ExportsOutputRefauthUserPoolA78B038B8D9965B5": {
+    //     "Value": {
+    //       "Ref": "authUserPoolA78B038B"
+    //     },
+    //     "Export": {
+    //       "Name": "frank-acme-auth:ExportsOutputRefauthUserPoolA78B038B8D9965B5"
+    //     }
+    //   },
+    const newTemplate = JSON.parse(await getLocalTemplate(stack));
+    const newOutputs = newTemplate.Outputs || {};
+    const newExportNames = Object.keys(newOutputs)
+        .filter((outputKey) => outputKey.startsWith("ExportsOutput"))
+        .filter((outputKey) => newOutputs[outputKey].Export)
+        .map((outputKey) => newOutputs[outputKey].Export.Name);
+    // Add missing exports
+    // ie.
+    // Outputs [{
+    //   OutputKey: (String)
+    //   OutputValue: (String)
+    //   Description: (String)
+    //   ExportName: (String)
+    // }]
+    let isDirty = false;
+    await Promise.all(oldOutputs
+        .filter((output) => output.OutputKey?.startsWith("ExportsOutput"))
+        .filter((output) => output.ExportName)
+        // filter exports not in the new template (ie. CloudFormation will be removing)
+        .filter((output) => !newExportNames.includes(output.ExportName))
+        // filter the exports still in-use by other stacks
+        .map(async (output) => {
+        const imports = await listImports(output.ExportName);
+        // update template
+        if (imports.length > 0) {
+            Logger.debug(`deploy stack: addInUseExports: export ${output.ExportName} used in ${imports.join(", ")}`);
+            newTemplate.Outputs = newTemplate.Outputs || {};
+            newTemplate.Outputs[output.OutputKey] = {
+                Description: `Output added by SST b/c exported value still used in ${imports.join(", ")}`,
+                Value: output.OutputValue,
+                Export: {
+                    Name: output.ExportName,
+                },
+            };
+            isDirty = true;
+        }
+    }));
+    // Save new template
+    if (isDirty) {
+        await saveLocalTemplate(stack, JSON.stringify(newTemplate, null, 2));
+    }
+}
+async function getCloudFormationStackOutputs(stack) {
+    const { CloudFormationClient, DescribeStacksCommand } = await import("@aws-sdk/client-cloudformation");
+    const client = useAWSClient(CloudFormationClient);
+    try {
+        const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
+            StackName: stack.id,
+        }));
+        if (!stacks || stacks.length === 0)
+            return;
+        return stacks[0].Outputs || [];
+    }
+    catch (e) {
+        if (e.name === "ValidationError" &&
+            e.message.includes("Stack with id") &&
+            e.message.includes("does not exist")) {
+            return;
+        }
+        else {
+            throw e;
+        }
+    }
+}
+async function listImports(exportName) {
+    const { CloudFormationClient, ListImportsCommand } = await import("@aws-sdk/client-cloudformation");
+    const client = useAWSClient(CloudFormationClient);
+    try {
+        const ret = await client.send(new ListImportsCommand({
+            ExportName: exportName,
+        }));
+        return ret.Imports || [];
+    }
+    catch (e) {
+        if (e.name === "ValidationError" &&
+            e.message.includes("is not imported by any stack")) {
+            return [];
+        }
+        throw e;
+    }
+}
+async function getLocalTemplate(stack) {
+    const fs = await import("fs/promises");
+    const fileContent = await fs.readFile(stack.templateFullPath);
+    return fileContent.toString();
+}
+async function saveLocalTemplate(stack, content) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(stack.templateFullPath, content);
+}

package/stacks/diff.d.ts

@@ -0,0 +1,8 @@
+import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
+export declare function diff(stack: CloudFormationStackArtifact, oldTemplate: any): Promise<{
+    count: number;
+    diff?: undefined;
+} | {
+    count: number;
+    diff: string;
+}>;

package/stacks/diff.js

@@ -0,0 +1,62 @@
+export async function diff(stack, oldTemplate) {
+    const { diffTemplate, formatDifferences, TemplateDiff } = await import("@aws-cdk/cloudformation-diff");
+    // Generate diff
+    const diff = diffTemplate(oldTemplate, stack.template);
+    if (diff.isEmpty) {
+        return { count: 0 };
+    }
+    // Only display resource and output changes
+    // @ts-ignore
+    diff.iamChanges = { hasChanges: false };
+    // @ts-ignore
+    diff.securityGroupChanges = { hasChanges: false };
+    // @ts-ignore
+    diff.awsTemplateFormatVersion = false;
+    // @ts-ignore
+    diff.transform = false;
+    // @ts-ignore
+    diff.description = false;
+    // @ts-ignore
+    diff.parameters = { differenceCount: 0 };
+    // @ts-ignore
+    diff.metadata = { differenceCount: 0 };
+    // @ts-ignore
+    diff.mappings = { differenceCount: 0 };
+    // @ts-ignore
+    diff.conditions = { differenceCount: 0 };
+    // @ts-ignore
+    diff.unknown = { differenceCount: 0 };
+    // Filter out SST internal diffs
+    // @ts-ignore
+    delete diff.outputs.diffs?.["SSTMetadata"];
+    // Format diff
+    const output = [];
+    const stream = {
+        write(chunk) {
+            output.push(`   ${chunk}`);
+        },
+    };
+    const pathMap = await buildLogicalToPathMap(stack);
+    formatDifferences(stream, diff, pathMap);
+    // Remove trailing newline
+    while (true) {
+        if (output[output.length - 1].match(/^\s*$/)) {
+            output.pop();
+        }
+        else {
+            break;
+        }
+    }
+    return {
+        count: diff.outputs.differenceCount + diff.resources.differenceCount,
+        diff: output.join(""),
+    };
+}
+async function buildLogicalToPathMap(stack) {
+    const { ArtifactMetadataEntryType } = await import("@aws-cdk/cloud-assembly-schema");
+    const map = {};
+    for (const md of stack.findMetadataByType(ArtifactMetadataEntryType.LOGICAL_ID)) {
+        map[md.data] = md.path;
+    }
+    return map;
+}

package/stacks/index.d.ts

@@ -1,5 +1,8 @@
+export * from "./app-metadata.js";
+export * from "./assembly.js";
 export * from "./build.js";
 export * from "./deploy.js";
+export * from "./diff.js";
 export * from "./metadata.js";
 export * from "./synth.js";
 export * from "./monitor.js";

package/stacks/index.js

@@ -1,5 +1,8 @@
+export * from "./app-metadata.js";
+export * from "./assembly.js";
 export * from "./build.js";
 export * from "./deploy.js";
+export * from "./diff.js";
 export * from "./metadata.js";
 export * from "./synth.js";
 export * from "./monitor.js";

package/stacks/metadata.d.ts

@@ -2,6 +2,8 @@ import type { Metadata } from "../constructs/Metadata.js";
 declare module "../bus.js" {
     interface Events {
         "stacks.metadata": Awaited<ReturnType<typeof metadata>>;
+        "stacks.metadata.updated": {};
+        "stacks.metadata.deleted": {};
     }
 }
 export declare function metadata(): Promise<Record<string, Metadata[]>>;

package/stacks/metadata.js

@@ -5,9 +5,8 @@ import { json } from "stream/consumers";
 import { useCache } from "../cache.js";
 import { Context } from "../context/context.js";
 import { useBus } from "../bus.js";
-import { Stacks } from "./index.js";
 import { Logger } from "../logger.js";
-import { useProject } from "../app.js";
+import { useProject } from "../project.js";
 export async function metadata() {
     Logger.debug("Fetching all metadata");
     const project = useProject();
@@ -16,10 +15,10 @@ export async function metadata() {
         useBootstrap(),
     ]);
     const s3 = new S3Client({
-        region: project.region,
+        region: project.config.region,
         credentials: credentials,
     });
-    const key = `stackMetadata/app.${project.name}/stage.${project.stage}/`;
+    const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/`;
     const list = await s3.send(new ListObjectsV2Command({
         Prefix: key,
         Bucket: bootstrap.bucket,
@@ -44,10 +43,10 @@ export async function metadataForStack(stackID) {
         useBootstrap(),
     ]);
     const s3 = new S3Client({
-        region: project.region,
+        region: project.config.region,
         credentials: credentials,
     });
-    const key = `stackMetadata/app.${project.name}/stage.${project.stage}/stack.${stackID}.json`;
+    const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stackID}.json`;
     Logger.debug("Getting metadata", key, "from", bootstrap.bucket);
     try {
         const result = await s3
@@ -67,12 +66,15 @@ const MetadataContext = Context.create(async () => {
     const bus = useBus();
     const cache = await useCache();
     const data = await metadata();
-    bus.subscribe("stack.status", async (evt) => {
-        if (!Stacks.isSuccess(evt.properties.status))
-            return;
-        const meta = await metadataForStack(evt.properties.stackID);
-        Logger.debug("Got metadata", meta);
-        data[evt.properties.stackID] = meta;
+    bus.publish("stacks.metadata", data);
+    bus.subscribe("stacks.metadata.updated", async () => {
+        const data = await metadata();
+        await cache.write(`metadata.json`, JSON.stringify(data));
+        bus.publish("stacks.metadata", data);
+        MetadataContext.provide(Promise.resolve(data));
+    });
+    bus.subscribe("stacks.metadata.deleted", async () => {
+        const data = await metadata();
         await cache.write(`metadata.json`, JSON.stringify(data));
         bus.publish("stacks.metadata", data);
         MetadataContext.provide(Promise.resolve(data));

package/stacks/monitor.d.ts

@@ -1,4 +1,4 @@
-import { DescribeStackResourcesOutput } from "@aws-sdk/client-cloudformation";
+import { DescribeStackResourcesOutput, StackEvent } from "@aws-sdk/client-cloudformation";
 declare module "../bus.js" {
     interface Events {
         "stack.updated": {
@@ -6,12 +6,16 @@ declare module "../bus.js" {
         };
         "stack.status": {
             stackID: string;
-            status: typeof STATUSES[number];
+            status: (typeof STATUSES)[number];
         };
         "stack.resources": {
             stackID: string;
             resources: DescribeStackResourcesOutput["StackResources"];
         };
+        "stack.event": {
+            stackID: string;
+            event: StackEvent;
+        };
     }
 }
 export declare const STATUSES: readonly ["CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "REVIEW_IN_PROGRESS", "ROLLBACK_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_IN_PROGRESS", "CREATE_COMPLETE", "UPDATE_COMPLETE", "DELETE_COMPLETE", "SKIPPED", "CREATE_FAILED", "DELETE_FAILED", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "DEPENDENCY_FAILED"];
@@ -24,4 +28,5 @@ export declare function monitor(stack: string): Promise<{
     outputs: Record<string, string>;
     errors: Record<string, string>;
 }>;
-export declare type StackDeploymentResult = Awaited<ReturnType<typeof monitor>>;
+export declare function filterOutputs(input: Record<string, string>): Record<string, string>;
+export type StackDeploymentResult = Awaited<ReturnType<typeof monitor>>;

package/stacks/monitor.js

@@ -1,4 +1,4 @@
-import { CloudFormationClient, DescribeStackResourcesCommand, DescribeStacksCommand, } from "@aws-sdk/client-cloudformation";
+import { CloudFormationClient, DescribeStackResourcesCommand, DescribeStacksCommand, DescribeStackEventsCommand, } from "@aws-sdk/client-cloudformation";
 import { useBus } from "../bus.js";
 import { useAWSClient } from "../credentials.js";
 import { Logger } from "../logger.js";
@@ -53,23 +53,51 @@ export async function monitor(stack) {
     ]);
     let lastStatus;
     const errors = {};
+    let lastEvent;
     while (true) {
         try {
-            const [describe, resources] = await Promise.all([
+            const [describe, resources, events] = await Promise.all([
                 cfn.send(new DescribeStacksCommand({
                     StackName: stack,
                 })),
                 cfn.send(new DescribeStackResourcesCommand({
                     StackName: stack,
                 })),
+                cfn.send(new DescribeStackEventsCommand({
+                    StackName: stack,
+                })),
             ]);
             Logger.debug("Stack description", describe);
+            if (lastEvent) {
+                const eventsReversed = [...(events.StackEvents ?? [])].reverse();
+                for (const event of eventsReversed) {
+                    if (!event.Timestamp)
+                        continue;
+                    if (event.Timestamp.getTime() > lastEvent.getTime()) {
+                        bus.publish("stack.event", {
+                            event: event,
+                            stackID: stack,
+                        });
+                        if (event.ResourceStatusReason) {
+                            if (event.ResourceStatusReason.includes("Resource creation cancelled") ||
+                                event.ResourceStatusReason.includes("Resource update cancelled") ||
+                                event.ResourceStatusReason?.includes("Resource creation Initiated"))
+                                continue;
+                            errors[event.LogicalResourceId] = event.ResourceStatusReason;
+                        }
+                    }
+                }
+                Logger.debug("Last event set to", lastEvent);
+            }
+            lastEvent = events.StackEvents?.at(0)?.Timestamp;
             bus.publish("stack.resources", {
                 stackID: stack,
                 resources: resources.StackResources,
             });
             for (const resource of resources.StackResources || []) {
-                if (resource.ResourceStatusReason?.includes("Resource creation cancelled"))
+                if (resource.ResourceStatusReason?.includes("Resource creation cancelled") ||
+                    resource.ResourceStatusReason?.includes("Resource update cancelled") ||
+                    resource.ResourceStatusReason?.includes("Resource creation Initiated"))
                     continue;
                 if (resource.ResourceStatusReason)
                     errors[resource.LogicalResourceId] = resource.ResourceStatusReason;
@@ -86,7 +114,7 @@ export async function monitor(stack) {
                     if (isFinal(first.StackStatus)) {
                         return {
                             status: first.StackStatus,
-                            outputs: Object.fromEntries(first.Outputs?.map((o) => [o.OutputKey, o.OutputValue]) || []),
+                            outputs: pipe(first.Outputs || [], map((o) => [o.OutputKey, o.OutputValue]), Object.fromEntries, filterOutputs),
                             errors: isFailed(first.StackStatus) ? errors : {},
                         };
                     }
@@ -109,3 +137,9 @@ export async function monitor(stack) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
+import { map, omitBy, pipe } from "remeda";
+export function filterOutputs(input) {
+    return pipe(input, omitBy((_, key) => {
+        return key.startsWith("Export") || key === "SSTMetadata";
+    }));
+}

package/stacks/remove.js

@@ -8,11 +8,7 @@ export async function removeMany(stacks) {
     const bus = useBus();
     const complete = new Set();
     const todo = new Set(stacks.map((s) => s.id));
-    const pending = new Set();
     const results = {};
-    bus.subscribe("stack.updated", (evt) => {
-        pending.add(evt.properties.stackID);
-    });
     return new Promise((resolve) => {
         async function trigger() {
             for (const stack of stacks) {

package/stacks/synth.d.ts

@@ -3,6 +3,7 @@ interface SynthOptions {
     buildDir?: string;
     outDir?: string;
     skipBuild?: boolean;
+    increaseTimeout?: boolean;
     mode: App["mode"];
     fn: (app: App) => Promise<void> | void;
 }