sst 3.0.0 → 3.0.1-2

package/cli/commands/bind.js

@@ -1,360 +0,0 @@
-import path from "path";
-import { VisibleError } from "../../error.js";
-class MetadataNotFoundError extends Error {
-}
-class MetadataOutdatedError extends Error {
-}
-export const bind = (program) => program
-    .command(["bind <command..>", "env <command..>"], "Bind your app's resources to a command", (yargs) => yargs
-    .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(`sst bind --script next build`, "Bind resources to your site before deployment"), async (args) => {
-    const { Token } = await import("aws-cdk-lib");
-    const { spawn } = await import("child_process");
-    const kill = await import("tree-kill");
-    const { exit, exitWithError } = await import("../program.js");
-    const { useProject } = await import("../../project.js");
-    const { Stacks } = await import("../../stacks/index.js");
-    const { useBus } = await import("../../bus.js");
-    const { useIOT } = await import("../../iot.js");
-    const { Colors } = await import("../colors.js");
-    const { Logger } = await import("../../logger.js");
-    const [{ useServices }, { useSites: useSsrSites }, { useSites: useStaticSites }, { useSites: useSlsNextjsSites }, { Parameter }, { getEnvironmentKey },] = await Promise.all([
-        import("../../constructs/Service.js"),
-        import("../../constructs/SsrSite.js"),
-        import("../../constructs/StaticSite.js"),
-        import("../../constructs/deprecated/NextjsSite.js"),
-        import("../../constructs/Config.js"),
-        import("../../constructs/util/functionBinding.js"),
-    ]);
-    try {
-        // Handle deprecated "env" command
-        if (args._[0] === "env") {
-            Colors.line(Colors.warning(`Warning: ${Colors.bold(`sst env`)} has been renamed to ${Colors.bold(`sst bind`)}`));
-        }
-        // Handle missing command
-        const command = args.command?.join(" ");
-        if (!command) {
-            throw new VisibleError("Command is required, e.g. sst bind npm run script");
-        }
-        await useIOT();
-        const bus = useBus();
-        const project = useProject();
-        let p;
-        let timer;
-        let siteConfigCache;
-        await buildApp();
-        const ssrSite = isInSsrSite();
-        const staticSite = isInStaticSite();
-        const service = isInService();
-        // Run the script
-        if (args.script || (!ssrSite && !staticSite && !service)) {
-            return await runScript();
-        }
-        // Run the app
-        try {
-            await runSite("init");
-        }
-        catch (e) {
-            if (!(e instanceof MetadataOutdatedError) &&
-                !(e instanceof MetadataNotFoundError)) {
-                return;
-            }
-            Colors.line(Colors.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();
-        }
-        bus.subscribe("stacks.metadata.updated", () => runSite("metadata_updated"));
-        bus.subscribe("stacks.metadata.deleted", () => runSite("metadata_updated"));
-        bus.subscribe("config.secret.updated", (payload) => {
-            const secretName = payload.properties.name;
-            if (!siteConfigCache.secrets.includes(secretName))
-                return;
-            Colors.line(`\n`, `SST secrets have been updated. Restarting \`${command}\`...`);
-            runSite("secrets_updated");
-        });
-        async function buildApp() {
-            const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-            const cwd = process.cwd();
-            process.chdir(project.paths.root);
-            await Stacks.synth({
-                fn: sstConfig.stacks,
-                mode: "remove",
-            });
-            process.chdir(cwd);
-        }
-        function isInSsrSite() {
-            const cwd = process.cwd();
-            return useSsrSites().all.find(({ props }) => {
-                return path.resolve(project.paths.root, props.path) === cwd;
-            });
-        }
-        function isInStaticSite() {
-            const cwd = process.cwd();
-            return (useStaticSites().all.find(({ props }) => {
-                return path.resolve(project.paths.root, props.path) === cwd;
-            }) ||
-                useSlsNextjsSites().all.find(({ props }) => {
-                    return path.resolve(project.paths.root, props.path) === cwd;
-                }));
-        }
-        function isInService() {
-            const cwd = process.cwd();
-            return useServices().all.find(({ props }) => {
-                return path.resolve(project.paths.root, props.path) === cwd;
-            });
-        }
-        async function runSite(reason) {
-            const siteConfig = ssrSite
-                ? await getSsrSiteMetadata()
-                : staticSite
-                    ? await getStaticSiteMetadata()
-                    : await getServiceMetadata();
-            // Handle rebind due to metadata updated
-            if (reason === "metadata_updated") {
-                if (areEnvsSame(siteConfig.envs, siteConfigCache?.envs || {}))
-                    return;
-                Colors.line(`\n`, `SST resources have been updated. Restarting \`${command}\`...`);
-            }
-            siteConfigCache = siteConfig;
-            // Assume function's role credentials
-            // Fallback to use local IAM credentials
-            const credentials = (siteConfig.role &&
-                (await getLiveIamCredentials(siteConfig.role))) ||
-                (await getLocalIamCredentials());
-            await runCommand({
-                ...siteConfig.envs,
-                ...credentials,
-            });
-        }
-        async function runSiteUndeployed() {
-            // Note: when the site is undeployed:
-            // - bind all resources
-            // - bind resources that are constant (ie. Config.Parameter)
-            // - set environment variables that are constant
-            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 } = await import("../../config.js");
-            await runCommand({
-                ...constructEnvs,
-                ...(await Config.env()),
-                ...(await getLocalIamCredentials()),
-            });
-        }
-        async function runScript() {
-            const { Config } = await import("../../config.js");
-            await runCommand({
-                ...(await Config.env()),
-                ...(await getLocalIamCredentials()),
-            });
-        }
-        async function getSsrSiteMetadata() {
-            const [{ metadataForStack }, { LambdaClient, GetFunctionCommand }, { useAWSClient },] = await Promise.all([
-                import("../../stacks/metadata.js"),
-                import("@aws-sdk/client-lambda"),
-                import("../../credentials.js"),
-            ]);
-            const metadataData = await metadataForStack(ssrSite.stack);
-            const metadata = metadataData
-                ?.filter((c) => [
-                "NextjsSite",
-                "AstroSite",
-                "RemixSite",
-                "SolidStartSite",
-                "SvelteKitSite",
-            ].includes(c.type))
-                .find((c) => {
-                // metadata prior to SST v2.3.0 doesn't have path
-                if (!c.data.path || !c.data.server) {
-                    throw new MetadataOutdatedError();
-                }
-                return (path.resolve(project.paths.root, c.data.path) ===
-                    process.cwd());
-            });
-            if (!metadata)
-                throw new MetadataNotFoundError();
-            // Parse metadata
-            const lambda = useAWSClient(LambdaClient);
-            const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
-                FunctionName: metadata.data.server,
-            }));
-            return {
-                role: functionConfig?.Role,
-                envs: functionConfig?.Environment?.Variables || {},
-                secrets: metadata.data.secrets,
-            };
-        }
-        async function getStaticSiteMetadata() {
-            const { metadataForStack } = await import("../../stacks/metadata.js");
-            const metadataData = await metadataForStack(staticSite.stack);
-            const metadata = metadataData
-                ?.filter((c) => ["StaticSite", "SlsNextjsSite"].includes(c.type))
-                .find((c) => {
-                // metadata prior to SST v2.3.0 doesn't have path
-                if (!c.data.path || !c.data.environment) {
-                    throw new MetadataOutdatedError();
-                }
-                return (path.resolve(project.paths.root, c.data.path) ===
-                    process.cwd());
-            });
-            if (!metadata)
-                throw new MetadataNotFoundError();
-            return {
-                envs: metadata.data.environment,
-                role: undefined,
-                secrets: [],
-            };
-        }
-        async function getServiceMetadata() {
-            const [{ metadataForStack }, { LambdaClient, GetFunctionCommand }, { ECSClient, DescribeTaskDefinitionCommand }, { useAWSClient },] = await Promise.all([
-                import("../../stacks/metadata.js"),
-                import("@aws-sdk/client-lambda"),
-                import("@aws-sdk/client-ecs"),
-                import("../../credentials.js"),
-            ]);
-            // Get metadata
-            const metadataData = await metadataForStack(service.stack);
-            const metadata = metadataData
-                ?.filter((c) => ["Service"].includes(c.type))
-                .find((c) => {
-                return (path.resolve(project.paths.root, c.data.path) ===
-                    process.cwd());
-            });
-            if (!metadata)
-                throw new MetadataNotFoundError();
-            // Parse metadata for "sst deploy"
-            if (metadata.data.mode === "deployed") {
-                const ecs = useAWSClient(ECSClient);
-                const task = await ecs.send(new DescribeTaskDefinitionCommand({
-                    taskDefinition: metadata.data.task,
-                }));
-                const envs = {};
-                (task?.taskDefinition?.containerDefinitions[0].environment || []).forEach(({ name, value }) => (envs[name] = value));
-                return {
-                    role: task?.taskDefinition?.taskRoleArn,
-                    envs,
-                    secrets: metadata.data.secrets,
-                };
-            }
-            // Parse metadata for "sst dev"
-            const lambda = useAWSClient(LambdaClient);
-            const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
-                FunctionName: metadata.data.devFunction,
-            }));
-            return {
-                role: functionConfig?.Role,
-                envs: functionConfig?.Environment?.Variables || {},
-                secrets: metadata.data.secrets,
-            };
-        }
-        async function getLiveIamCredentials(roleArn) {
-            const credentials = await assumeSsrRole(roleArn);
-            if (!credentials)
-                return;
-            // refresh crecentials 1 minute before expiration
-            const expireAt = credentials.Expiration.getTime() - 60000;
-            clearTimeout(timer);
-            timer = setTimeout(() => {
-                Colors.line(`\n`, `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`);
-                runSite("iam_expired");
-            }, expireAt - Date.now());
-            return {
-                AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
-                AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
-                AWS_SESSION_TOKEN: credentials.SessionToken,
-            };
-        }
-        async function getLocalIamCredentials() {
-            const { useAWSCredentials } = await import("../../credentials.js");
-            const credentials = await useAWSCredentials();
-            return {
-                AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-                AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-                AWS_SESSION_TOKEN: credentials.sessionToken,
-            };
-        }
-        async function runCommand(envs) {
-            Colors.gap();
-            if (p) {
-                p.removeAllListeners("exit");
-                // Note: calling p.kill() does not kill child processes. And in the
-                // cases of Next.js and CRA, servers are child processes. Need to
-                // kill the entire process tree to free up port ie. 3000.
-                await new Promise((resolve, reject) => {
-                    kill.default(p?.pid, (error) => {
-                        if (error) {
-                            return reject(error);
-                        }
-                        resolve(true);
-                    });
-                });
-            }
-            p = spawn(command, {
-                env: {
-                    ...process.env,
-                    ...envs,
-                    AWS_REGION: project.config.region,
-                },
-                stdio: "inherit",
-                shell: true,
-            });
-            p.on("exit", (code) => {
-                exit(code || 0);
-            });
-        }
-        function areEnvsSame(envs1, envs2) {
-            return (Object.keys(envs1).length === Object.keys(envs2).length &&
-                Object.keys(envs1).every((key) => envs1[key] === envs2[key]));
-        }
-        async function assumeSsrRole(roleArn) {
-            const { STSClient, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
-            const { useAWSClient } = await import("../../credentials.js");
-            const sts = useAWSClient(STSClient);
-            const assumeRole = async (duration) => {
-                const { Credentials: credentials } = await sts.send(new AssumeRoleCommand({
-                    RoleArn: roleArn,
-                    RoleSessionName: "dev-session",
-                    DurationSeconds: duration,
-                }));
-                return credentials;
-            };
-            // Assume role with max duration first. This can fail if chaining roles, or if
-            // the role has a max duration set. If it fails, assume role with 1 hour duration.
-            let err;
-            try {
-                return await assumeRole(43200);
-            }
-            catch (e) {
-                err = e;
-            }
-            if (err.name === "ValidationError" &&
-                err.message.startsWith("The requested DurationSeconds exceeds")) {
-                try {
-                    return await assumeRole(3600);
-                }
-                catch (e) {
-                    err = e;
-                }
-            }
-            Colors.line("Using local IAM credentials since `sst dev` is not running.");
-            Logger.debug(`Failed to assume ${roleArn}.`, err);
-        }
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-})
-    .strict(false);

