sst 2.0.0-rc.9 → 2.0.0

package/cli/commands/bind.js

@@ -1,23 +1,26 @@
-import { useProject } from "../../app.js";
-export const bind = (program) => program.command("bind <command>", "Binds blah", (yargs) => yargs.positional("command", {
+export const bind = (program) => program.command("bind <command>", "Bind your app's resources to a command", (yargs) => yargs
+    .positional("command", {
     type: "string",
-    describe: "Command to bind to",
+    describe: "The command to bind to",
     demandOption: true,
-}), async (args) => {
+})
+    .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 } = await import("../../config.js");
-    const { spawnSync, spawn } = await import("child_process");
+    const { spawnSync } = await import("child_process");
     const { useAWSCredentials } = await import("../../credentials.js");
+    const { useProject } = await import("../../project.js");
     const env = await Config.env();
     const project = useProject();
     const credentials = await useAWSCredentials();
     const result = spawnSync(args.command, {
         env: {
+            ...process.env,
             ...env,
             AWS_ACCESS_KEY_ID: credentials.accessKeyId,
             AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
             AWS_SESSION_TOKEN: credentials.sessionToken,
-            AWS_REGION: project.region,
-            PATH: process.env.PATH,
+            AWS_REGION: project.config.region,
         },
         stdio: "inherit",
         shell: process.env.SHELL || true,

package/cli/commands/bootstrap.d.ts

@@ -0,0 +1,13 @@
+/// <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;
+}>;

package/cli/commands/bootstrap.js

@@ -0,0 +1,11 @@
+export const bootstrap = (program) => program.command("bootstrap", "Create the SST bootstrap stack", (yargs) => yargs, async () => {
+    const { Colors } = await import("../colors.js");
+    const { useProject } = await import("../../project.js");
+    const { useBootstrap } = await import("../../bootstrap.js");
+    const { useSTSIdentity } = await import("../../credentials.js");
+    const project = useProject();
+    const identity = await useSTSIdentity();
+    await useBootstrap();
+    Colors.line(Colors.success(`✔`), Colors.bold(` Bootstrapped account ${identity.Account} in region ${project.config.region}`));
+    process.exit(0);
+});

package/cli/commands/build.d.ts

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

package/cli/commands/build.js

@@ -1,12 +1,17 @@
-import { createSpinner } from "../spinner.js";
-export const build = (program) => program.command("build", "Build stacks code", yargs => yargs.option("from", { type: "string" }), async () => {
+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 { useProject } = await import("../../project.js");
     const { Stacks } = await import("../../stacks/index.js");
-    const spinner = createSpinner("Building stacks").start();
-    const fn = await Stacks.build();
-    await Stacks.synth({
-        fn,
-        mode: "deploy"
+    const { Colors } = await import("../colors.js");
+    const path = await import("path");
+    const result = await Stacks.synth({
+        fn: useProject().stacks,
+        buildDir: args.to,
+        mode: "deploy",
     });
-    spinner.succeed();
+    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)}`);
     process.exit(0);
 });

package/cli/commands/console.d.ts

@@ -1,9 +1,13 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+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;
 }>>;

package/cli/commands/console.js

@@ -1,15 +1,17 @@
-import { blue } from "colorette";
-import { useRuntimeServer } from "../../runtime/server.js";
-import { useLocalServer } from "../local/server.js";
-export const consoleCommand = async (program) => program.command("console", "Start the sst console", (yargs) => yargs, async () => {
+export const consoleCommand = async (program) => program.command("console", "Start the SST Console", (yargs) => yargs, async () => {
+    const { blue } = await import("colorette");
+    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");
     await Promise.all([
         useRuntimeServer(),
         useLocalServer({
             key: "",
             cert: "",
             live: false,
-            port: 13557,
         }),
     ]);
-    console.log(`Console started: ${blue(`https://console.sst.dev`)}`);
+    clear();
+    printHeader({ console: true, hint: "ready!" });
 });

package/cli/commands/deploy.d.ts

@@ -7,9 +7,11 @@ export declare const deploy: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    from: string | undefined;
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
 } & {
-    fullscreen: boolean;
+    from: string | undefined;
 } & {
     filter: string | undefined;
 }>;

package/cli/commands/deploy.js

@@ -1,50 +1,90 @@
-import { printDeploymentResults } from "../ui/deploy.js";
-export const deploy = (program) => program.command("deploy [filter]", "Work on your SST app locally", (yargs) => yargs
-    .option("from", { type: "string" })
-    .option("fullscreen", {
-    type: "boolean",
-    describe: "Disable full screen UI",
-    default: true,
+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" }), async (args) => {
+    .positional("filter", {
+    type: "string",
+    describe: "Optionally filter stacks to deploy",
+}), async (args) => {
     const React = await import("react");
-    const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
-    const { blue, bold } = await import("colorette");
-    const { useProject } = await import("../../app.js");
-    const { Stacks } = await import("../../stacks/index.js");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { createSpinner } = await import("../spinner.js");
+    const { dim, blue, bold } = await import("colorette");
+    const { useProject } = await import("../../project.js");
+    const { loadAssembly, useAppMetadata, saveAppMetadata, Stacks } = await import("../../stacks/index.js");
     const { render } = await import("ink");
     const { DeploymentUI } = await import("../ui/deploy.js");
+    const { mapValues } = await import("remeda");
+    const project = useProject();
+    const [identity, appMetadata] = await Promise.all([
+        useSTSIdentity(),
+        useAppMetadata(),
+    ]);
+    // Check app mode changed
+    if (appMetadata && appMetadata.mode !== "deploy") {
+        if (!(await promptChangeMode())) {
+            process.exit(0);
+        }
+    }
+    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();
+    // 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 = new CloudAssembly(args.from);
+            const result = await loadAssembly(args.from);
             return result;
         }
-        const fn = await Stacks.build();
-        return await Stacks.synth({
-            fn,
+        const spinner = createSpinner({
+            text: " Building...",
+        });
+        const result = await Stacks.synth({
+            fn: project.stacks,
             mode: "deploy",
         });
+        spinner.succeed();
+        return result;
     })();
-    const project = useProject();
     const target = assembly.stacks.filter((s) => !args.filter ||
         s.stackName.toLowerCase().includes(args.filter.toLowerCase()));
     if (!target.length) {
-        console.log(`No stacks found matching ${blue(args.filter)}`);
+        Colors.line(`No stacks found matching ${blue(args.filter)}`);
         process.exit(1);
-        return;
-    }
-    console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.stage)}...`);
-    let component = undefined;
-    if (args.fullscreen) {
-        process.stdout.write("\x1b[?1049h");
-        component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
     }
+    const component = render(React.createElement(DeploymentUI, { assembly: assembly }));
     const results = await Stacks.deployMany(target);
-    if (component)
-        component.unmount();
-    process.stdout.write("\x1b[?1049l");
-    printDeploymentResults(results);
+    component.clear();
+    component.unmount();
+    printDeploymentResults(assembly, results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
         process.exit(1);
+    fs.writeFile(path.join(project.paths.out, "outputs.json"), JSON.stringify(mapValues(results, (val) => val.outputs), null, 2));
+    // Update app state
+    await saveAppMetadata({ mode: "deploy" });
     process.exit(0);
 });
+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 this 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");
+        });
+    });
+}

