sst 2.0.0-rc.37 → 2.0.0-rc.39

package/bootstrap.js

@@ -68,7 +68,9 @@ export async function initBootstrap() {
                 }),
                 new PolicyStatement({
                     actions: ["iot:Publish"],
-                    resources: [`arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`],
+                    resources: [
+                        `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`,
+                    ],
                 }),
             ],
         });

package/cdk/cloudformation-deployments-wrapper.d.ts

@@ -1,2 +1,3 @@
-import { CloudFormationDeployments, DeployStackOptions } from "./cloudformation-deployments.js";
-export declare function publishAssets(deployment: CloudFormationDeployments, options: DeployStackOptions): Promise<void>;
+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

@@ -1,7 +1,14 @@
+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 publishAssets(deployment, options) {
-    const toolkitInfo = await useToolkitInfo().lookup(deployment, options);
+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: {
@@ -9,17 +16,97 @@ export async function publishAssets(deployment, options) {
             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 useToolkitInfo = Context.memo(() => {
+const useDeployment = Context.memo(() => {
     const state = new Map();
     return {
-        async lookup(deployment, options) {
-            if (state.has(deployment))
-                return state.get(deployment);
-            const { stackSdk, resolvedEnvironment } = await deployment.prepareSdkFor(options.stack, options.roleArn);
-            const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
-            state.set(deployment, toolkitInfo);
-            return toolkitInfo;
+        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

@@ -290,6 +290,6 @@ export declare class CloudFormationDeployments {
     /**
      * 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,5 +1,6 @@
 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";
@@ -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 {

package/cli/commands/secrets/secrets.js

@@ -1,11 +1,14 @@
+import { get } from "./get.js";
+import { list } from "./list.js";
+import { remove } from "./remove.js";
 import { set } from "./set.js";
 export function secrets(program) {
     program.command("secrets", "Manage the secrets in your app", (yargs) => {
         yargs.demandCommand(1);
         set(yargs);
-        // get(yargs);
-        // list(yargs);
-        // remove(yargs);
+        get(yargs);
+        list(yargs);
+        remove(yargs);
         return yargs;
     });
 }

package/cli/program.js

@@ -22,7 +22,7 @@ export const program = yargs(hideBin(process.argv))
     type: "string",
     describe: "ARN of the IAM role to use when invoking AWS",
 })
-    .group(["stage", "profile", "region", "help"], "Global:")
+    .group(["stage", "profile", "region", "help", "verbose", "role"], "Global:")
     .middleware(async (argv) => {
     if (argv.verbose) {
         process.env.SST_VERBOSE = "1";

package/iot.js

@@ -37,6 +37,10 @@ export const useIOT = Context.memo(async () => {
     });
     device.on("message", (_topic, buffer) => {
         const fragment = JSON.parse(buffer.toString());
+        if (!fragment.id) {
+            bus.publish(fragment.type, fragment.properties);
+            return;
+        }
         let pending = fragments.get(fragment.id);
         if (!pending) {
             pending = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.0-rc.37",
+  "version": "2.0.0-rc.39",
   "bin": {
     "sst": "cli/sst.js"
   },

package/sst.mjs

@@ -2120,11 +2120,26 @@ var init_cloudformation_deployments = __esm({
 // src/cdk/cloudformation-deployments-wrapper.ts
 var cloudformation_deployments_wrapper_exports = {};
 __export(cloudformation_deployments_wrapper_exports, {
-  publishAssets: () => publishAssets3
+  publishDeployAssets: () => publishDeployAssets
 });
+import { debug as debug3 } from "aws-cdk/lib/logging.js";
+import {
+  CloudFormationStack as CloudFormationStack3,
+  TemplateParameters as TemplateParameters2,
+  waitForStackDelete as waitForStackDelete2
+} from "aws-cdk/lib/api/util/cloudformation.js";
 import { ToolkitInfo as ToolkitInfo2 } from "aws-cdk/lib/api/toolkit-info.js";
-async function publishAssets3(deployment, options) {
-  const toolkitInfo = await useToolkitInfo().lookup(deployment, options);
+import { addMetadataAssetsToManifest as addMetadataAssetsToManifest2 } from "aws-cdk/lib/assets.js";
+import { publishAssets as publishAssets3 } from "aws-cdk/lib/util/asset-publishing.js";
+import { AssetManifestBuilder as AssetManifestBuilder2 } from "aws-cdk/lib/util/asset-manifest-builder.js";
+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: {
@@ -2132,26 +2147,130 @@ async function publishAssets3(deployment, options) {
       parallel: options.assetParallelism
     }
   });
+  return deployStack2({
+    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
+  });
 }
-var useToolkitInfo;
+async function deployStack2(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 CloudFormationStack3.lookup(cfn, deployName);
+  if (cloudFormationStack.stackStatus.isCreationFailure) {
+    debug3(
+      `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 waitForStackDelete2(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})`
+      );
+    }
+    cloudFormationStack = CloudFormationStack3.doesNotExist(cfn, deployName);
+  }
+  const legacyAssets = new AssetManifestBuilder2();
+  const assetParams = await addMetadataAssetsToManifest2(
+    stackArtifact,
+    legacyAssets,
+    options.toolkitInfo,
+    options.reuseAssets
+  );
+  const finalParameterValues = { ...options.parameters, ...assetParams };
+  const templateParams = TemplateParameters2.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 publishAssets3(
+    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
+    }
+  };
+}
+var useDeployment;
 var init_cloudformation_deployments_wrapper = __esm({
   "src/cdk/cloudformation-deployments-wrapper.ts"() {
     "use strict";
+    init_cloudformation_deployments();
+    init_deploy_stack();
     init_context();
-    useToolkitInfo = Context.memo(() => {
+    useDeployment = Context.memo(() => {
       const state2 = /* @__PURE__ */ new Map();
       return {
-        async lookup(deployment, options) {
-          if (state2.has(deployment))
-            return state2.get(deployment);
-          const { stackSdk, resolvedEnvironment } = await deployment.prepareSdkFor(options.stack, options.roleArn);
-          const toolkitInfo = await ToolkitInfo2.lookup(
-            resolvedEnvironment,
-            stackSdk,
-            options.toolkitStackName
-          );
-          state2.set(deployment, toolkitInfo);
-          return toolkitInfo;
+        async get(sdkProvider, options) {
+          if (!state2.has(sdkProvider)) {
+            const deployment = new CloudFormationDeployments({ sdkProvider });
+            const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn);
+            const toolkitInfo = await ToolkitInfo2.lookup(
+              resolvedEnvironment,
+              stackSdk,
+              options.toolkitStackName
+            );
+            await deployment.validateBootstrapStackVersion(
+              options.stack.stackName,
+              options.stack.requiresBootstrapStackVersion,
+              options.stack.bootstrapStackVersionSsmParameter,
+              toolkitInfo
+            );
+            state2.set(sdkProvider, {
+              deployment,
+              toolkitInfo,
+              stackSdk,
+              resolvedEnvironment,
+              cloudFormationRoleArn
+            });
+          }
+          return state2.get(sdkProvider);
         }
       };
     });
@@ -2162,23 +2281,22 @@ var init_cloudformation_deployments_wrapper = __esm({
 async function publishAssets4(stacks) {
   Logger.debug("Publishing assets");
   const provider = await useAWSProvider();
-  const { CloudFormationDeployments: CloudFormationDeployments2 } = await Promise.resolve().then(() => (init_cloudformation_deployments(), cloudformation_deployments_exports));
-  const { publishAssets: publishAssets5 } = await Promise.resolve().then(() => (init_cloudformation_deployments_wrapper(), cloudformation_deployments_wrapper_exports));
-  const deployment = new CloudFormationDeployments2({
-    sdkProvider: provider
-  });
+  const { publishDeployAssets: publishDeployAssets2 } = await Promise.resolve().then(() => (init_cloudformation_deployments_wrapper(), cloudformation_deployments_wrapper_exports));
+  const results = {};
   for (const stack of stacks) {
-    await publishAssets5(
-      deployment,
+    const result = await publishDeployAssets2(
+      provider,
       {
         stack,
-        quiet: true,
+        quiet: false,
         deploymentMethod: {
           method: "direct"
         }
       }
     );
+    results[stack.stackName] = result;
   }
+  return results;
 }
 async function deployMany(stacks) {
   Logger.debug(
@@ -2352,7 +2470,7 @@ async function metadata() {
     credentials
   });
   const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/`;
-  const list = await s3.send(
+  const list2 = await s3.send(
     new ListObjectsV2Command({
       Prefix: key,
       Bucket: bootstrap.bucket
@@ -2360,7 +2478,7 @@ async function metadata() {
   );
   const result = Object.fromEntries(
     await Promise.all(
-      list.Contents?.map(async (obj) => {
+      list2.Contents?.map(async (obj) => {
         const stackID = obj.Key?.split("/").pop();
         const result2 = await s3.send(
           new GetObjectCommand({
@@ -2372,7 +2490,7 @@ async function metadata() {
       }) || []
     )
   );
-  Logger.debug("Fetched metadata from", list.KeyCount, "stacks");
+  Logger.debug("Fetched metadata from", list2.KeyCount, "stacks");
   return result;
 }
 async function metadataForStack(stackID) {
@@ -2409,22 +2527,23 @@ var init_metadata = __esm({
     init_cache();
     init_context();
     init_bus();
-    init_stacks();
     init_logger();
     init_project();
     MetadataContext = Context.create(async () => {
       const bus = useBus();
       const cache = await useCache();
       const data2 = await metadata();
-      bus.subscribe("stack.status", async (evt) => {
-        if (!stacks_exports.isSuccess(evt.properties.status))
-          return;
-        const meta = await metadataForStack(evt.properties.stackID);
-        Logger.debug("Got metadata", meta);
-        data2[evt.properties.stackID] = meta;
-        await cache.write(`metadata.json`, JSON.stringify(data2));
-        bus.publish("stacks.metadata", data2);
-        MetadataContext.provide(Promise.resolve(data2));
+      bus.subscribe("stacks.metadata.updated", async () => {
+        const data3 = await metadata();
+        await cache.write(`metadata.json`, JSON.stringify(data3));
+        bus.publish("stacks.metadata", data3);
+        MetadataContext.provide(Promise.resolve(data3));
+      });
+      bus.subscribe("stacks.metadata.deleted", async () => {
+        const data3 = await metadata();
+        await cache.write(`metadata.json`, JSON.stringify(data3));
+        bus.publish("stacks.metadata", data3);
+        MetadataContext.provide(Promise.resolve(data3));
       });
       return data2;
     });
@@ -3851,7 +3970,9 @@ async function initBootstrap() {
         }),
         new PolicyStatement({
           actions: ["iot:Publish"],
-          resources: [`arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`]
+          resources: [
+            `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`
+          ]
         })
       ]
     });
@@ -4484,6 +4605,10 @@ var init_iot = __esm({
       });
       device.on("message", (_topic, buffer) => {
         const fragment = JSON.parse(buffer.toString());
+        if (!fragment.id) {
+          bus.publish(fragment.type, fragment.properties);
+          return;
+        }
         let pending = fragments.get(fragment.id);
         if (!pending) {
           pending = /* @__PURE__ */ new Map();
@@ -5706,7 +5831,7 @@ var program = yargs(hideBin(process.argv)).scriptName("sst").option("stage", {
 }).option("role", {
   type: "string",
   describe: "ARN of the IAM role to use when invoking AWS"
-}).group(["stage", "profile", "region", "help"], "Global:").middleware(async (argv) => {
+}).group(["stage", "profile", "region", "help", "verbose", "role"], "Global:").middleware(async (argv) => {
   if (argv.verbose) {
     process.env.SST_VERBOSE = "1";
   }
@@ -6181,6 +6306,108 @@ var consoleCommand = async (program2) => program2.command(
   }
 );
 
+// src/cli/commands/secrets/get.ts
+var get = (program2) => program2.command(
+  "get <name>",
+  "Get the value of a secret",
+  (yargs2) => yargs2.positional("name", {
+    type: "string",
+    describe: "Name of the secret",
+    demandOption: true
+  }).option("fallback", {
+    type: "boolean",
+    describe: "Get the fallback value"
+  }),
+  async (args) => {
+    const { red: red3 } = await import("colorette");
+    const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { bold: bold2 } = await import("colorette");
+    try {
+      const result = await Config2.getSecret({
+        key: args.name,
+        fallback: args.fallback === true
+      });
+      console.log(bold2(result));
+    } catch {
+      console.log(red3(`${bold2(args.name)} is not set`));
+    }
+  }
+);
+
+// src/cli/commands/secrets/list.ts
+var list = (program2) => program2.command(
+  "list [format]",
+  "Fetch all the secrets",
+  (yargs2) => yargs2.positional("format", {
+    type: "string",
+    choices: ["table", "env"]
+  }),
+  async (args) => {
+    const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { gray } = await import("colorette");
+    const secrets2 = await Config2.secrets();
+    switch (args.format || "table") {
+      case "env":
+        for (const [key, value] of Object.entries(secrets2)) {
+          console.log(`${key}=${value.value || value.fallback}`);
+        }
+        break;
+      case "table":
+        const keys2 = Object.keys(secrets2);
+        const keyLen = Math.max(
+          "Secrets".length,
+          ...keys2.map((key) => key.length)
+        );
+        const valueLen = Math.max(
+          "Values".length,
+          ...keys2.map(
+            (key) => secrets2[key].value ? secrets2[key].value.length : `${secrets2[key].fallback} (fallback)`.length
+          )
+        );
+        console.log(
+          "\u250C".padEnd(keyLen + 3, "\u2500") + "\u252C" + "".padEnd(valueLen + 2, "\u2500") + "\u2510"
+        );
+        console.log(
+          `\u2502 ${"Secrets".padEnd(keyLen)} \u2502 ${"Values".padEnd(valueLen)} \u2502`
+        );
+        console.log(
+          "\u251C".padEnd(keyLen + 3, "\u2500") + "\u253C" + "".padEnd(valueLen + 2, "\u2500") + "\u2524"
+        );
+        keys2.sort().forEach((key) => {
+          const value = secrets2[key].value ? secrets2[key].value : `${secrets2[key].fallback} ${gray("(fallback)")}`;
+          console.log(
+            `\u2502 ${key.padEnd(keyLen)} \u2502 ${value.padEnd(valueLen)} \u2502`
+          );
+        });
+        console.log(
+          "\u2514".padEnd(keyLen + 3, "\u2500") + "\u2534" + "".padEnd(valueLen + 2, "\u2500") + "\u2518"
+        );
+        break;
+    }
+  }
+);
+
+// src/cli/commands/secrets/remove.ts
+var remove3 = (program2) => program2.command(
+  "remove <name>",
+  "Remove a secret",
+  (yargs2) => yargs2.positional("name", {
+    describe: "Name of the secret",
+    type: "string",
+    demandOption: true
+  }).option("fallback", {
+    type: "boolean",
+    describe: "Remove the fallback value"
+  }),
+  async (args) => {
+    const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    await Config2.removeSecret({
+      key: args.name,
+      fallback: args.fallback === true
+    });
+  }
+);
+
 // src/cli/commands/secrets/set.ts
 var set = (program2) => program2.command(
   "set <name> <value>",
@@ -6223,6 +6450,9 @@ function secrets(program2) {
   program2.command("secrets", "Manage the secrets in your app", (yargs2) => {
     yargs2.demandCommand(1);
     set(yargs2);
+    get(yargs2);
+    list(yargs2);
+    remove3(yargs2);
     return yargs2;
   });
 }

package/stacks/deploy.d.ts

@@ -1,6 +1,6 @@
 import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
 import { StackDeploymentResult } from "./monitor.js";
-export declare function publishAssets(stacks: CloudFormationStackArtifact[]): Promise<void>;
+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

@@ -3,23 +3,21 @@ import { useAWSProvider } from "../credentials.js";
 import { Logger } from "../logger.js";
 import { isFailed, monitor } from "./monitor.js";
 export async function publishAssets(stacks) {
-    // TODO: use memo in cloudformation-deployments.ts
     Logger.debug("Publishing assets");
     const provider = await useAWSProvider();
-    const { CloudFormationDeployments } = await import("../cdk/cloudformation-deployments.js");
-    const { publishAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
-    const deployment = new CloudFormationDeployments({
-        sdkProvider: provider,
-    });
+    const { publishDeployAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
+    const results = {};
     for (const stack of stacks) {
-        await publishAssets(deployment, {
+        const result = await publishDeployAssets(provider, {
             stack: stack,
-            quiet: true,
+            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));

package/stacks/metadata.js

@@ -5,7 +5,6 @@ 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 "../project.js";
 export async function metadata() {
@@ -67,12 +66,14 @@ 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.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));