sst 2.0.0-rc.7 → 2.0.0-rc.71

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: string;
+    bucket: string;
 }>;

package/bootstrap.js

@@ -1,79 +1,226 @@
-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 { 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";
+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 { useAWSClient, useAWSCredentials, useSTSIdentity, } 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 = "6";
+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) {
-        const project = useProject();
+    let [cdkStatus, sstStatus] = await Promise.all([
+        loadCDKStatus(),
+        loadSSTStatus(),
+    ]);
+    Logger.debug("Loaded bootstrap status");
+    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();
-        const app = new App();
-        const stack = new Stack(app, "SSTBootstrap", {
+        if (needToBootstrapCDK) {
+            await bootstrapCDK();
+        }
+        if (needToBootstrapSST) {
+            await bootstrapSST();
+            // fetch bootstrap status
+            sstStatus = await loadSSTStatus();
+            if (!sstStatus)
+                throw new VisibleError("Failed to load bootstrap stack status");
+        }
+        spinner.succeed();
+    }
+    Logger.debug("Bootstrap context initialized", sstStatus);
+    return sstStatus;
+}, "Bootstrap");
+async function loadCDKStatus() {
+    const client = useAWSClient(CloudFormationClient);
+    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,
+        environment: {
+            BUCKET_NAME: bucket.bucketName,
+        },
+        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)}`);
+    }
+}
+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}/${region}`,
+            "--no-version-reporting",
+        ].join(" "), {
             env: {
-                region: project.region,
+                ...process.env,
+                AWS_ACCESS_KEY_ID: credentials.accessKeyId,
+                AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
+                AWS_SESSION_TOKEN: credentials.sessionToken,
+                AWS_REGION: region,
+                AWS_PROFILE: profile,
             },
+            stdio: "pipe",
+            shell: process.env.SHELL || true,
         });
-        const tags = {};
-        for (const [key, value] of Object.entries(tags)) {
-            Tags.of(app).add(key, value);
-        }
-        const bucket = new Bucket(stack, project.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,
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            Logger.debug(data.toString());
         });