package/cli/commands/dev.d.ts

@@ -7,5 +7,9 @@ export declare const dev: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    fullscreen: boolean;
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
+} & {
+    "increase-timeout": boolean | undefined;
 }>;

package/cli/commands/dev.js

@@ -1,81 +1,133 @@
-import path from "path";
-import fs from "fs/promises";
-import crypto from "crypto";
-import { printDeploymentResults } from "../ui/deploy.js";
-import { useFunctions } from "../../constructs/Function.js";
-import { dim, gray, yellow } from "colorette";
-import { useProject } from "../../app.js";
-import { SiteEnv } from "../../site-env.js";
-import { usePothosBuilder } from "./plugins/pothos.js";
-import { useKyselyTypeGenerator } from "./plugins/kysely.js";
-import { useRDSWarmer } from "./plugins/warmer.js";
-export const dev = (program) => program.command(["start", "dev"], "Work on your SST app locally", (yargs) => yargs.option("fullscreen", {
+import { Colors } from "../colors.js";
+import { printHeader } from "../ui/header.js";
+import { mapValues, omitBy, pipe } from "remeda";
+export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("increase-timeout", {
     type: "boolean",
-    describe: "Disable full screen UI",
-    default: true,
+    description: "Increase function timeout",
 }), async (args) => {
     const { useRuntimeWorkers } = await import("../../runtime/workers.js");
     const { useIOTBridge } = await import("../../runtime/iot.js");
     const { useRuntimeServer } = await import("../../runtime/server.js");
     const { useBus } = await import("../../bus.js");
     const { useWatcher } = await import("../../watcher.js");
-    const { Stacks } = await import("../../stacks/index.js");
+    const { useAppMetadata, saveAppMetadata, Stacks } = await import("../../stacks/index.js");
     const { Logger } = await import("../../logger.js");
     const { createSpinner } = await import("../spinner.js");
-    const { bold, magenta, green, blue, red } = await import("colorette");
+    const { bold, dim, yellow } = await import("colorette");
     const { render } = await import("ink");
     const React = await import("react");
     const { Context } = await import("../../context/context.js");
-    const { DeploymentUI } = await import("../ui/deploy.js");
+    const { printDeploymentResults, DeploymentUI } = await import("../ui/deploy.js");
     const { useLocalServer } = await import("../local/server.js");
+    const path = await import("path");
+    const fs = await import("fs/promises");
+    const crypto = await import("crypto");
+    const { useFunctions } = await import("../../constructs/Function.js");
+    const { SiteEnv } = await import("../../site-env.js");
+    const { usePothosBuilder } = await import("./plugins/pothos.js");
+    const { useKyselyTypeGenerator } = await import("./plugins/kysely.js");
+    const { useRDSWarmer } = await import("./plugins/warmer.js");
+    const { useProject } = await import("../../project.js");
+    const { useMetadata } = await import("../../stacks/metadata.js");
+    const { clear } = await import("../terminal.js");
     if (args._[0] === "start") {
         console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
     }
     const useFunctionLogger = Context.memo(async () => {
         const bus = useBus();
+        const colors = ["#01cdfe", "#ff71ce", "#05ffa1", "#b967ff"];
+        let index = 0;
+        const pending = new Map();
+        function prefix(requestID) {
+            const exists = pending.get(requestID);
+            if (exists) {
+                return Colors.hex(exists.color)(Colors.prefix);
+            }
+            pending.set(requestID, {
+                requestID,
+                started: Date.now(),
+                color: colors[index % colors.length],
+            });
+            index++;
+            return prefix(requestID);
+        }
+        function end(requestID) {
+            // index--;
+            // if (index < 0) index = colors.length - 1;
+            pending.delete(requestID);
+        }
         bus.subscribe("function.invoked", async (evt) => {
-            console.log(bold(magenta(`Invoked `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            Colors.line(prefix(evt.properties.requestID), Colors.dim.bold("Invoked"), Colors.dim(useFunctions().fromID(evt.properties.functionID).handler));
+        });
+        bus.subscribe("worker.stdout", async (evt) => {
+            prefix(evt.properties.requestID);
+            const { started } = pending.get(evt.properties.requestID);
+            for (let line of evt.properties.message.split("\n")) {
+                Colors.line(prefix(evt.properties.requestID), Colors.dim(("+" + (Date.now() - started) + "ms").padEnd(7)), Colors.dim(line));
+            }
         });
         bus.subscribe("function.build.success", async (evt) => {
-            console.log(bold(gray(`Built   `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            const info = useFunctions().fromID(evt.properties.functionID);
+            if (!info.enableLiveDev)
+                return;
+            Colors.line(Colors.dim(Colors.prefix, "Built", info.handler));
         });
         bus.subscribe("function.build.failed", async (evt) => {
-            console.log(bold(red(`Build failed `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
-            console.log(dim(evt.properties.errors.join("\n")));
-        });
-        bus.subscribe("worker.stdout", async (evt) => {
-            const { message } = evt.properties;
-            const lines = message.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                lines[i] = "         " + line;
+            const info = useFunctions().fromID(evt.properties.functionID);
+            if (info.enableLiveDev === false)
+                return;
+            Colors.gap();
+            Colors.line(Colors.danger("✖ "), "Build failed", info.handler);
+            for (const line of evt.properties.errors) {
+                Colors.line("  ", line);
             }
-            console.log(bold(blue(`Log     `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
-            console.log(dim(lines.join("\n")));
+            Colors.gap();
         });
         bus.subscribe("function.success", async (evt) => {
-            console.log(bold(green(`Success `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            // stdout logs sometimes come in after
+            const p = prefix(evt.properties.requestID);
+            const req = pending.get(evt.properties.requestID);
+            setTimeout(() => {
+                Colors.line(p, Colors.dim(`Done in ${Date.now() - req.started - 100}ms`));
+                end(evt.properties.requestID);
+            }, 100);
         });
         bus.subscribe("function.error", async (evt) => {
-            console.log(bold(red(`Error   `)), bold(useFunctions().fromID(evt.properties.functionID).handler), evt.properties.errorMessage);
-            for (const line of evt.properties.trace || []) {
-                console.log(`         ${dim(line)}`);
-            }
+            setTimeout(() => {
+                Colors.line(prefix(evt.properties.requestID), Colors.danger.bold("Error:"), Colors.danger.bold(evt.properties.errorMessage));
+                for (const line of evt.properties.trace || []) {
+                    Colors.line("  ", `${dim(line)}`);
+                }
+                end(evt.properties.requestID);
+            }, 100);
         });
     });
     const useStackBuilder = Context.memo(async () => {
         const watcher = useWatcher();
-        const bus = useBus();
         const project = useProject();
+        const bus = useBus();
         let lastDeployed;
-        let pending;
-        let isDeploying = false;
+        let isWorking = false;
+        let isDirty = false;
         async function build() {
-            const spinner = createSpinner("Building stacks").start();
+            if (isWorking) {
+                isDirty = true;
+                return;
+            }
+            isDirty = false;
+            isWorking = true;
+            Colors.gap();
+            const spinner = createSpinner({
+                color: "gray",
+                text: lastDeployed ? ` Building...` : dim(` Checking for changes`),
+            }).start();
             try {
-                const fn = await Stacks.build();
+                const [metafile, sstConfig] = await Stacks.load(project.paths.config);
+                project.metafile = metafile;
+                project.stacks = sstConfig.stacks;
                 const assembly = await Stacks.synth({
-                    fn,
+                    increaseTimeout: args["increase-timeout"],
+                    fn: project.stacks,
                     outDir: `.sst/cdk.out`,
                     mode: "dev",
                 });
@@ -83,39 +135,46 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
                 const next = await checksum(assembly.directory);
                 Logger.debug("Checksum", "next", next, "old", lastDeployed);
                 if (next === lastDeployed) {
-                    spinner.succeed("Stacks built! No changes");
+                    spinner.succeed(Colors.dim(" Built with no changes"));
+                    isWorking = false;
+                    if (isDirty)
+                        build();
                     return;
                 }
-                spinner.succeed(lastDeployed ? `Stacks built!` : `Stacks built!`);
-                pending = assembly;
-                if (lastDeployed)
-                    deploy();
+                if (!lastDeployed) {
+                    spinner.stop();
+                    spinner.clear();
+                    Colors.mode("gap");
+                }
+                else {
+                    spinner.succeed(Colors.dim(` Built`));
+                    Colors.gap();
+                }
+                deploy(assembly);
             }
             catch (ex) {
+                isWorking = false;
                 spinner.fail();
-                console.error(ex);
+                Colors.line(ex.stack
+                    .split("\n")
+                    .map((line) => "   " + line)
+                    .join("\n"));
+                Colors.gap();
             }
         }
-        async function deploy() {
-            if (!pending)
-                return;
-            if (isDeploying)
-                return;
-            isDeploying = true;
-            const assembly = pending;
+        async function deploy(assembly) {
             const nextChecksum = await checksum(assembly.directory);
-            pending = undefined;
-            let component = undefined;
-            if (args.fullscreen) {
-                process.stdout.write("\x1b[?1049h");
-                component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-            }
+            const component = render(React.createElement(DeploymentUI, { assembly: assembly }));
             const results = await Stacks.deployMany(assembly.stacks);
-            if (component)
-                component.unmount();
-            process.stdout.write("\x1b[?1049l");
+            component.clear();
+            component.unmount();
+            printDeploymentResults(assembly, results);
+            // Update app state
+            if (!lastDeployed) {
+                await saveAppMetadata({ mode: "dev" });
+            }
             lastDeployed = nextChecksum;
-            printDeploymentResults(results);
+            // Update site env
             const keys = await SiteEnv.keys();
             if (keys.length) {
                 const result = {};
@@ -131,8 +190,11 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
                 }
                 await SiteEnv.writeValues(result);
             }
-            isDeploying = false;
-            deploy();
+            // Write outputs.json
+            fs.writeFile(path.join(project.paths.out, "outputs.json"), JSON.stringify(pipe(results, omitBy((_, key) => key.includes("SstSiteEnv")), mapValues((val) => val.outputs)), null, 2));
+            isWorking = false;
+            if (isDirty)
+                build();
         }
         async function checksum(cdkOutPath) {
             const manifestPath = path.join(cdkOutPath, "manifest.json");
@@ -151,38 +213,54 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
                 .digest("hex");
             return hash;
         }
-        let metafile;
-        bus.subscribe("stack.built", async (evt) => {
-            metafile = evt.properties.metafile;
-        });
         watcher.subscribe("file.changed", async (evt) => {
-            if (!metafile)
+            if (!project.metafile)
                 return;
-            if (!metafile.inputs[evt.properties.relative])
+            if (!project.metafile.inputs[evt.properties.relative])
                 return;
             build();
         });
         await build();
-        await deploy();
     });
-    createSpinner("").start().succeed("Ready for function invocations");
-    createSpinner("")
-        .start()
-        .succeed(`Console ready at https://console.sst.dev`);
-    await Promise.all([
+    const [appMetadata] = await Promise.all([
+        useAppMetadata(),
         useLocalServer({
             key: "",
             cert: "",
             live: true,
-            port: 13557,
         }),
+    ]);
+    // Check app mode changed
+    if (appMetadata && appMetadata.mode !== "dev") {
+        if (!(await promptChangeMode())) {
+            process.exit(0);
+        }
+    }
+    clear();
+    await printHeader({ console: true, hint: "ready!" });
+    await Promise.all([
         useRuntimeWorkers(),
         useIOTBridge(),
         useRuntimeServer(),
         usePothosBuilder(),
+        useMetadata(),
         useKyselyTypeGenerator(),
         useRDSWarmer(),
         useFunctionLogger(),
         useStackBuilder(),
     ]);
 });
+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 have previously deployed this stage in production. It is recommended that you use a different stage for development. Read more here — https://docs.sst.dev/live-lambda-development\n\nAre you sure you want to run this stage in dev mode? [y/N] ", async (input) => {
+            rl.close();
+            resolve(input.trim() === "y");
+        });
+    });
+}

package/cli/commands/diff.d.ts

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