package/cli/commands/bootstrap.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="yargs" />
-import type { Program } from "../program.js";
-export declare const bootstrap: (program: Program) => import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-}>;

package/cli/commands/bootstrap.js

@@ -1,11 +0,0 @@
-export const bootstrap = (program) => program.command("bootstrap", "Create the SST bootstrap stack", (yargs) => yargs, async () => {
-    const { exit, exitWithError } = await import("../program.js");
-    const { useBootstrap } = await import("../../bootstrap.js");
-    try {
-        await useBootstrap();
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/commands/build.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="yargs" />
-import type { Program } from "../program.js";
-export declare const build: (program: Program) => import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-} & {
-    to: string | undefined;
-}>;

package/cli/commands/build.js

@@ -1,25 +0,0 @@
-export const build = (program) => program.command("build", "Build your app", (yargs) => yargs.option("to", {
-    type: "string",
-    describe: "Output directory, defaults to .sst/dist",
-}), async (args) => {
-    const { exit, exitWithError } = await import("../program.js");
-    const { useProject } = await import("../../project.js");
-    const { Stacks } = await import("../../stacks/index.js");
-    const { Colors } = await import("../colors.js");
-    const path = await import("path");
-    try {
-        const project = useProject();
-        const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-        const result = await Stacks.synth({
-            fn: sstConfig.stacks,
-            buildDir: args.to,
-            mode: "deploy",
-        });
-        Colors.line("");
-        Colors.line(Colors.success(`✔`), Colors.bold(" Built:"), `${result.stacks.length} stack${result.stacks.length > 1 ? "s" : ""} to ${path.relative(process.cwd(), result.directory)}`);
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/commands/connect.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="yargs" />
-import type { Program } from "../program.js";
-export declare const connect: (program: Program) => import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-} & {
-    dev: boolean;
-}>;

package/cli/commands/connect.js

@@ -1,55 +0,0 @@
-import { Colors } from "../colors.js";
-export const connect = (program) => program.command("connect", "Connect a stage to SST Console", (yargs) => yargs.option("dev", {
-    type: "boolean",
-    default: false,
-    describe: "Connect to SST dev account (probably don't want to do this)",
-}), async (args) => {
-    if (!args.future)
-        throw new Error("This command is not yet available.");
-    const { exit, exitWithError } = await import("../program.js");
-    const { useAWSClient } = await import("../../credentials.js");
-    const { useProject } = await import("../../project.js");
-    const { useSTSIdentity } = await import("../../credentials.js");
-    const { IAMClient, CreateRoleCommand, AttachRolePolicyCommand } = await import("@aws-sdk/client-iam");
-    try {
-        const client = useAWSClient(IAMClient);
-        if (args.dev) {
-            Colors.line(Colors.warning("⚠"), Colors.bold(" Connecting to dev stage"));
-        }
-        await client
-            .send(new CreateRoleCommand({
-            RoleName: "sst",
-            AssumeRolePolicyDocument: JSON.stringify({
-                Version: "2012-10-17",
-                Statement: [
-                    {
-                        Effect: "Allow",
-                        Principal: {
-                            AWS: `arn:aws:iam::${args.dev ? "917397401067" : "226609089145"}:root`,
-                        },
-                        Action: "sts:AssumeRole",
-                    },
-                ],
-            }),
-        }))
-            .catch((e) => {
-            if (e.Error.Code === "EntityAlreadyExists")
-                return;
-            throw e;
-        });
-        await client.send(new AttachRolePolicyCommand({
-            RoleName: "sst",
-            PolicyArn: "arn:aws:iam::aws:policy/AdministratorAccess",
-        }));
-        const project = useProject();
-        const identity = await useSTSIdentity();
-        const host = args.dev
-            ? "http://localhost:3000"
-            : "https://console.production.sst.dev";
-        console.log(`${host}/connect?app=${project.config.name}&stage=${project.config.stage}&aws_account_id=${identity.Account}&region=${project.config.region}`);
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/commands/console.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="yargs" />
-import type { Program } from "../program.js";
-export declare const consoleCommand: (program: Program) => Promise<import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-}>>;

package/cli/commands/console.js

@@ -1,22 +0,0 @@
-export const consoleCommand = async (program) => program.command("console", "Start the SST Console", (yargs) => yargs, async () => {
-    const { exit, exitWithError } = await import("../program.js");
-    const { useRuntimeServer } = await import("../../runtime/server.js");
-    const { useLocalServer } = await import("../local/server.js");
-    const { printHeader } = await import("../ui/header.js");
-    const { clear } = await import("../terminal.js");
-    try {
-        await Promise.all([
-            useRuntimeServer(),
-            useLocalServer({
-                key: "",
-                cert: "",
-                live: false,
-            }),
-        ]);
-        clear();
-        printHeader({ console: true, hint: "ready!" });
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/commands/deploy.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="yargs" />
-import type { Program } from "../program.js";
-export declare const deploy: (program: Program) => import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-} & {
-    from: string | undefined;
-} & {
-    filter: string | undefined;
-}>;

package/cli/commands/deploy.js

@@ -1,112 +0,0 @@
-import { useSTSIdentity } from "../../credentials.js";
-import { Colors } from "../colors.js";
-import fs from "fs/promises";
-import path from "path";
-export const deploy = (program) => program.command("deploy [filter]", "Deploy your app to AWS", (yargs) => yargs
-    .option("from", {
-    type: "string",
-    describe: "Deploy using previously built output",
-})
-    .positional("filter", {
-    type: "string",
-    describe: "Optionally filter stacks to deploy",
-}), async (args) => {
-    const React = await import("react");
-    const { printDeploymentResults } = await import("../ui/deploy.js");
-    const { createSpinner } = await import("../spinner.js");
-    const { dim, blue, bold } = await import("colorette");
-    const { exit, exitWithError } = await import("../program.js");
-    const { useProject } = await import("../../project.js");
-    const { SilentError } = await import("../../error.js");
-    const { loadAssembly, useAppMetadata, saveAppMetadata, Stacks } = await import("../../stacks/index.js");
-    const { getCiInfo } = await import("../ci-info.js");
-    const { render } = await import("ink");
-    const { DeploymentUI } = await import("../ui/deploy.js");
-    const { mapValues } = await import("remeda");
-    try {
-        const project = useProject();
-        const [identity, appMetadata] = await Promise.all([
-            useSTSIdentity(),
-            useAppMetadata(),
-        ]);
-        async function promptChangeMode() {
-            const readline = await import("readline");
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            return new Promise((resolve) => {
-                console.log("");
-                rl.question(`You were previously running the stage "${project.config.stage}" in dev mode. It is recommended that you use a different stage for production. Read more here — https://docs.sst.dev/live-lambda-development\n\nAre you sure you want to deploy to this stage? (y/N) `, async (input) => {
-                    rl.close();
-                    resolve(input.trim() === "y");
-                });
-            });
-        }
-        // Check app mode changed
-        if (!project.config.advanced?.disableAppModeCheck &&
-            !getCiInfo().isCI &&
-            appMetadata &&
-            appMetadata.mode !== "deploy") {
-            if (!(await promptChangeMode())) {
-                await exit();
-            }
-        }
-        Colors.line(`${Colors.primary.bold(`SST v${project.version}`)}`);
-        Colors.gap();
-        Colors.line(`${Colors.primary(`➜`)}  ${Colors.bold("App:")}     ${project.config.name}`);
-        Colors.line(`   ${Colors.bold("Stage:")}   ${project.config.stage}`);
-        Colors.line(`   ${Colors.bold("Region:")}  ${project.config.region}`);
-        Colors.line(`   ${Colors.bold("Account:")} ${identity.Account}`);
-        Colors.gap();
-        const isActiveStack = (stackId) => !args.filter ||
-            stackId
-                .toLowerCase()
-                .replace(project.config.name.toLowerCase(), "")
-                .replace(project.config.stage.toLowerCase(), "")
-                .includes(args.filter.toLowerCase());
-        // Generate cloud assembly
-        // - if --from is specified, we will use the existing cloud assembly
-        // - if --from is not specified, we will call synth to generate
-        const assembly = await (async function () {
-            if (args.from) {
-                const result = await loadAssembly(args.from);
-                return result;
-            }
-            const spinner = createSpinner({
-                text: " Building...",
-            });
-            const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-            const result = await Stacks.synth({
-                fn: sstConfig.stacks,
-                mode: "deploy",
-                isActiveStack,
-            });
-            spinner.succeed();
-            return result;
-        })();
-        const target = assembly.stacks.filter((s) => isActiveStack(s.id));
-        if (!target.length) {
-            Colors.line(`No stacks found matching ${blue(args.filter)}`);
-            throw new SilentError(`No stacks found matching ${args.filter}`);
-        }
-        const component = render(React.createElement(DeploymentUI, { assembly: assembly }));
-        const results = await Stacks.deployMany(target);
-        component.clear();
-        component.unmount();
-        printDeploymentResults(assembly, results);
-        // Check failed stacks
-        const failed = Object.values(results).find((result) => Stacks.isFailed(result.status));
-        if (failed) {
-            throw new SilentError(`CloudFormation status ${failed.status}`);
-        }
-        fs.writeFile(project.config.outputs ||
-            path.join(project.paths.out, "outputs.json"), JSON.stringify(mapValues(results, (val) => val.outputs), null, 2));
-        // Update app state
-        await saveAppMetadata({ mode: "deploy" });
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});