sst 2.28.6 → 2.29.2

package/cdk/deploy-stack.d.ts

@@ -2,8 +2,8 @@ import * as cxapi from "@aws-cdk/cx-api";
 import { Tag } from "sst-aws-cdk/lib/cdk-toolkit.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
 import { ISDK, SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/index.js";
+import { EnvironmentResources } from "sst-aws-cdk/lib/api/environment-resources.js";
 import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
 import { ResourcesToImport } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "sst-aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 type TemplateBodyParameter = {
@@ -56,7 +56,7 @@ export interface DeployStackOptions {
     /**
      * Information about the bootstrap stack found in the target environment
      */
-    readonly toolkitInfo: ToolkitInfo;
+    readonly envResources: EnvironmentResources;
     /**
      * Role to pass to CloudFormation to execute the change set
      *
@@ -200,14 +200,14 @@ export declare function deployStack(options: DeployStackOptions): Promise<Deploy
  * @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>;
+export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 /**
  * Prepare a body parameter for CFN, performing the upload
  *
  * Return it as-is if it is small enough to pass in the API call,
  * upload to S3 and return the coordinates if it is not.
  */
-export declare function makeBodyParameterAndUpload(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, toolkitInfo: ToolkitInfo, sdkProvider: SdkProvider, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
+export declare function makeBodyParameterAndUpload(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, resources: EnvironmentResources, sdkProvider: SdkProvider, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 export interface DestroyStackOptions {
     /**
      * The stack to be destroyed

package/cdk/deploy-stack.js

@@ -37,7 +37,7 @@ export async function deployStack(options) {
     // 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 assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, options.reuseAssets);
     const finalParameterValues = { ...options.parameters, ...assetParams };
     const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
     const stackParams = options.usePreviousParameters
@@ -58,7 +58,7 @@ export async function deployStack(options) {
     else {
         debug(`${deployName}: deploying...`);
     }
-    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.toolkitInfo, options.sdk, options.overrideTemplate);
+    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.sdk, options.overrideTemplate);
     await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
         parallel: options.assetParallelism,
     });
@@ -352,7 +352,7 @@ class FullCloudFormationDeployment {
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
+export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, resources, sdk, overrideTemplate) {
     // If the template has already been uploaded to S3, just use it from there.
     if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
         return {
@@ -364,6 +364,7 @@ export async function makeBodyParameter(stack, resolvedEnvironment, assetManifes
     if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
         return { TemplateBody: templateJson };
     }
+    const toolkitInfo = await resources.lookupToolkit();
     if (!toolkitInfo.found) {
         error(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
             `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
@@ -394,14 +395,14 @@ export async function makeBodyParameter(stack, resolvedEnvironment, assetManifes
  * Return it as-is if it is small enough to pass in the API call,
  * upload to S3 and return the coordinates if it is not.
  */
-export async function makeBodyParameterAndUpload(stack, resolvedEnvironment, toolkitInfo, sdkProvider, sdk, overrideTemplate) {
+export async function makeBodyParameterAndUpload(stack, resolvedEnvironment, resources, sdkProvider, sdk, overrideTemplate) {
     // We don't have access to the actual asset manifest here, so pretend that the
     // stack doesn't have a pre-published URL.
     const forceUploadStack = Object.create(stack, {
         stackTemplateAssetObjectUrl: { value: undefined },
     });
     const builder = new AssetManifestBuilder();
-    const bodyparam = await makeBodyParameter(forceUploadStack, resolvedEnvironment, builder, toolkitInfo, sdk, overrideTemplate);
+    const bodyparam = await makeBodyParameter(forceUploadStack, resolvedEnvironment, builder, resources, sdk, overrideTemplate);
     const manifest = builder.toManifest(stack.assembly.directory);
     await publishAssets(manifest, sdkProvider, resolvedEnvironment, {
         quiet: true,

package/cdk/deployments-wrapper.js

@@ -3,7 +3,6 @@ import { AssetManifest } from "cdk-assets";
 import { debug } from "sst-aws-cdk/lib/logging.js";
 import { CloudFormationStack, TemplateParameters, waitForStackDelete, } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
 import { addMetadataAssetsToManifest } from "sst-aws-cdk/lib/assets.js";
 import { publishAssets } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
@@ -11,7 +10,7 @@ import { Deployments, } from "./deployments.js";
 import { makeBodyParameter } from "./deploy-stack.js";
 import { lazy } from "../util/lazy.js";
 export async function publishDeployAssets(sdkProvider, options) {
-    const { deployment, toolkitInfo, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
+    const { deployment, envResources, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
     // TODO
     // old
     //await deployment.publishStackAssets(options.stack, toolkitInfo, {
@@ -44,7 +43,7 @@ export async function publishDeployAssets(sdkProvider, options) {
         sdkProvider,
         roleArn: cloudFormationRoleArn,
         reuseAssets: options.reuseAssets,
-        toolkitInfo,
+        envResources,
         tags: options.tags,
         deploymentMethod: options.deploymentMethod,
         force: options.force,
@@ -67,13 +66,12 @@ const useDeployment = lazy(() => {
             const region = options.stack.environment.region;
             if (!state.has(region)) {
                 const deployment = new Deployments({ sdkProvider });
-                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-                const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
+                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn, envResources, } = await deployment.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
                 // Do a verification of the bootstrap stack version
-                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, envResources);
                 state.set(region, {
                     deployment,
-                    toolkitInfo,
+                    envResources,
                     stackSdk,
                     resolvedEnvironment,
                     cloudFormationRoleArn,
@@ -106,13 +104,13 @@ async function deployStack(options) {
     // 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 assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, 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);
+    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.sdk, options.overrideTemplate);
     await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
         parallel: options.assetParallelism,
     });

package/cdk/deployments.d.ts

@@ -6,7 +6,7 @@ import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import { ISDK } from "sst-aws-cdk/lib/api/aws-auth/sdk.js";
 import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
 import { DeployStackResult, DeploymentMethod } from "./deploy-stack.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
+import { EnvironmentResources } from "sst-aws-cdk/lib/api/environment-resources.js";
 import { Template, ResourcesToImport, ResourceIdentifierSummaries } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "sst-aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
@@ -31,6 +31,10 @@ export interface PreparedSdkWithLookupRoleForEnvironment {
      * the default credentials (not the assume role credentials)
      */
     readonly didAssumeRole: boolean;
+    /**
+     * An object for accessing the bootstrap resources in this environment
+     */
+    readonly envResources: EnvironmentResources;
 }
 export interface DeployStackOptions {
     /**
@@ -212,6 +216,7 @@ export interface StackExistsOptions {
 }
 export interface DeploymentsProps {
     sdkProvider: SdkProvider;
+    readonly toolkitStackName?: string;
     readonly quiet?: boolean;
 }
 /**
@@ -234,6 +239,10 @@ export interface PreparedSdkForEnvironment {
      * @default - no execution role is used
      */
     readonly cloudFormationRoleArn?: string;
+    /**
+     * Access class for environmental resources to help the deployment
+     */
+    readonly envResources: EnvironmentResources;
 }
 /**
  * Scope for a single set of deployments from a set of Cloud Assembly Artifacts
@@ -243,13 +252,13 @@ export interface PreparedSdkForEnvironment {
 export declare class Deployments {
     private readonly props;
     private readonly sdkProvider;
-    private readonly toolkitInfoCache;
     private readonly sdkCache;
     private readonly publisherCache;
+    private readonly environmentResources;
     constructor(props: DeploymentsProps);
     readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact, retrieveProcessedTemplate?: boolean): Promise<Template>;
     readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template>;
-    resourceIdentifierSummaries(stackArtifact: cxapi.CloudFormationStackArtifact, toolkitStackName?: string): Promise<ResourceIdentifierSummaries>;
+    resourceIdentifierSummaries(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<ResourceIdentifierSummaries>;
     deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;
     destroyStack(options: DestroyStackOptions): Promise<void>;
     stackExists(options: StackExistsOptions): Promise<boolean>;
@@ -283,10 +292,6 @@ export declare class Deployments {
      * function can then decide to use them or fallback to another role.
      */
     prepareSdkWithLookupRoleFor(stack: cxapi.CloudFormationStackArtifact): Promise<PreparedSdkWithLookupRoleForEnvironment>;
-    /**
-     * Look up the toolkit for a given environment, using a given SDK
-     */
-    lookupToolkit(resolvedEnvironment: cxapi.Environment, sdk: ISDK, toolkitStackName?: string): Promise<ToolkitInfo>;
     private prepareAndValidateAssets;
     /**
      * Build all assets in a manifest
@@ -314,8 +319,10 @@ export declare class Deployments {
     isSingleAssetPublished(assetManifest: AssetManifest, asset: IManifestEntry, options: PublishStackAssetsOptions): Promise<boolean>;
     /**
      * Validate that the bootstrap stack has the right version for this stack
+     *
+     * Call into envResources.validateVersion, but prepend the stack name in case of failure.
      */
-    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, toolkitInfo: ToolkitInfo): Promise<void>;
+    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, envResources: EnvironmentResources): Promise<void>;
     private cachedSdkForEnvironment;
     private cachedPublisher;
 }

package/cdk/deployments.js

@@ -6,11 +6,10 @@ import { debug, warning } from "sst-aws-cdk/lib/logging.js";
 import { buildAssets, publishAssets, PublishingAws, EVENT_TO_LOGGER, } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import { deployStack, destroyStack, makeBodyParameterAndUpload, } from "./deploy-stack.js";
-import { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, } from "sst-aws-cdk/lib/api/nested-stack-helpers.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
+import { EnvironmentResourcesRegistry, } from "sst-aws-cdk/lib/api/environment-resources.js";
+import { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, flattenNestedStackNames, } from "sst-aws-cdk/lib/api/nested-stack-helpers.js";
 import { CloudFormationStack, } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { replaceEnvPlaceholders } from "sst-aws-cdk/lib/api/util/placeholders.js";
-import { callWithRetry } from "./util.js";
 /**
  * Scope for a single set of deployments from a set of Cloud Assembly Artifacts
  *
@@ -19,17 +18,22 @@ import { callWithRetry } from "./util.js";
 export class Deployments {
     props;
     sdkProvider;
-    toolkitInfoCache = new Map();
     sdkCache = new Map();
     publisherCache = new Map();
+    environmentResources;
     constructor(props) {
         this.props = props;
         this.sdkProvider = props.sdkProvider;
+        this.environmentResources = new EnvironmentResourcesRegistry(props.toolkitStackName);
     }
     async readCurrentTemplateWithNestedStacks(rootStackArtifact, retrieveProcessedTemplate = false) {
         const sdk = (await this.prepareSdkWithLookupOrDeployRole(rootStackArtifact))
             .stackSdk;
-        return (await loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate)).deployedTemplate;
+        const templateWithNestedStacks = await loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate);
+        return {
+            deployedTemplate: templateWithNestedStacks.deployedTemplate,
+            nestedStackCount: flattenNestedStackNames(templateWithNestedStacks.nestedStackNames).length,
+        };
     }
     async readCurrentTemplate(stackArtifact) {
         debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
@@ -37,15 +41,14 @@ export class Deployments {
             .stackSdk;
         return loadCurrentTemplate(stackArtifact, sdk);
     }
-    async resourceIdentifierSummaries(stackArtifact, toolkitStackName) {
+    async resourceIdentifierSummaries(stackArtifact) {
         debug(`Retrieving template summary for stack ${stackArtifact.displayName}.`);
         // Currently, needs to use `deploy-role` since it may need to read templates in the staging
         // bucket which have been encrypted with a KMS key (and lookup-role may not read encrypted things)
-        const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
+        const { stackSdk, resolvedEnvironment, envResources } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
         const cfn = stackSdk.cloudFormation();
-        const toolkitInfo = await this.lookupToolkit(resolvedEnvironment, stackSdk, toolkitStackName);
         // Upload the template, if necessary, before passing it to CFN
-        const cfnParam = await makeBodyParameterAndUpload(stackArtifact, resolvedEnvironment, toolkitInfo, this.sdkProvider, stackSdk);
+        const cfnParam = await makeBodyParameterAndUpload(stackArtifact, resolvedEnvironment, envResources, this.sdkProvider, stackSdk);
         const response = await cfn.getTemplateSummary(cfnParam).promise();
         if (!response.ResourceIdentifierSummaries) {
             debug('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"');
@@ -64,10 +67,9 @@ export class Deployments {
                 execute: options.execute,
             };
         }
-        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await callWithRetry(() => this.lookupToolkit(resolvedEnvironment, stackSdk, options.toolkitStackName));
+        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn, envResources, } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
         // Do a verification of the bootstrap stack version
-        await this.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+        await this.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, envResources);
         // Deploy assets
         const assetArtifacts = options.stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact);
         for (const asset of assetArtifacts) {
@@ -89,7 +91,7 @@ export class Deployments {
             sdkProvider: this.sdkProvider,
             roleArn: cloudFormationRoleArn,
             reuseAssets: options.reuseAssets,
-            toolkitInfo,
+            envResources,
             tags: options.tags,
             deploymentMethod,
             force: options.force,
@@ -129,6 +131,7 @@ export class Deployments {
                 return {
                     resolvedEnvironment: result.resolvedEnvironment,
                     stackSdk: result.sdk,
+                    envResources: result.envResources,
                 };
             }
         }
@@ -164,6 +167,7 @@ export class Deployments {
             stackSdk: stackSdk.sdk,
             resolvedEnvironment,
             cloudFormationRoleArn: arns.cloudFormationRoleArn,
+            envResources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk),
         };
     }
     /**
@@ -198,11 +202,12 @@ export class Deployments {
                 assumeRoleArn: arns.lookupRoleArn,
                 assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,
             });
+            const envResources = this.environmentResources.for(resolvedEnvironment, stackSdk.sdk);
             // if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version
             if (stackSdk.didAssumeRole &&
                 stack.lookupRole?.bootstrapStackVersionSsmParameter &&
                 stack.lookupRole.requiresBootstrapStackVersion) {
-                const version = await ToolkitInfo.versionFromSsmParameter(stackSdk.sdk, stack.lookupRole.bootstrapStackVersionSsmParameter);
+                const version = await envResources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);
                 if (version < stack.lookupRole.requiresBootstrapStackVersion) {
                     throw new Error(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'.`);
                 }
@@ -213,7 +218,7 @@ export class Deployments {
                 stack.lookupRole?.requiresBootstrapStackVersion) {
                 warning(upgradeMessage);
             }
-            return { ...stackSdk, resolvedEnvironment };
+            return { ...stackSdk, resolvedEnvironment, envResources };
         }
         catch (e) {
             debug(e);
@@ -226,26 +231,11 @@ export class Deployments {
             throw e;
         }
     }
-    /**
-     * Look up the toolkit for a given environment, using a given SDK
-     */
-    async lookupToolkit(resolvedEnvironment, sdk, toolkitStackName) {
-        const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}:${toolkitStackName}`;
-        const existing = this.toolkitInfoCache.get(key);
-        if (existing) {
-            return existing;
-        }
-        const ret = await ToolkitInfo.lookup(resolvedEnvironment, sdk, toolkitStackName);
-        this.toolkitInfoCache.set(key, ret);
-        return ret;
-    }
     async prepareAndValidateAssets(asset, options) {
-        const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await this.lookupToolkit(resolvedEnvironment, stackSdk, options.toolkitStackName);
-        const stackEnv = await this.sdkProvider.resolveEnvironment(options.stack.environment);
-        await this.validateBootstrapStackVersion(options.stack.stackName, asset.requiresBootstrapStackVersion, asset.bootstrapStackVersionSsmParameter, toolkitInfo);
+        const { envResources } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        await this.validateBootstrapStackVersion(options.stack.stackName, asset.requiresBootstrapStackVersion, asset.bootstrapStackVersionSsmParameter, envResources);
         const manifest = AssetManifest.fromFile(asset.file);
-        return { manifest, stackEnv };
+        return { manifest, stackEnv: envResources.environment };
     }
     /**
      * Build all assets in a manifest
@@ -270,10 +260,9 @@ export class Deployments {
      */
     // eslint-disable-next-line max-len
     async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
-        const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await this.lookupToolkit(stackEnv, stackSdk, options.toolkitStackName);
-        await this.validateBootstrapStackVersion(options.stack.stackName, assetArtifact.requiresBootstrapStackVersion, assetArtifact.bootstrapStackVersionSsmParameter, toolkitInfo);
-        const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
+        const { resolvedEnvironment, envResources } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        await this.validateBootstrapStackVersion(options.stack.stackName, assetArtifact.requiresBootstrapStackVersion, assetArtifact.bootstrapStackVersionSsmParameter, envResources);
+        const publisher = this.cachedPublisher(assetManifest, resolvedEnvironment, options.stackName);
         await publisher.buildEntry(asset);
     }
     /**
@@ -296,13 +285,12 @@ export class Deployments {
     }
     /**
      * Validate that the bootstrap stack has the right version for this stack
+     *
+     * Call into envResources.validateVersion, but prepend the stack name in case of failure.
      */
-    async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, toolkitInfo) {
-        if (requiresBootstrapStackVersion === undefined) {
-            return;
-        }
+    async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, envResources) {
         try {
-            await toolkitInfo.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
+            await envResources.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
         }
         catch (e) {
             throw new Error(`${stackName}: ${e.message}`);

package/cli/commands/bind.js

@@ -81,13 +81,10 @@ export const bind = (program) => program
         });
         async function buildApp() {
             const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-            const cwd = process.cwd();
-            process.chdir(project.paths.root);
             await Stacks.synth({
                 fn: sstConfig.stacks,
                 mode: "remove",
             });
-            process.chdir(cwd);
         }
         function isInSsrSite() {
             const cwd = process.cwd();

package/cli/sst.js

@@ -3,7 +3,6 @@ import { blue, red } from "colorette";
 import { program } from "./program.js";
 import { SilentError, VisibleError } from "../error.js";
 import { useSpinners } from "./spinner.js";
-import { Logger } from "../logger.js";
 import dotenv from "dotenv";
 dotenv.config({
     override: true,
@@ -48,7 +47,6 @@ if ("setSourceMapsEnabled" in process) {
 }
 process.removeAllListeners("uncaughtException");
 process.on("uncaughtException", (err) => {
-    Logger.debug(err);
     const spinners = useSpinners();
     for (const spinner of spinners) {
         if (spinner.isSpinning)
@@ -68,7 +66,7 @@ process.on("uncaughtException", (err) => {
 });
 // Check Node version
 const nodeVersion = process.versions.node;
-if (Number(nodeVersion.split(".")[0]) < 16) {
-    throw new VisibleError(`Node.js version ${nodeVersion} is not supported by SST. Please upgrade to Node.js 16 or later.`);
+if (Number(nodeVersion.split(".")[0]) < 18) {
+    throw new VisibleError(`Node.js version ${nodeVersion} is not supported by SST. Please upgrade to Node.js 18 or later.`);
 }
 program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.28.6",
+  "version": "2.29.2",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -87,7 +87,7 @@
     "ora": "^6.1.2",
     "react": "18.2.0",
     "remeda": "^1.3.0",
-    "sst-aws-cdk": "2.91.0",
+    "sst-aws-cdk": "2.95.1",
     "tree-kill": "^1.2.2",
     "undici": "^5.12.0",
     "uuid": "^9.0.0",
@@ -119,7 +119,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.28.6",
+    "astro-sst": "2.29.2",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",
     "vitest": "^0.33.0"

package/runtime/handlers.js

@@ -114,6 +114,7 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
+    const semaphore = new Semaphore(4);
     const result = {
         artifact: (functionID) => {
             if (artifacts.has(functionID))
@@ -121,13 +122,19 @@ export const useFunctionBuilder = lazy(() => {
             return result.build(functionID);
         },
         build: async (functionID) => {
-            const result = await handlers.build(functionID, "start");
-            if (!result)
-                return;
-            if (result.type === "error")
-                return;
-            artifacts.set(functionID, result);
-            return artifacts.get(functionID);
+            const unlock = await semaphore.lock();
+            try {
+                const result = await handlers.build(functionID, "start");
+                if (!result)
+                    return;
+                if (result.type === "error")
+                    return;
+                artifacts.set(functionID, result);
+                return artifacts.get(functionID);
+            }
+            finally {
+                unlock();
+            }
         },
     };
     const watcher = useWatcher();
@@ -149,3 +156,30 @@ export const useFunctionBuilder = lazy(() => {
     });
     return result;
 });
+class Semaphore {
+    queue = [];
+    locked = 0;
+    maxLocks;
+    constructor(maxLocks = 1) {
+        this.maxLocks = maxLocks;
+    }
+    lock() {
+        return new Promise((resolve) => {
+            const unlock = () => {
+                this.locked--;
+                const next = this.queue.shift();
+                if (next) {
+                    this.locked++;
+                    next(unlock);
+                }
+            };
+            if (this.locked < this.maxLocks) {
+                this.locked++;
+                resolve(unlock);
+            }
+            else {
+                this.queue.push(unlock);
+            }
+        });
+    }
+}

package/stacks/build.js

@@ -14,7 +14,13 @@ export async function load(input, shallow) {
     const root = await findAbove(input, "package.json");
     if (!root)
         throw new VisibleError("Could not find a package.json file");
-    const outfile = path.join(parsed.dir, `.${parsed.name}.${Date.now()}.mjs`);
+    // Create the output file in the current working directory. This is because
+    // the sst cli command might not always run from where `sst.config.ts` is. When
+    // running from another workspace (ie. running `sst bind` in frontend workspace),
+    // the "sst" package imported from within the output file might resolve to a
+    // different "sst" package than the one resolved by the sst cli command. This
+    // will cause issues like "Project not initialized".
+    const outfile = path.join(process.cwd(), `.${parsed.name}.${Date.now()}.mjs`);
     const pkg = JSON.parse(await fs.readFile(path.join(root, "package.json")).then((x) => x.toString()));
     try {
         // Logger.debug("running esbuild on", input);

package/stacks/synth.js

@@ -11,62 +11,75 @@ export async function synth(opts) {
     const cxapi = await import("@aws-cdk/cx-api");
     const { Configuration } = await import("sst-aws-cdk/lib/settings.js");
     const project = useProject();
-    const identity = await useSTSIdentity();
-    opts = {
-        ...opts,
-        buildDir: opts.buildDir || path.join(project.paths.out, "dist"),
-    };
-    await fs.rm(opts.buildDir, { recursive: true, force: true });
-    await fs.mkdir(opts.buildDir, { recursive: true });
-    /*
-    console.log(JSON.stringify(cfg.context));
-    const executable = new CloudExecutable({
-      sdkProvider: await useAWSProvider(),
-      configuration: cfg,
-      synthesizer: async () => app.synth() as any
-    });
-    const { assembly } = await executable.synthesize(true);
-    */
-    const cfg = new Configuration();
-    await cfg.load();
-    let previous = new Set();
-    while (true) {
-        const app = new App({
-            account: identity.Account,
-            stage: project.config.stage,
-            name: project.config.name,
-            region: project.config.region,
-            mode: opts.mode,
-            debugIncreaseTimeout: opts.increaseTimeout,
-            debugScriptVersion: opts.scriptVersion,
-            isActiveStack: opts.isActiveStack,
-        }, {
-            outdir: opts.buildDir,
-            context: {
-                ...cfg.context.all,
-                [cxapi.PATH_METADATA_ENABLE_CONTEXT]: project.config.cdk?.pathMetadata ?? false,
-            },
-        });
-        await opts.fn(app);
-        await app.finish();
-        const assembly = app.synth();
-        Logger.debug(assembly.manifest.missing);
-        const { missing } = assembly.manifest;
-        const provider = await useAWSProvider();
-        if (missing && missing.length) {
-            const next = missing.map((x) => x.key);
-            if (next.length === previous.size && next.every((x) => previous.has(x)))
-                throw new VisibleError(formatErrorMessage(next.join("")));
-            Logger.debug("Looking up context for:", next, "Previous:", previous);
-            previous = new Set(next);
-            await contextproviders.provideContextValues(missing, cfg.context, provider);
-            if (cfg.context.keys.length) {
-                await cfg.saveContext();
+    const cwd = process.cwd();
+    process.chdir(project.paths.root);
+    try {
+        return await synthInRoot();
+    }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        process.chdir(cwd);
+    }
+    async function synthInRoot() {
+        const identity = await useSTSIdentity();
+        opts = {
+            ...opts,
+            buildDir: opts.buildDir || path.join(project.paths.out, "dist"),
+        };
+        await fs.rm(opts.buildDir, { recursive: true, force: true });
+        await fs.mkdir(opts.buildDir, { recursive: true });
+        /*
+      console.log(JSON.stringify(cfg.context));
+      const executable = new CloudExecutable({
+        sdkProvider: await useAWSProvider(),
+        configuration: cfg,
+        synthesizer: async () => app.synth() as any
+      });
+      const { assembly } = await executable.synthesize(true);
+      */
+        const cfg = new Configuration();
+        await cfg.load();
+        let previous = new Set();
+        while (true) {
+            const app = new App({
+                account: identity.Account,
+                stage: project.config.stage,
+                name: project.config.name,
+                region: project.config.region,
+                mode: opts.mode,
+                debugIncreaseTimeout: opts.increaseTimeout,
+                debugScriptVersion: opts.scriptVersion,
+                isActiveStack: opts.isActiveStack,
+            }, {
+                outdir: opts.buildDir,
+                context: {
+                    ...cfg.context.all,
+                    [cxapi.PATH_METADATA_ENABLE_CONTEXT]: project.config.cdk?.pathMetadata ?? false,
+                },
+            });
+            await opts.fn(app);
+            await app.finish();
+            const assembly = app.synth();
+            Logger.debug(assembly.manifest.missing);
+            const { missing } = assembly.manifest;
+            const provider = await useAWSProvider();
+            if (missing && missing.length) {
+                const next = missing.map((x) => x.key);
+                if (next.length === previous.size && next.every((x) => previous.has(x)))
+                    throw new VisibleError(formatErrorMessage(next.join("")));
+                Logger.debug("Looking up context for:", next, "Previous:", previous);
+                previous = new Set(next);
+                await contextproviders.provideContextValues(missing, cfg.context, provider);
+                if (cfg.context.keys.length) {
+                    await cfg.saveContext();
+                }
+                continue;
             }
-            continue;
+            Logger.debug("Finished synthesizing");
+            return assembly;
         }
-        Logger.debug("Finished synthesizing");
-        return assembly;
     }
 }
 function formatErrorMessage(message) {