sst 2.2.8 → 2.3.1

package/sst.mjs

@@ -177,6 +177,13 @@ var init_module = __esm({
 });
 
 // src/util/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  existsAsync: () => existsAsync,
+  findAbove: () => findAbove,
+  findBelow: () => findBelow,
+  isChild: () => isChild
+});
 import fs2 from "fs/promises";
 import path2 from "path";
 async function findAbove(dir, target) {
@@ -1980,6 +1987,7 @@ async function monitor(stack) {
           errors: {}
         };
       }
+      throw ex;
     }
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
@@ -3258,13 +3266,13 @@ async function listImports(exportName) {
   }
 }
 async function getLocalTemplate(stack) {
-  const fs19 = await import("fs/promises");
-  const fileContent = await fs19.readFile(stack.templateFullPath);
+  const fs18 = await import("fs/promises");
+  const fileContent = await fs18.readFile(stack.templateFullPath);
   return fileContent.toString();
 }
 async function saveLocalTemplate(stack, content) {
-  const fs19 = await import("fs/promises");
-  await fs19.writeFile(stack.templateFullPath, content);
+  const fs18 = await import("fs/promises");
+  await fs18.writeFile(stack.templateFullPath, content);
 }
 var init_deploy = __esm({
   "src/stacks/deploy.ts"() {
@@ -3373,7 +3381,6 @@ var init_cache = __esm({
 var metadata_exports = {};
 __export(metadata_exports, {
   metadata: () => metadata2,
-  metadataForStack: () => metadataForStack,
   useMetadata: () => useMetadata
 });
 import {
@@ -3417,32 +3424,6 @@ async function metadata2() {
   Logger.debug("Fetched metadata from", list2.KeyCount, "stacks");
   return result;
 }
-async function metadataForStack(stackID) {
-  const [project, credentials, bootstrap2] = await Promise.all([
-    useProject(),
-    useAWSCredentialsProvider(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client2({
-    region: project.config.region,
-    credentials
-  });
-  const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stackID}.json`;
-  Logger.debug("Getting metadata", key, "from", bootstrap2.bucket);
-  try {
-    const result = await s3.send(
-      new GetObjectCommand2({
-        Key: key,
-        Bucket: bootstrap2.bucket
-      })
-    );
-    const body = await result.Body.transformToString();
-    return JSON.parse(body);
-  } catch (ex) {
-    console.error(ex);
-    return [];
-  }
-}
 var MetadataContext2, useMetadata;
 var init_metadata = __esm({
   "src/stacks/metadata.ts"() {
@@ -5080,7 +5061,6 @@ __export(stacks_exports, {
   load: () => load,
   loadAssembly: () => loadAssembly,
   metadata: () => metadata2,
-  metadataForStack: () => metadataForStack,
   monitor: () => monitor,
   publishAssets: () => publishAssets4,
   remove: () => remove,
@@ -5384,65 +5364,6 @@ var init_bootstrap = __esm({
   }
 });
 
-// src/site-env.ts
-var site_env_exports = {};
-__export(site_env_exports, {
-  SiteEnv: () => site_env_exports,
-  append: () => append,
-  keys: () => keys,
-  reset: () => reset2,
-  values: () => values,
-  valuesFile: () => valuesFile,
-  writeValues: () => writeValues
-});
-import fs13 from "fs";
-import path16 from "path";
-function keysFile() {
-  return path16.join(useProject().paths.out, "site-environment-keys.jsonl");
-}
-function valuesFile() {
-  return path16.join(useProject().paths.out, "site-environment-values.json");
-}
-async function keys() {
-  try {
-    const file = keysFile();
-    const data2 = await fs13.promises.readFile(file).then((x) => x.toString().split("\n"));
-    return data2.filter(Boolean).map((x) => JSON.parse(x));
-  } catch {
-    return [];
-  }
-}
-async function values() {
-  try {
-    const file = valuesFile();
-    const data2 = await fs13.promises.readFile(file).then((x) => JSON.parse(x.toString()));
-    return data2;
-  } catch {
-    return {};
-  }
-}
-async function writeValues(input) {
-  const file = valuesFile();
-  await fs13.promises.writeFile(file, JSON.stringify(input));
-}
-function append(input) {
-  input.path = path16.resolve(useProject().paths.root, input.path);
-  fs13.appendFileSync(keysFile(), JSON.stringify(input) + "\n");
-}
-function reset2() {
-  fs13.rmSync(keysFile(), {
-    force: true,
-    recursive: true
-  });
-}
-var init_site_env = __esm({
-  "src/site-env.ts"() {
-    "use strict";
-    init_site_env();
-    init_project();
-  }
-});
-
 // src/cli/local/router.ts
 import * as trpc from "@trpc/server";
 var router2;
@@ -5497,7 +5418,7 @@ __export(server_exports2, {
 });
 import { produceWithPatches, enablePatches } from "immer";
 import express2 from "express";
-import fs14 from "fs/promises";
+import fs13 from "fs/promises";
 import { WebSocketServer } from "ws";
 import https3 from "https";
 import http from "http";
@@ -5578,15 +5499,15 @@ async function useLocalServer(opts) {
     const CERT_PATH = ".sst/localhost.pem";
     if (result2.status === 0) {
       try {
-        await Promise.all([fs14.access(KEY_PATH), fs14.access(CERT_PATH)]);
+        await Promise.all([fs13.access(KEY_PATH), fs13.access(CERT_PATH)]);
       } catch (e) {
         sync("mkcert", ["localhost"], {
           cwd: ".sst"
         });
       }
       const [key, cert] = await Promise.all([
-        fs14.readFile(KEY_PATH),
-        fs14.readFile(CERT_PATH)
+        fs13.readFile(KEY_PATH),
+        fs13.readFile(CERT_PATH)
       ]);
       return https3.createServer(
         {
@@ -5995,15 +5916,10 @@ function printDeploymentResults(assembly, results, remove4) {
       Colors.bold(remove4 ? ` Removed:` : ` Deployed:`)
     );
     for (const [stack, result] of success) {
-      const outputs = Object.entries(result.outputs).filter(
-        ([key, _]) => !key.includes("SstSiteEnv")
-      );
       Colors.line(`   ${Colors.dim(stackNameToId(stack))}`);
-      if (outputs.length > 0) {
-        for (const key of Object.keys(Object.fromEntries(outputs)).sort()) {
-          const value = result.outputs[key];
-          Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
-        }
+      for (const key of Object.keys(result.outputs).sort()) {
+        const value = result.outputs[key];
+        Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
       }
     }
     Colors.gap();
@@ -6142,16 +6058,16 @@ __export(pothos_exports, {
 import babel from "@babel/core";
 import generator from "@babel/generator";
 import esbuild3 from "esbuild";
-import fs15 from "fs/promises";
-import path17 from "path";
+import fs14 from "fs/promises";
+import path16 from "path";
 import url9 from "url";
 async function generate(opts) {
   const { printSchema, lexicographicSortSchema } = await import("graphql");
   const contents = await extractSchema(opts);
-  const out = path17.join(path17.dirname(opts.schema), "out.mjs");
-  await fs15.writeFile(out, contents, "utf8");
+  const out = path16.join(path16.dirname(opts.schema), "out.mjs");
+  await fs14.writeFile(out, contents, "utf8");
   const { schema } = await import(url9.pathToFileURL(out).href + "?bust=" + Date.now());
-  await fs15.rm(out);
+  await fs14.rm(out);
   const schemaAsString = printSchema(lexicographicSortSchema(schema));
   return schemaAsString;
 }
@@ -6299,10 +6215,10 @@ var pothos_exports2 = {};
 __export(pothos_exports2, {
   usePothosBuilder: () => usePothosBuilder
 });
-import fs16 from "fs/promises";
+import fs15 from "fs/promises";
 import { exec as exec6 } from "child_process";
 import { promisify as promisify4 } from "util";
-import path18 from "path";
+import path17 from "path";
 var execAsync4, usePothosBuilder;
 var init_pothos2 = __esm({
   "src/cli/commands/plugins/pothos.ts"() {
@@ -6320,7 +6236,7 @@ var init_pothos2 = __esm({
           const schema = await pothos_exports.generate({
             schema: route.schema
           });
-          await fs16.writeFile(route.output, schema);
+          await fs15.writeFile(route.output, schema);
           if (Array.isArray(route.commands) && route.commands.length > 0) {
             await Promise.all(route.commands.map((cmd) => execAsync4(cmd)));
           }
@@ -6336,9 +6252,9 @@ var init_pothos2 = __esm({
         if (evt.properties.file.endsWith("out.mjs"))
           return;
         for (const route of routes) {
-          const dir = path18.dirname(route.schema);
-          const relative = path18.relative(dir, evt.properties.file);
-          if (relative && !relative.startsWith("..") && !path18.isAbsolute(relative))
+          const dir = path17.dirname(route.schema);
+          const relative = path17.relative(dir, evt.properties.file);
+          if (relative && !relative.startsWith("..") && !path17.isAbsolute(relative))
             build2(route);
         }
       });
@@ -6364,7 +6280,7 @@ __export(kysely_exports, {
 import { Kysely } from "kysely";
 import { DataApiDialect } from "kysely-data-api";
 import { RDSData } from "@aws-sdk/client-rds-data";
-import * as fs17 from "fs/promises";
+import * as fs16 from "fs/promises";
 import {
   DatabaseMetadata,
   EnumCollection,
@@ -6436,7 +6352,7 @@ var init_kysely = __esm({
         };
         const serializer = new Serializer();
         const data2 = serializer.serialize(nodes);
-        await fs17.writeFile(db.types.path, data2);
+        await fs16.writeFile(db.types.path, data2);
       }
       bus.subscribe("stacks.metadata", (evt) => {
         const constructs = Object.values(evt.properties).flat();
@@ -6573,12 +6489,39 @@ function parse(ssmName) {
     prop: parts.slice(6).join("/")
   };
 }
+async function restartFunction(arn) {
+  const lambda = useAWSClient(LambdaClient);
+  try {
+    const config = await lambda.send(
+      new GetFunctionConfigurationCommand({
+        FunctionName: arn
+      })
+    );
+    await lambda.send(
+      new UpdateFunctionConfigurationCommand({
+        FunctionName: arn,
+        Environment: {
+          Variables: {
+            ...config.Environment?.Variables || {},
+            [SECRET_UPDATED_AT_ENV]: Date.now().toString()
+          }
+        }
+      })
+    );
+    return true;
+  } catch (e) {
+    if (e.name === "ResourceNotFoundException" && e.message.startsWith("Function not found")) {
+      return;
+    }
+  }
+}
 var Config, FALLBACK_STAGE, SECRET_UPDATED_AT_ENV, PREFIX;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_project();
     init_credentials();
+    init_iot();
     init_stacks();
     ((Config2) => {
       async function parameters() {
@@ -6633,10 +6576,10 @@ var init_config = __esm({
         return result;
       }
       Config2.secrets = secrets2;
-      async function env2() {
+      async function env() {
         const project = useProject();
         const parameters2 = await Config2.parameters();
-        const env3 = {
+        const env2 = {
           SST_APP: project.config.name,
           SST_STAGE: project.config.stage,
           ...pipe2(
@@ -6645,12 +6588,12 @@ var init_config = __esm({
             Object.fromEntries
           )
         };
-        return env3;
+        return env2;
       }
-      Config2.env = env2;
+      Config2.env = env;
       async function setSecret(input) {
         const ssm = useAWSClient(SSMClient);
-        const result = await ssm.send(
+        await ssm.send(
           new PutParameterCommand({
             Name: pathFor({
               id: input.key,
@@ -6663,6 +6606,9 @@ var init_config = __esm({
             Overwrite: true
           })
         );
+        const iot2 = await useIOT();
+        const topic = `${iot2.prefix}/events`;
+        await iot2.publish(topic, "config.secret.updated", { name: input.key });
       }
       Config2.setSecret = setSecret;
       async function getSecret(input) {
@@ -6696,37 +6642,35 @@ var init_config = __esm({
       }
       Config2.removeSecret = removeSecret;
       async function restart(key) {
-        const lambda = useAWSClient(LambdaClient);
         const metadata3 = await stacks_exports.metadata();
-        const filtered = Object.values(metadata3).flat().filter((f) => f.type === "Function").filter((f) => f.data.secrets.includes(key));
-        const restarted = await Promise.all(
-          filtered.map(async (f) => {
-            try {
-              const config = await lambda.send(
-                new GetFunctionConfigurationCommand({
-                  FunctionName: f.data.arn
-                })
-              );
-              await lambda.send(
-                new UpdateFunctionConfigurationCommand({
-                  FunctionName: f.data.arn,
-                  Environment: {
-                    Variables: {
-                      ...config.Environment?.Variables || {},
-                      [SECRET_UPDATED_AT_ENV]: Date.now().toString()
-                    }
-                  }
-                })
-              );
-              return true;
-            } catch (e) {
-              if (e.name === "ResourceNotFoundException" && e.message.startsWith("Function not found")) {
-                return;
-              }
-            }
-          })
+        const siteData = Object.values(metadata3).flat().filter(
+          (c) => c.type === "AstroSite" || c.type === "NextjsSite" || c.type === "RemixSite" || c.type === "SolidStartSite"
+        ).filter((c) => c.data.secrets.includes(key));
+        const siteDataPlaceholder = siteData.filter(
+          (c) => c.data.mode === "placeholder"
         );
-        return restarted.filter(Boolean).length;
+        const siteDataEdge = siteData.filter((c) => c.data.mode === "deployed").filter((c) => c.data.edge);
+        const siteDataRegional = siteData.filter((c) => c.data.mode === "deployed").filter((c) => !c.data.edge);
+        const regionalSiteArns = siteData.map((s) => s.data.server);
+        const functionData = Object.values(metadata3).flat().filter((c) => c.type === "Function").filter((c) => !regionalSiteArns.includes(c.data.arn)).filter((c) => c.data.secrets.includes(key));
+        const restartedSites = (await Promise.all(
+          siteDataRegional.map(async (s) => {
+            const restarted = await restartFunction(s.data.server);
+            return restarted ? s : restarted;
+          })
+        )).filter((c) => Boolean(c));
+        const restartedFunctions = (await Promise.all(
+          functionData.map(async (f) => {
+            const restarted = await restartFunction(f.data.arn);
+            return restarted ? f : restarted;
+          })
+        )).filter((c) => Boolean(c));
+        return {
+          edgeSites: siteDataEdge,
+          sites: restartedSites,
+          placeholderSites: siteDataPlaceholder,
+          functions: restartedFunctions
+        };
       }
       Config2.restart = restart;
     })(Config || (Config = {}));
@@ -6802,63 +6746,6 @@ var bootstrap = (program2) => program2.command(
   }
 );
 
-// src/cli/commands/env.ts
-init_error();
-var env = (program2) => program2.command(
-  "env <command..>",
-  "Load environment variables and start your frontend",
-  (yargs2) => yargs2.array("command").example(
-    `sst env "next dev"`,
-    "Start Next.js with your environment variables"
-  ).example(
-    `sst env "vite dev"`,
-    "Start Vite with your environment variables"
-  ),
-  async (args) => {
-    const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
-    const fs19 = await import("fs/promises");
-    const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
-    const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
-    const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
-    let spinner;
-    while (true) {
-      const exists = await fs19.access(SiteEnv.valuesFile()).then(() => true).catch(() => false);
-      if (!exists) {
-        spinner = createSpinner2(
-          "Cannot find SST environment variables. Waiting for SST to start..."
-        ).start();
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        continue;
-      }
-      spinner?.succeed();
-      const sites = await SiteEnv.values();
-      const env2 = sites[process.cwd()] || {};
-      const project = useProject2();
-      const credentials = await useAWSCredentials3();
-      const joined = args.command?.join(" ");
-      if (!joined)
-        throw new VisibleError(
-          "Command is required, e.g. sst env vite dev"
-        );
-      const result = spawnSync(joined, {
-        env: {
-          ...process.env,
-          ...env2,
-          AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-          AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-          AWS_SESSION_TOKEN: credentials.sessionToken,
-          AWS_REGION: project.config.region
-        },
-        stdio: "inherit",
-        shell: true
-      });
-      process.exitCode = result.status || void 0;
-      break;
-    }
-  }
-).strict(false);
-
 // src/cli/commands/dev.tsx
 var dev = (program2) => program2.command(
   ["dev", "start"],
@@ -6870,7 +6757,7 @@ var dev = (program2) => program2.command(
   async (args) => {
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     const { printHeader: printHeader2 } = await Promise.resolve().then(() => (init_header(), header_exports));
-    const { mapValues, omitBy: omitBy2, pipe: pipe3 } = await import("remeda");
+    const { mapValues } = await import("remeda");
     const path20 = await import("path");
     const { useRuntimeWorkers: useRuntimeWorkers2 } = await Promise.resolve().then(() => (init_workers(), workers_exports));
     const { useIOTBridge: useIOTBridge2 } = await Promise.resolve().then(() => (init_iot2(), iot_exports2));
@@ -6886,10 +6773,9 @@ var dev = (program2) => program2.command(
     const { Context: Context2 } = await Promise.resolve().then(() => (init_context(), context_exports));
     const { printDeploymentResults: printDeploymentResults2, DeploymentUI: DeploymentUI2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
     const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
-    const fs19 = await import("fs/promises");
+    const fs18 = await import("fs/promises");
     const crypto2 = await import("crypto");
     const { useFunctions: useFunctions3 } = await import("../src/constructs/Function.js");
-    const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
     const { usePothosBuilder: usePothosBuilder2 } = await Promise.resolve().then(() => (init_pothos2(), pothos_exports2));
     const { useKyselyTypeGenerator: useKyselyTypeGenerator2 } = await Promise.resolve().then(() => (init_kysely(), kysely_exports));
     const { useRDSWarmer: useRDSWarmer2 } = await Promise.resolve().then(() => (init_warmer(), warmer_exports));
@@ -7061,27 +6947,10 @@ var dev = (program2) => program2.command(
           await saveAppMetadata2({ mode: "dev" });
         }
         lastDeployed = nextChecksum;
-        const keys2 = await SiteEnv.keys();
-        const result = {};
-        for (const key of keys2) {
-          const stack = results[key.stack];
-          const value = stack.outputs[key.output];
-          let existing = result[key.path];
-          if (!existing) {
-            result[key.path] = existing;
-            existing = result[key.path] = {};
-          }
-          existing[key.environment] = value;
-        }
-        await SiteEnv.writeValues(result);
-        fs19.writeFile(
+        fs18.writeFile(
           path20.join(project.paths.out, "outputs.json"),
           JSON.stringify(
-            pipe3(
-              results,
-              omitBy2((_, key) => key.includes("SstSiteEnv")),
-              mapValues((val) => val.outputs)
-            ),
+            mapValues(results, (val) => val.outputs),
             null,
             2
           )
@@ -7093,7 +6962,7 @@ var dev = (program2) => program2.command(
       async function checksum(cdkOutPath) {
         const manifestPath = path20.join(cdkOutPath, "manifest.json");
         const cdkManifest = JSON.parse(
-          await fs19.readFile(manifestPath).then((x) => x.toString())
+          await fs18.readFile(manifestPath).then((x) => x.toString())
         );
         const checksumData = await Promise.all(
           Object.keys(cdkManifest.artifacts).filter(
@@ -7101,7 +6970,7 @@ var dev = (program2) => program2.command(
           ).map(async (key) => {
             const { templateFile } = cdkManifest.artifacts[key].properties;
             const templatePath = path20.join(cdkOutPath, templateFile);
-            const templateContent = await fs19.readFile(templatePath);
+            const templateContent = await fs18.readFile(templatePath);
             return templateContent;
           })
         ).then((x) => x.join("\n"));
@@ -7192,37 +7061,231 @@ Are you sure you want to run this stage in dev mode? [y/N] `,
 
 // src/cli/commands/bind.ts
 init_error();
+import path18 from "path";
+var SITE_CONFIG = {
+  NextjsSite: "next.config",
+  AstroSite: "astro.config",
+  RemixSite: "remix.config",
+  SolidStartSite: "vite.config",
+  StaticSite: "vite.config",
+  SlsNextjsSite: "next.config"
+};
 var bind = (program2) => program2.command(
-  "bind <command..>",
+  ["bind <command..>", "env <command..>"],
   "Bind your app's resources to a command",
   (yargs2) => yargs2.array("command").example(`sst bind "vitest run"`, "Bind your resources to your tests").example(
     `sst bind "tsx scripts/myscript.ts"`,
     "Bind your resources to a script"
   ),
   async (args) => {
-    const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { spawn: spawn7 } = await import("child_process");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
-    const env2 = await Config2.env();
+    const { useBus: useBus2 } = await Promise.resolve().then(() => (init_bus(), bus_exports));
+    const { useIOT: useIOT2 } = await Promise.resolve().then(() => (init_iot(), iot_exports));
+    const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+    if (args._[0] === "env") {
+      Colors2.line(
+        Colors2.warning(
+          `Warning: ${Colors2.bold(
+            `sst env`
+          )} has been renamed to ${Colors2.bold(`sst bind`)}`
+        )
+      );
+    }
+    await useIOT2();
+    const bus = useBus2();
     const project = useProject2();
-    const credentials = await useAWSCredentials3();
-    const joined = args.command?.join(" ");
-    if (!joined)
-      throw new VisibleError("Command is required, e.g. sst bind env");
-    const result = spawnSync(joined, {
-      env: {
-        ...process.env,
-        ...env2,
+    const command = args.command?.join(" ");
+    const isFrontend = await isRunningInFrontend();
+    let p;
+    let timer;
+    let metadataCache;
+    if (!command) {
+      throw new VisibleError(
+        `Command is required, e.g. sst bind ${isFrontend ? "next dev" : "env"}`
+      );
+    }
+    const initialMetadata = await getSiteMetadata();
+    if (!initialMetadata) {
+      return await bindScript();
+    }
+    await bindSite("init");
+    bus.subscribe(
+      "stacks.metadata.updated",
+      () => bindSite("metadata_updated")
+    );
+    bus.subscribe(
+      "stacks.metadata.deleted",
+      () => bindSite("metadata_updated")
+    );
+    bus.subscribe("config.secret.updated", (payload) => {
+      const secretName = payload.properties.name;
+      if (metadataCache?.secrets === void 0)
+        return;
+      if (!metadataCache.secrets.includes(secretName))
+        return;
+      Colors2.line(
+        `
+`,
+        `SST secrets have been updated. Restarting \`${command}\`...`
+      );
+      bindSite("secrets_updated");
+    });
+    async function isRunningInFrontend() {
+      const { existsAsync: existsAsync3 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+      const results = await Promise.all(
+        Object.values(SITE_CONFIG).map(
+          (config) => [".js", ".cjs", ".mjs", ".ts"].map(
+            (ext) => existsAsync3(`${config}${ext}`)
+          )
+        ).flat()
+      );
+      return results.some(Boolean);
+    }
+    async function bindSite(reason) {
+      const metadata3 = reason === "init" ? initialMetadata : await getSiteMetadata();
+      if (reason === "metadata_updated") {
+        if (areEnvsSame(metadata3.envs, metadataCache?.envs || {}))
+          return;
+        Colors2.line(
+          `
+`,
+          `SST resources have been updated. Restarting \`${command}\`...`
+        );
+      }
+      metadataCache = metadata3;
+      if (metadata3.role) {
+        const credentials = await assumeSsrRole(metadata3.role);
+        if (credentials) {
+          const expireAt = credentials.Expiration.getTime() - 6e4;
+          clearTimeout(timer);
+          timer = setTimeout(() => {
+            Colors2.line(
+              `
+`,
+              `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`
+            );
+            bindSite("iam_expired");
+          }, expireAt - Date.now());
+          runCommand({
+            ...metadata3.envs,
+            AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
+            AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
+            AWS_SESSION_TOKEN: credentials.SessionToken
+          });
+          return;
+        }
+      }
+      runCommand({
+        ...metadata3.envs,
+        ...await localIamCredentials()
+      });
+    }
+    async function bindScript() {
+      const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      runCommand({
+        ...await Config2.env(),
+        ...await localIamCredentials()
+      });
+    }
+    async function getSiteMetadata() {
+      const { metadata: metadata3 } = await Promise.resolve().then(() => (init_metadata(), metadata_exports));
+      const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
+      const { LambdaClient: LambdaClient2, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
+      const { useAWSClient: useAWSClient2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const spinner = createSpinner2({});
+      while (true) {
+        const metadataData = await metadata3();
+        const data2 = Object.values(metadataData).flat().filter(
+          (c) => Boolean(c)
+        ).filter((c) => Boolean(SITE_CONFIG[c.type])).find(
+          (c) => path18.resolve(project.paths.root, c.data.path) === process.cwd()
+        );
+        if (!data2 && !isFrontend) {
+          return;
+        }
+        if (!data2) {
+          spinner.start(
+            "Make sure `sst dev` is running..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        const isBindSupported = data2.type !== "StaticSite" && data2.type !== "SlsNextjsSite";
+        if (isBindSupported && !data2.data.server || !isBindSupported && !data2.data.environment) {
+          spinner.start(
+            "This was deployed with an old version of SST. Make sure to restart `sst dev`..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        spinner.isSpinning && spinner.stop().clear();
+        if (!isBindSupported) {
+          return { envs: data2.data.environment };
+        }
+        const lambda = useAWSClient2(LambdaClient2);
+        const { Configuration: functionConfig } = await lambda.send(
+          new GetFunctionCommand({
+            FunctionName: data2.data.server
+          })
+        );
+        return {
+          role: functionConfig?.Role,
+          envs: functionConfig?.Environment?.Variables || {},
+          secrets: data2.data.secrets
+        };
+      }
+    }
+    async function assumeSsrRole(roleArn) {
+      const { STSClient: STSClient2, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
+      const { Logger: Logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+      const { useAWSClient: useAWSClient2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const sts = useAWSClient2(STSClient2);
+      try {
+        const { Credentials: credentials } = await sts.send(
+          new AssumeRoleCommand({
+            RoleArn: roleArn,
+            RoleSessionName: "dev-session",
+            DurationSeconds: 43200
+          })
+        );
+        return credentials;
+      } catch (e) {
+        Colors2.line(
+          Colors2.warning(
+            `Failed to assume SSR role ${roleArn}. Falling back to using local IAM credentials.`
+          )
+        );
+        Logger2.debug(`Failed to assume ${roleArn}.`, e);
+      }
+    }
+    async function localIamCredentials() {
+      const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const credentials = await useAWSCredentials3();
+      return {
         AWS_ACCESS_KEY_ID: credentials.accessKeyId,
         AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-        AWS_SESSION_TOKEN: credentials.sessionToken,
-        AWS_REGION: project.config.region
-      },
-      stdio: "inherit",
-      shell: true
-    });
-    process.exitCode = result.status || void 0;
+        AWS_SESSION_TOKEN: credentials.sessionToken
+      };
+    }
+    function runCommand(envs) {
+      Colors2.gap();
+      if (p) {
+        p.kill();
+      }
+      p = spawn7(command, {
+        env: {
+          ...process.env,
+          ...envs,
+          AWS_REGION: project.config.region
+        },
+        stdio: "inherit",
+        shell: true
+      });
+    }
+    function areEnvsSame(envs1, envs2) {
+      return Object.keys(envs1).length === Object.keys(envs2).length && Object.keys(envs1).every((key) => envs1[key] === envs2[key]);
+    }
   }
 ).strict(false);
 
@@ -7257,7 +7320,7 @@ var build = (program2) => program2.command(
 // src/cli/commands/deploy.tsx
 init_credentials();
 init_colors();
-import fs18 from "fs/promises";
+import fs17 from "fs/promises";
 import path19 from "path";
 var deploy2 = (program2) => program2.command(
   "deploy [filter]",
@@ -7346,7 +7409,7 @@ Are you sure you want to deploy to this stage? (y/N) `,
     printDeploymentResults2(assembly, results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
       process.exit(1);
-    fs18.writeFile(
+    fs17.writeFile(
       path19.join(project.paths.out, "outputs.json"),
       JSON.stringify(
         mapValues(results, (val) => val.outputs),
@@ -7494,14 +7557,14 @@ var list = (program2) => program2.command(
         }
         break;
       case "table":
-        const keys2 = Object.keys(secrets2);
+        const keys = Object.keys(secrets2);
         const keyLen = Math.max(
           "Secrets".length,
-          ...keys2.map((key) => key.length)
+          ...keys.map((key) => key.length)
         );
         const valueLen = Math.max(
           "Values".length,
-          ...keys2.map(
+          ...keys.map(
             (key) => secrets2[key].value ? secrets2[key].value.length : `${secrets2[key].fallback} (fallback)`.length
           )
         );
@@ -7514,7 +7577,7 @@ var list = (program2) => program2.command(
         console.log(
           "\u251C".padEnd(keyLen + 3, "\u2500") + "\u253C" + "".padEnd(valueLen + 2, "\u2500") + "\u2524"
         );
-        keys2.sort().forEach((key) => {
+        keys.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`
@@ -7573,6 +7636,7 @@ var set = (program2) => program2.command(
   }),
   async (args) => {
     const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     const { blue: blue4 } = await import("colorette");
     const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
     const setting = createSpinner2(` Setting "${args.name}"`).start();
@@ -7583,12 +7647,31 @@ var set = (program2) => program2.command(
     });
     setting.succeed();
     const restarting = createSpinner2(
-      ` Restarting all functions using ${blue4(args.name)}...`
+      ` Reloading all resources using ${blue4(args.name)}...`
     ).start();
-    const count = await Config2.restart(args.name);
-    restarting.succeed(
-      count === 1 ? ` Restarted ${count} function` : ` Restarted ${count} functions`
-    );
+    const { edgeSites, sites, placeholderSites, functions } = await Config2.restart(args.name);
+    restarting.stop().clear();
+    const siteCount = sites.length + placeholderSites.length;
+    if (siteCount > 0) {
+      Colors2.line(
+        Colors2.success(`\u2714 `),
+        siteCount === 1 ? `Reloaded ${siteCount} site` : `Reloaded ${siteCount} sites`
+      );
+    }
+    const functionCount = functions.length;
+    if (functionCount > 0) {
+      Colors2.line(
+        Colors2.success(`\u2714 `),
+        functionCount === 1 ? `Reloaded ${functionCount} function` : `Reloaded ${functionCount} functions`
+      );
+    }
+    edgeSites.forEach(({ id, type }) => {
+      Colors2.line(
+        Colors2.danger(`\u279C `),
+        `Redeploy the "${id}" ${type} to use the new secret`
+      );
+    });
+    process.exit(0);
   }
 );
 
@@ -7616,13 +7699,13 @@ var update = (program2) => program2.command(
   }),
   async (args) => {
     const { green, yellow } = await import("colorette");
-    const fs19 = await import("fs/promises");
+    const fs18 = await import("fs/promises");
     const path20 = await import("path");
     const { fetch } = await import("undici");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     async function find2(dir) {
-      const children = await fs19.readdir(dir);
+      const children = await fs18.readdir(dir);
       const tasks2 = children.map(async (item) => {
         if (item === "node_modules")
           return [];
@@ -7631,7 +7714,7 @@ var update = (program2) => program2.command(
         const full = path20.join(dir, item);
         if (item === "package.json")
           return [full];
-        const stat = await fs19.stat(full);
+        const stat = await fs18.stat(full);
         if (stat.isDirectory())
           return find2(full);
         return [];
@@ -7645,7 +7728,7 @@ var update = (program2) => program2.command(
     ).then((resp) => resp.json());
     const results = /* @__PURE__ */ new Map();
     const tasks = files.map(async (file) => {
-      const data2 = await fs19.readFile(file).then((x) => x.toString()).then(JSON.parse);
+      const data2 = await fs18.readFile(file).then((x) => x.toString()).then(JSON.parse);
       for (const field of FIELDS) {
         const deps = data2[field];
         if (!deps)
@@ -7674,7 +7757,7 @@ var update = (program2) => program2.command(
         }
       }
       if (results.has(file)) {
-        await fs19.writeFile(file, JSON.stringify(data2, null, 2));
+        await fs18.writeFile(file, JSON.stringify(data2, null, 2));
       }
     });
     await Promise.all(tasks);
@@ -7907,7 +7990,6 @@ dev(program);
 deploy2(program);
 build(program);
 bind(program);
-env(program);
 secrets(program);
 remove2(program);
 update(program);