sst 2.22.10 → 2.23.0

package/sst.mjs

@@ -161,13 +161,6 @@ 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) {
@@ -1328,7 +1321,8 @@ var init_monitor = __esm({
       "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
       "UPDATE_IN_PROGRESS",
       "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
-      "UPDATE_ROLLBACK_IN_PROGRESS"
+      "UPDATE_ROLLBACK_IN_PROGRESS",
+      "PUBLISH_ASSETS_IN_PROGRESS"
     ];
     STATUSES_SUCCESS = [
       "CREATE_COMPLETE",
@@ -3494,6 +3488,10 @@ async function deploy(stack) {
   }));
   try {
     await addInUseExports(stack);
+    bus.publish("stack.status", {
+      stackID: stack.stackName,
+      status: "PUBLISH_ASSETS_IN_PROGRESS"
+    });
     const result = await deployment.deployStack({
       stack,
       quiet: true,
@@ -3723,6 +3721,7 @@ var init_cache = __esm({
 var metadata_exports = {};
 __export(metadata_exports, {
   metadata: () => metadata2,
+  metadataForStack: () => metadataForStack,
   useMetadata: () => useMetadata
 });
 import {
@@ -3730,6 +3729,25 @@ import {
   GetObjectCommand as GetObjectCommand2,
   ListObjectsV2Command
 } from "@aws-sdk/client-s3";
+async function metadataForStack(stack) {
+  const project = useProject();
+  const [credentials, bootstrap2] = await Promise.all([
+    useAWSCredentials(),
+    useBootstrap()
+  ]);
+  const s3 = new S3Client2({
+    region: project.config.region,
+    credentials
+  });
+  const result = await s3.send(
+    new GetObjectCommand2({
+      Key: `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stack}.json`,
+      Bucket: bootstrap2.bucket
+    })
+  );
+  const body = await result.Body.transformToString();
+  return JSON.parse(body);
+}
 async function metadata2() {
   Logger.debug("Fetching all metadata");
   const project = useProject();
@@ -4702,6 +4720,9 @@ var init_node = __esm({
             if (input.mode === "start") {
               rebuildCache[input.functionID] = { ctx, result };
             }
+            if (input.mode === "deploy") {
+              ctx.dispose();
+            }
             logMemoryUsage(input.functionID, input.props.handler);
             return {
               type: "success",
@@ -5795,6 +5816,7 @@ __export(stacks_exports, {
   load: () => load,
   loadAssembly: () => loadAssembly,
   metadata: () => metadata2,
+  metadataForStack: () => metadataForStack,
   monitor: () => monitor,
   publishAssets: () => publishAssets4,
   remove: () => remove,
@@ -5945,7 +5967,10 @@ async function bootstrapSST() {
   for (const [key, value] of Object.entries(bootstrap2?.tags || {})) {
     Tags.of(app).add(key, value);
   }
-  const bucket = new Bucket(stack, region, {
+  const bucket = bootstrap2?.useExistingBucket ? {
+    bucketName: bootstrap2.useExistingBucket,
+    bucketArn: `arn:${stack.partition}:s3:::${bootstrap2.useExistingBucket}`
+  } : new Bucket(stack, region, {
     encryption: BucketEncryption.S3_MANAGED,
     removalPolicy: RemovalPolicy.DESTROY,
     autoDeleteObjects: true,
@@ -6811,10 +6836,32 @@ var init_deploy2 = __esm({
     init_colors();
     init_project();
     DeploymentUI = (props) => {
+      const [statuses, setStatuses] = useState({});
       const [resources, setResources] = useState({});
       useEffect(() => {
         Colors.gap();
         const bus = useBus();
+        const status = bus.subscribe("stack.status", (payload) => {
+          const { stackID, status: status2 } = payload.properties;
+          setStatuses((previous2) => {
+            if (status2 !== "PUBLISH_ASSETS_IN_PROGRESS") {
+              if (previous2[stackID]) {
+                Colors.line(
+                  Colors.warning(Colors.prefix),
+                  Colors.dim(stackNameToId(stackID)),
+                  Colors.dim("PUBLISH_ASSETS_COMPLETE"),
+                  ""
+                );
+              }
+              const { [stackID]: _, ...next } = previous2;
+              return next;
+            }
+            return {
+              ...previous2,
+              [stackID]: status2
+            };
+          });
+        });
         const event = bus.subscribe("stack.event", (payload) => {
           const { event: event2 } = payload.properties;
           setResources((previous2) => {
@@ -6845,6 +6892,7 @@ var init_deploy2 = __esm({
         });
         return () => {
           bus.unsubscribe(event);
+          bus.unsubscribe(status);
         };
       }, []);
       function color(status) {
@@ -6854,14 +6902,19 @@ var init_deploy2 = __esm({
           return "green";
         return "yellow";
       }
-      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, Object.entries(resources).slice(0, process.stdout.rows - 2).map(([_, evt], index) => {
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, Object.entries(statuses).slice(0, process.stdout.rows - 2).map(([stack, status], index) => {
+        return /* @__PURE__ */ React.createElement(Box, { key: index }, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Spinner, null), "  ", stackNameToId(stack), " "), /* @__PURE__ */ React.createElement(Text, { color: color(status) }, status));
+      }), Object.entries(resources).slice(
+        0,
+        Math.max(0, process.stdout.rows - Object.entries(statuses).length - 2)
+      ).map(([_, evt], index) => {
         const readable = logicalIdToCdkPath(
           props.assembly,
           evt.StackName,
           evt.LogicalResourceId
         );
         return /* @__PURE__ */ React.createElement(Box, { key: index }, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Spinner, null), "  ", readable ? `${stackNameToId(evt.StackName)} ${readable} ${evt.ResourceType}` : `${stackNameToId(evt.StackName)} ${evt.ResourceType}`, " "), /* @__PURE__ */ React.createElement(Text, { color: color(evt.ResourceStatus || "") }, evt.ResourceStatus));
-      }), Object.entries(resources).length === 0 && /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Spinner, null), "  ", /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.remove ? "Removing..." : "Deploying..."))));
+      }), Object.entries(resources).length === 0 && Object.entries(statuses).length === 0 && /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Spinner, null), "  ", /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.remove ? "Removing..." : "Deploying..."))));
     };
   }
 });
@@ -7926,10 +7979,7 @@ var MetadataOutdatedError = class extends Error {
 var bind = (program2) => program2.command(
   ["bind <command..>", "env <command..>"],
   "Bind your app's resources to a command",
-  (yargs2) => yargs2.option("site", {
-    type: "boolean",
-    describe: "Run in site mode"
-  }).option("script", {
+  (yargs2) => yargs2.option("script", {
     type: "boolean",
     describe: "Run in script mode"
   }).array("command").example(`sst bind vitest run`, "Bind resources to your tests").example(`sst bind next dev`, "Bind resources to your site").example(
@@ -7937,13 +7987,30 @@ var bind = (program2) => program2.command(
     "Bind resources to your site before deployment"
   ),
   async (args) => {
+    const { Token } = await import("aws-cdk-lib");
     const { spawn: spawn8 } = await import("child_process");
     const kill = await import("tree-kill");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
+    const { Stacks } = await Promise.resolve().then(() => (init_stacks(), stacks_exports));
     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));
     const { Logger: Logger3 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const [
+      { useServices },
+      { useSites: useSsrSites },
+      { useSites: useStaticSites },
+      { useSites: useSlsNextjsSites },
+      { Parameter },
+      { getEnvironmentKey }
+    ] = await Promise.all([
+      import("../src/constructs/Service.js"),
+      import("../src/constructs/SsrSite.js"),
+      import("../src/constructs/StaticSite.js"),
+      import("../src/constructs/deprecated/NextjsSite.js"),
+      import("../src/constructs/Config.js"),
+      import("../src/constructs/util/functionBinding.js")
+    ]);
     if (args._[0] === "env") {
       Colors2.line(
         Colors2.warning(
@@ -7953,102 +8020,95 @@ var bind = (program2) => program2.command(
         )
       );
     }
+    const command = args.command?.join(" ");
+    if (!command) {
+      throw new VisibleError(
+        "Command is required, e.g. sst bind npm run script"
+      );
+    }
     await useIOT2();
     const bus = useBus2();
     const project = useProject2();
-    const command = args.command?.join(" ");
-    const isSite = await isRunningInSite();
-    const mode = args.site ? "site" : args.script ? "script" : "auto";
     let p;
     let timer;
     let siteConfigCache;
-    if (!command) {
-      throw new VisibleError(
-        `Command is required, e.g. sst bind ${isSite ? "next dev" : "vitest run"}`
-      );
+    await buildApp();
+    const ssrSite = isInSsrSite();
+    const staticSite = isInStaticSite();
+    const service = isInService();
+    if (args.script || !ssrSite && !staticSite && !service) {
+      return await runScript();
     }
-    if (args.script || !isSite && !args.site) {
-      Logger3.debug("Running in script mode.");
-      return await bindScript();
+    try {
+      await runSite("init");
+    } catch (e) {
+      if (!(e instanceof MetadataOutdatedError) && !(e instanceof MetadataNotFoundError)) {
+        return;
+      }
+      Colors2.line(
+        Colors2.warning(
+          e instanceof MetadataOutdatedError ? "Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update." : "Warning: The site has not been deployed. Some resources might not be available."
+        )
+      );
+      return await runSiteUndeployed();
     }
-    await bindSite("init");
     bus.subscribe(
       "stacks.metadata.updated",
-      () => bindSite("metadata_updated")
+      () => runSite("metadata_updated")
     );
     bus.subscribe(
       "stacks.metadata.deleted",
-      () => bindSite("metadata_updated")
+      () => runSite("metadata_updated")
     );
     bus.subscribe("config.secret.updated", (payload) => {
       const secretName = payload.properties.name;
-      if (!(siteConfigCache?.secrets || []).includes(secretName))
+      if (!siteConfigCache.secrets.includes(secretName))
         return;
       Colors2.line(
         `
 `,
         `SST secrets have been updated. Restarting \`${command}\`...`
       );
-      bindSite("secrets_updated");
+      runSite("secrets_updated");
     });
-    async function isRunningInSite() {
-      const { existsAsync: existsAsync3 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-      const { readFile } = await import("fs/promises");
-      const SITE_CONFIGS = [
-        { file: "next.config", multiExtension: true },
-        { file: "astro.config", multiExtension: true },
-        { file: "remix.config", multiExtension: true },
-        { file: "svelte.config", multiExtension: true },
-        { file: "gatsby-config", multiExtension: true },
-        { file: "angular.json" },
-        { file: "ember-cli-build.js" },
-        {
-          file: "vite.config",
-          multiExtension: true,
-          match: /solid-start|plugin-vue|plugin-react|@preact\/preset-vite/
-        },
-        { file: "package.json", match: /react-scripts/ },
-        // CRA
-        { file: "index.html" }
-        // plain HTML
-      ];
-      const results = await Promise.all(
-        SITE_CONFIGS.map((site) => {
-          const files = site.multiExtension ? [".js", ".cjs", ".mjs", ".ts"].map(
-            (ext) => `${site.file}${ext}`
-          ) : [site.file];
-          return files.map(async (file) => {
-            const exists = await existsAsync3(file);
-            if (!exists)
-              return false;
-            if (site.match) {
-              const content = await readFile(file);
-              return content.toString().match(site.match);
-            }
-            return true;
-          });
-        }).flat()
+    async function buildApp() {
+      const [_metafile, sstConfig] = await Stacks.load(
+        project.paths.config
       );
-      return results.some(Boolean);
+      const cwd = process.cwd();
+      process.chdir(project.paths.root);
+      await Stacks.synth({
+        fn: sstConfig.stacks,
+        mode: "remove"
+      });
+      process.chdir(cwd);
     }
-    async function bindSite(reason) {
-      let siteMetadata;
-      try {
-        siteMetadata = await getSiteMetadata();
-      } catch (e) {
-        if (!(e instanceof MetadataOutdatedError) && !(e instanceof MetadataNotFoundError)) {
-          throw e;
-        }
-        if (reason !== "init")
-          return;
-        Colors2.line(
-          Colors2.warning(
-            e instanceof MetadataOutdatedError ? "Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update." : "Warning: The site has not been deployed. Some resources might not be available."
-          )
-        );
-        return await bindScript();
-      }
-      const siteConfig = await parseSiteMetadata(siteMetadata);
+    function isInSsrSite() {
+      const cwd = process.cwd();
+      return useSsrSites().all.find(({ props }) => {
+        console.log(path20.resolve(project.paths.root, props.path));
+        return path20.resolve(project.paths.root, props.path) === cwd;
+      });
+    }
+    function isInStaticSite() {
+      const cwd = process.cwd();
+      return useStaticSites().all.find(({ props }) => {
+        console.log(path20.resolve(project.paths.root, props.path));
+        return path20.resolve(project.paths.root, props.path) === cwd;
+      }) || useSlsNextjsSites().all.find(({ props }) => {
+        console.log(path20.resolve(project.paths.root, props.path));
+        return path20.resolve(project.paths.root, props.path) === cwd;
+      });
+    }
+    function isInService() {
+      const cwd = process.cwd();
+      return useServices().all.find(({ props }) => {
+        console.log(path20.resolve(project.paths.root, props.path));
+        return path20.resolve(project.paths.root, props.path) === cwd;
+      });
+    }
+    async function runSite(reason) {
+      const siteConfig = ssrSite ? await getSsrSiteMetadata() : staticSite ? await getStaticSiteMetadata() : await getServiceMetadata();
       if (reason === "metadata_updated") {
         if (areEnvsSame(siteConfig.envs, siteConfigCache?.envs || {}))
           return;
@@ -8065,49 +8125,125 @@ var bind = (program2) => program2.command(
         ...credentials
       });
     }
-    async function bindScript() {
+    async function runSiteUndeployed() {
+      const constructEnvs = {};
+      Object.entries(
+        (ssrSite || staticSite || service)?.props.environment || {}
+      ).filter(([key, value]) => !Token.isUnresolved(value)).forEach(([key, value]) => constructEnvs[key] = value);
+      ((ssrSite || service)?.props.bind || []).forEach((b) => {
+        if (b instanceof Parameter && !Token.isUnresolved(b.value)) {
+          constructEnvs[getEnvironmentKey(b, "name")] = b.value;
+        }
+      });
+      const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      await runCommand({
+        ...constructEnvs,
+        ...await Config2.env(),
+        ...await getLocalIamCredentials()
+      });
+    }
+    async function runScript() {
       const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       await runCommand({
         ...await Config2.env(),
         ...await getLocalIamCredentials()
       });
     }
-    async function getSiteMetadata() {
-      const { metadata: metadata3 } = await Promise.resolve().then(() => (init_metadata(), metadata_exports));
-      const metadataData = await metadata3();
-      const data2 = Object.values(metadataData).flat().filter(
+    async function getSsrSiteMetadata() {
+      const [
+        { metadataForStack: metadataForStack2 },
+        { LambdaClient: LambdaClient2, GetFunctionCommand },
+        { useAWSClient: useAWSClient2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_metadata(), metadata_exports)),
+        import("@aws-sdk/client-lambda"),
+        Promise.resolve().then(() => (init_credentials(), credentials_exports))
+      ]);
+      const metadataData = await metadataForStack2(ssrSite.stack);
+      const metadata3 = metadataData.filter(
         (c) => [
-          "StaticSite",
           "NextjsSite",
           "AstroSite",
           "RemixSite",
           "SolidStartSite",
-          "SvelteKitSite",
-          "SlsNextjsSite"
+          "SvelteKitSite"
         ].includes(c.type)
       ).find((c) => {
-        const isSsr = c.type !== "StaticSite" && c.type !== "SlsNextjsSite";
-        if (!c.data.path || isSsr && !c.data.server || !isSsr && !c.data.environment) {
+        if (!c.data.path || !c.data.server) {
           throw new MetadataOutdatedError();
         }
         return path20.resolve(project.paths.root, c.data.path) === process.cwd();
       });
-      if (!data2) {
+      if (!metadata3)
         throw new MetadataNotFoundError();
-      }
-      return data2;
+      const lambda = useAWSClient2(LambdaClient2);
+      const { Configuration: functionConfig } = await lambda.send(
+        new GetFunctionCommand({
+          FunctionName: metadata3.data.server
+        })
+      );
+      return {
+        role: functionConfig?.Role,
+        envs: functionConfig?.Environment?.Variables || {},
+        secrets: metadata3.data.secrets
+      };
     }
-    async function parseSiteMetadata(metadata3) {
-      const { LambdaClient: LambdaClient2, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
-      const { useAWSClient: useAWSClient2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
-      const isBindSupported = metadata3.type !== "StaticSite" && metadata3.type !== "SlsNextjsSite";
-      if (!isBindSupported) {
-        return { envs: metadata3.data.environment };
+    async function getStaticSiteMetadata() {
+      const { metadataForStack: metadataForStack2 } = await Promise.resolve().then(() => (init_metadata(), metadata_exports));
+      const metadataData = await metadataForStack2(staticSite.stack);
+      const metadata3 = metadataData.filter(
+        (c) => ["StaticSite", "SlsNextjsSite"].includes(c.type)
+      ).find((c) => {
+        if (!c.data.path || !c.data.environment) {
+          throw new MetadataOutdatedError();
+        }
+        return path20.resolve(project.paths.root, c.data.path) === process.cwd();
+      });
+      if (!metadata3)
+        throw new MetadataNotFoundError();
+      return {
+        envs: metadata3.data.environment,
+        role: void 0,
+        secrets: []
+      };
+    }
+    async function getServiceMetadata() {
+      const [
+        { metadataForStack: metadataForStack2 },
+        { LambdaClient: LambdaClient2, GetFunctionCommand },
+        { ECSClient, DescribeTaskDefinitionCommand },
+        { useAWSClient: useAWSClient2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_metadata(), metadata_exports)),
+        import("@aws-sdk/client-lambda"),
+        import("@aws-sdk/client-ecs"),
+        Promise.resolve().then(() => (init_credentials(), credentials_exports))
+      ]);
+      const metadataData = await metadataForStack2(service.stack);
+      const metadata3 = metadataData.filter((c) => ["Service"].includes(c.type)).find((c) => {
+        return path20.resolve(project.paths.root, c.data.path) === process.cwd();
+      });
+      if (!metadata3)
+        throw new MetadataNotFoundError();
+      if (metadata3.data.mode === "deployed") {
+        const ecs = useAWSClient2(ECSClient);
+        const task = await ecs.send(
+          new DescribeTaskDefinitionCommand({
+            taskDefinition: metadata3.data.task
+          })
+        );
+        const envs = {};
+        (task?.taskDefinition?.containerDefinitions[0].environment || []).forEach(({ name, value }) => envs[name] = value);
+        return {
+          role: task?.taskDefinition?.taskRoleArn,
+          envs,
+          secrets: metadata3.data.secrets
+        };
       }
       const lambda = useAWSClient2(LambdaClient2);
       const { Configuration: functionConfig } = await lambda.send(
         new GetFunctionCommand({
-          FunctionName: metadata3.data.server
+          FunctionName: metadata3.data.devFunction
         })
       );
       return {
@@ -8128,7 +8264,7 @@ var bind = (program2) => program2.command(
 `,
           `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`
         );
-        bindSite("iam_expired");
+        runSite("iam_expired");
       }, expireAt - Date.now());
       return {
         AWS_ACCESS_KEY_ID: credentials.AccessKeyId,

package/stacks/deploy.js

@@ -84,6 +84,10 @@ export async function deploy(stack) {
     }));
     try {
         await addInUseExports(stack);
+        bus.publish("stack.status", {
+            stackID: stack.stackName,
+            status: "PUBLISH_ASSETS_IN_PROGRESS",
+        });
         const result = await deployment.deployStack({
             stack: stack,
             quiet: true,

package/stacks/metadata.d.ts

@@ -6,5 +6,6 @@ declare module "../bus.js" {
         "stacks.metadata.deleted": {};
     }
 }
+export declare function metadataForStack(stack: String): Promise<Metadata[]>;
 export declare function metadata(): Promise<Record<string, Metadata[]>>;
 export declare const useMetadata: () => Promise<Record<string, Metadata[]>>;

package/stacks/metadata.js

@@ -6,6 +6,23 @@ import { Context } from "../context/context.js";
 import { useBus } from "../bus.js";
 import { Logger } from "../logger.js";
 import { useProject } from "../project.js";
+export async function metadataForStack(stack) {
+    const project = useProject();
+    const [credentials, bootstrap] = await Promise.all([
+        useAWSCredentials(),
+        useBootstrap(),
+    ]);
+    const s3 = new S3Client({
+        region: project.config.region,
+        credentials: credentials,
+    });
+    const result = await s3.send(new GetObjectCommand({
+        Key: `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stack}.json`,
+        Bucket: bootstrap.bucket,
+    }));
+    const body = await result.Body.transformToString();
+    return JSON.parse(body);
+}
 export async function metadata() {
     Logger.debug("Fetching all metadata");
     const project = useProject();

package/stacks/monitor.d.ts

@@ -18,7 +18,7 @@ declare module "../bus.js" {
         };
     }
 }
-export declare const STATUSES: readonly ["CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "REVIEW_IN_PROGRESS", "ROLLBACK_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_IN_PROGRESS", "CREATE_COMPLETE", "UPDATE_COMPLETE", "DELETE_COMPLETE", "SKIPPED", "CREATE_FAILED", "DELETE_FAILED", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "DEPENDENCY_FAILED"];
+export declare const STATUSES: readonly ["CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "REVIEW_IN_PROGRESS", "ROLLBACK_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_IN_PROGRESS", "PUBLISH_ASSETS_IN_PROGRESS", "CREATE_COMPLETE", "UPDATE_COMPLETE", "DELETE_COMPLETE", "SKIPPED", "CREATE_FAILED", "DELETE_FAILED", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "DEPENDENCY_FAILED"];
 export declare function isFinal(input: string): boolean;
 export declare function isFailed(input: string): boolean;
 export declare function isSuccess(input: string): boolean;

package/stacks/monitor.js

@@ -11,6 +11,7 @@ const STATUSES_PENDING = [
     "UPDATE_IN_PROGRESS",
     "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
     "UPDATE_ROLLBACK_IN_PROGRESS",
+    "PUBLISH_ASSETS_IN_PROGRESS",
 ];
 const STATUSES_SUCCESS = [
     "CREATE_COMPLETE",

package/support/nixpacks/Dockerfile

@@ -0,0 +1,6 @@
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y curl
+RUN curl -LO https://github.com/railwayapp/nixpacks/releases/download/v1.11.0/nixpacks-v1.11.0-amd64.deb
+RUN dpkg -i nixpacks-v1.11.0-amd64.deb
+
+ENTRYPOINT ["nixpacks"]

package/support/service-dev-function/index.js

@@ -0,0 +1 @@
+export async function handler() {}