-        new StringParameter(stack, SSM_NAME_STACK_NAME, {
-            parameterName: SSM_NAME_STACK_NAME,
-            stringValue: stack.stackName,
-            tier: ParameterTier.STANDARD,
+        proc.stderr.on("data", (data) => {
+            Logger.debug(data.toString());
+            stderr += data;
         });
-        new StringParameter(stack, SSM_NAME_BUCKET_NAME, {
-            parameterName: SSM_NAME_BUCKET_NAME,
-            stringValue: bucket.bucketName,
-            tier: ParameterTier.STANDARD,
+        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`));
+            }
         });
-        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 loadSSTStatus() {
+    // 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;
         }
-        spinner.succeed();
-        return ssm();
+        throw e;
     }
-    Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
-    return ret;
-});
-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,
-    };
+    // 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/bus.js

@@ -30,7 +30,7 @@ export const useBus = Context.memo(() => {
         unsubscribe(sub) {
             const arr = subscribers(sub.type);
             const index = arr.indexOf(sub);
-            if (!index)
+            if (index < 0)
                 return;
             arr.splice(index, 1);
         },

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/cloudformation-deployments-wrapper.d.ts

@@ -0,0 +1,3 @@
+import { SdkProvider } from "aws-cdk/lib/api/aws-auth/sdk-provider.js";
+import { DeployStackOptions as PublishStackAssetsOptions } from "./cloudformation-deployments.js";
+export declare function publishDeployAssets(sdkProvider: SdkProvider, options: PublishStackAssetsOptions): Promise<any>;

package/cdk/cloudformation-deployments-wrapper.js

@@ -0,0 +1,117 @@
+import { debug } from "aws-cdk/lib/logging.js";
+import { CloudFormationStack, TemplateParameters, waitForStackDelete, } from "aws-cdk/lib/api/util/cloudformation.js";
+import { ToolkitInfo } from "aws-cdk/lib/api/toolkit-info.js";
+import { addMetadataAssetsToManifest } from "aws-cdk/lib/assets.js";
+import { publishAssets } from "aws-cdk/lib/util/asset-publishing.js";
+import { AssetManifestBuilder } from "aws-cdk/lib/util/asset-manifest-builder.js";
+import { CloudFormationDeployments, } from "./cloudformation-deployments.js";
+import { makeBodyParameter } from "./deploy-stack.js";
+import { Context } from "../context/context.js";
+export async function publishDeployAssets(sdkProvider, options) {
+    const { deployment, toolkitInfo, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
+    await deployment.publishStackAssets(options.stack, toolkitInfo, {
+        buildAssets: options.buildAssets ?? true,
+        publishOptions: {
+            quiet: options.quiet,
+            parallel: options.assetParallelism,
+        },
+    });
+    return deployStack({
+        stack: options.stack,
+        noMonitor: true,
+        resolvedEnvironment,
+        deployName: options.deployName,
+        notificationArns: options.notificationArns,
+        quiet: options.quiet,
+        sdk: stackSdk,
+        sdkProvider,
+        roleArn: cloudFormationRoleArn,
+        reuseAssets: options.reuseAssets,
+        toolkitInfo,
+        tags: options.tags,
+        deploymentMethod: options.deploymentMethod,
+        force: options.force,
+        parameters: options.parameters,
+        usePreviousParameters: options.usePreviousParameters,
+        progress: options.progress,
+        ci: options.ci,
+        rollback: options.rollback,
+        hotswap: options.hotswap,
+        extraUserAgent: options.extraUserAgent,
+        resourcesToImport: options.resourcesToImport,
+        overrideTemplate: options.overrideTemplate,
+        assetParallelism: options.assetParallelism,
+    });
+}
+const useDeployment = Context.memo(() => {
+    const state = new Map();
+    return {
+        async get(sdkProvider, options) {
+            if (!state.has(sdkProvider)) {
+                const deployment = new CloudFormationDeployments({ sdkProvider });
+                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn);
+                const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
+                // Do a verification of the bootstrap stack version
+                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+                state.set(sdkProvider, {
+                    deployment,
+                    toolkitInfo,
+                    stackSdk,
+                    resolvedEnvironment,
+                    cloudFormationRoleArn,
+                });
+            }
+            return state.get(sdkProvider);
+        },
+    };
+});
+async function deployStack(options) {
+    const stackArtifact = options.stack;
+    const stackEnv = options.resolvedEnvironment;
+    options.sdk.appendCustomUserAgent(options.extraUserAgent);
+    const cfn = options.sdk.cloudFormation();
+    const deployName = options.deployName || stackArtifact.stackName;
+    let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
+    if (cloudFormationStack.stackStatus.isCreationFailure) {
+        debug(`Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`);
+        await cfn.deleteStack({ StackName: deployName }).promise();
+        const deletedStack = await waitForStackDelete(cfn, deployName);
+        if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
+            throw new Error(`Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`);
+        }
+        // Update variable to mark that the stack does not exist anymore, but avoid
+        // doing an actual lookup in CloudFormation (which would be silly to do if
+        // we just deleted it).
+        cloudFormationStack = CloudFormationStack.doesNotExist(cfn, deployName);
+    }
+    // Detect "legacy" assets (which remain in the metadata) and publish them via
+    // an ad-hoc asset manifest, while passing their locations via template
+    // parameters.
+    const legacyAssets = new AssetManifestBuilder();
+    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.toolkitInfo, options.reuseAssets);
+    const finalParameterValues = { ...options.parameters, ...assetParams };
+    const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
+    const stackParams = options.usePreviousParameters
+        ? templateParams.updateExisting(finalParameterValues, cloudFormationStack.parameters)
+        : templateParams.supplyAll(finalParameterValues);
+    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.toolkitInfo, options.sdk, options.overrideTemplate);
+    await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
+        parallel: options.assetParallelism,
+    });
+    return {
+        isUpdate: cloudFormationStack.exists &&
+            cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS",
+        params: {
+            StackName: deployName,
+            TemplateBody: bodyParameter.TemplateBody,
+            TemplateURL: bodyParameter.TemplateURL,
+            Parameters: stackParams.apiParameters,
+            Capabilities: [
+                "CAPABILITY_IAM",
+                "CAPABILITY_NAMED_IAM",
+                "CAPABILITY_AUTO_EXPAND",
+            ],
+            Tags: options.tags,
+        },
+    };
+}

package/cdk/cloudformation-deployments.d.ts

@@ -1,9 +1,11 @@
 import * as cxapi from "@aws-cdk/cx-api";
 import { Tag } from "aws-cdk/lib/cdk-toolkit.js";
-import { BuildAssetsOptions } from "aws-cdk/lib/util/asset-publishing.js";
+import { BuildAssetsOptions, PublishAssetsOptions } from "aws-cdk/lib/util/asset-publishing.js";
+import { Mode } from "aws-cdk/lib/api/aws-auth/credentials.js";
 import { ISDK } from "aws-cdk/lib/api/aws-auth/sdk.js";
 import { SdkProvider } from "aws-cdk/lib/api/aws-auth/sdk-provider.js";
 import { DeployStackResult, DeploymentMethod } from "./deploy-stack.js";
+import { ToolkitInfo } from "aws-cdk/lib/api/toolkit-info.js";
 import { Template, ResourcesToImport, ResourceIdentifierSummaries } from "aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 /**
@@ -203,6 +205,18 @@ export interface BuildStackAssetsOptions {
      */
     readonly buildOptions?: BuildAssetsOptions;
 }
+interface PublishStackAssetsOptions {
+    /**
+     * Whether to build assets before publishing.
+     *
+     * @default true To remain backward compatible.
+     */
+    readonly buildAssets?: boolean;
+    /**
+     * Options to pass on to `publishAsests()` function
+     */
+    readonly publishOptions?: Omit<PublishAssetsOptions, "buildAssets">;
+}
 export interface DestroyStackOptions {
     stack: cxapi.CloudFormationStackArtifact;
     deployName?: string;
@@ -264,7 +278,7 @@ export declare class CloudFormationDeployments {
      * - SDK loaded with the right credentials for calling `CreateChangeSet`.
      * - The Execution Role that should be passed to CloudFormation.
      */
-    private prepareSdkFor;
+    prepareSdkFor(stack: cxapi.CloudFormationStackArtifact, roleArn?: string, mode?: Mode): Promise<PreparedSdkForEnvironment>;
     /**
      * Build a stack's assets.
      */
@@ -272,9 +286,10 @@ export declare class CloudFormationDeployments {
     /**
      * Publish all asset manifests that are referenced by the given stack
      */
-    private publishStackAssets;
+    publishStackAssets(stack: cxapi.CloudFormationStackArtifact, toolkitInfo: ToolkitInfo, options?: PublishStackAssetsOptions): Promise<void>;
     /**
      * Validate that the bootstrap stack has the right version for this stack
      */
-    private validateBootstrapStackVersion;
+    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, toolkitInfo: ToolkitInfo): Promise<void>;
 }
+export {};

package/cdk/deploy-stack.d.ts

@@ -1,10 +1,11 @@
 import * as cxapi from "@aws-cdk/cx-api";
 import { Tag } from "aws-cdk/lib/cdk-toolkit.js";
+import { AssetManifestBuilder } from "aws-cdk/lib/util/asset-manifest-builder.js";
 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 +167,7 @@ export interface DeployStackOptions {
      */
     readonly assetParallelism?: boolean;
 }
-export declare type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
+export type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
 export interface DirectDeploymentMethod {
     readonly method: "direct";
 }
@@ -185,6 +186,20 @@ export interface ChangeSetDeploymentMethod {
     readonly changeSetName?: string;
 }
 export declare function deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, toolkitInfo: ToolkitInfo, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 /**
  * Prepare a body parameter for CFN, performing the upload
  *

package/cdk/deploy-stack.js

@@ -340,7 +340,7 @@ class FullCloudFormationDeployment {
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
+export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
     // If the template has already been uploaded to S3, just use it from there.
     if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
         return {
@@ -459,6 +459,11 @@ async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterC
         debug(`${deployName}: no existing stack`);
         return false;
     }
+    // SST check: stack is not busy
+    if (cloudFormationStack.stackStatus.isInProgress) {
+        debug(`${deployName}: stack is busy`);
+        return false;
+    }
     // Template has changed (assets taken into account here)
     if (JSON.stringify(deployStackOptions.stack.template) !==
         JSON.stringify(await cloudFormationStack.template())) {

package/cli/colors.d.ts

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+declare let last: "line" | "gap";
+export declare const Colors: {
+    line: (message?: any, ...optionalParams: any[]) => void;
+    mode(input: typeof last): void;
+    gap(): void;
+    hex: (color: string) => chalk.Chalk;
+    primary: chalk.Chalk;
+    link: chalk.Chalk;
+    success: chalk.Chalk;
+    danger: chalk.Chalk;
+    warning: chalk.Chalk;
+    dim: chalk.Chalk;
+    bold: chalk.Chalk;
+    all: chalk.Chalk & chalk.ChalkFunction & {
+        supportsColor: false | chalk.ColorSupport;
+        Level: chalk.Level;
+        Color: ("red" | "green" | "yellow" | "black" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
+        ForegroundColor: "red" | "green" | "yellow" | "black" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+        Modifiers: "bold" | "dim" | "reset" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough" | "visible";
+        stderr: chalk.Chalk & {
+            supportsColor: false | chalk.ColorSupport;
+        };
+    };
+    prefix: string;
+};
+export {};

package/cli/colors.js

@@ -0,0 +1,27 @@
+import chalk from "chalk";
+let last = "gap";
+export const Colors = {
+    line: (message, ...optionalParams) => {
+        last = "line";
+        console.log(message, ...optionalParams);
+    },
+    mode(input) {
+        last = input;
+    },
+    gap() {
+        if (last === "line") {
+            last = "gap";
+            console.log();
+        }
+    },
+    hex: chalk.hex,
+    primary: chalk.hex("#E27152"),
+    link: chalk.cyan,
+    success: chalk.green,
+    danger: chalk.red,
+    warning: chalk.yellow,
+    dim: chalk.dim,
+    bold: chalk.bold,
+    all: chalk,
+    prefix: chalk.bold("| "),
+};

package/cli/commands/bind.d.ts

@@ -6,6 +6,10 @@ export declare const bind: (program: Program) => import("yargs").Argv<{
     profile: string | undefined;
 } & {
     region: string | undefined;
+} & {
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
 } & {
     command: string;
 }>;