@mittwald/cli 1.4.4 → 1.5.1

package/dist/lib/context/FlagSetBuilder.js

@@ -59,9 +59,13 @@ export default class FlagSetBuilder {
     buildFlags() {
         const { displayName } = this;
         const article = articleForWord(displayName);
-        const { retrieveFromContext = true } = this.opts;
-        let summary = `ID or short ID of ${article} ${displayName}`;
-        let description = `May contain a short ID or a full ID of ${article} ${displayName}`;
+        const { retrieveFromContext = true, expectedShortIDFormat } = this.opts;
+        let summary = `ID of ${article} ${displayName}`;
+        let description = `May contain a ID of ${article} ${displayName}`;
+        if (expectedShortIDFormat) {
+            summary = `ID or short ID of ${article} ${displayName}`;
+            description = `May contain a short ID or a full ID of ${article} ${displayName}`;
+        }
         if (retrieveFromContext) {
             summary += `; this flag is optional if a default ${displayName} is set in the context`;
             description += `; you can also use the "<%= config.bin %> context set --${this.flagName}=<VALUE>" command to persistently set a default ${displayName} for all commands that accept this flag.`;
@@ -83,8 +87,11 @@ export default class FlagSetBuilder {
     buildArgs() {
         const { displayName } = this;
         const article = articleForWord(displayName);
-        const { retrieveFromContext = true } = this.opts;
-        let description = `ID or short ID of ${article} ${displayName}`;
+        const { retrieveFromContext = true, expectedShortIDFormat } = this.opts;
+        let description = `ID of ${article} ${displayName}`;
+        if (expectedShortIDFormat) {
+            description = `ID or short ID of ${article} ${displayName}`;
+        }
         if (retrieveFromContext) {
             description += `; this argument is optional if a default ${displayName} is set in the context.`;
         }
@@ -99,28 +106,28 @@ export default class FlagSetBuilder {
         };
     }
     buildSanityCheck() {
-        if (this.opts.expectedShortIDFormat != null) {
-            const format = this.opts.expectedShortIDFormat;
-            return (id) => {
-                if (!validateUuid(id) && !format.pattern.test(id)) {
-                    throw new UnexpectedShortIDPassedError(this.displayName, format.display);
-                }
-            };
+        if (!this.opts.expectedShortIDFormat) {
+            return () => { };
         }
-        return () => { };
+        const format = this.opts.expectedShortIDFormat;
+        return (id) => {
+            if (!validateUuid(id) && !format.pattern.test(id)) {
+                throw new UnexpectedShortIDPassedError(this.displayName, format.display);
+            }
+        };
     }
     buildIDGetter() {
         const idInputSanityCheck = this.buildSanityCheck();
         const idFromArgsOrFlag = this.buildIDFromArgsOrFlag();
         const { normalize = (_, id) => id, retrieveFromContext = true } = this.opts;
         return async (apiClient, commandType, flags, args, cfg) => {
+            const context = new Context(apiClient, cfg);
             const idInput = idFromArgsOrFlag(flags, args);
             if (idInput) {
                 idInputSanityCheck(idInput);
-                return normalize(apiClient, idInput);
+                return normalize(apiClient, idInput, context);
             }
             if (retrieveFromContext) {
-                const context = new Context(apiClient, cfg);
                 const idFromContext = await context.getContextValue(this.flagName);
                 if (idFromContext) {
                     return idFromContext.value;

package/dist/lib/resources/container/containerconfig.d.ts

@@ -0,0 +1,43 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+type ContainerContainerImageConfig = MittwaldAPIV2.Components.Schemas.ContainerContainerImageConfig;
+/**
+ * Parses environment variables from command line flags and env files
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariables(envFlags?: string[], envFiles?: string[]): Promise<Record<string, string>>;
+/**
+ * Parses environment variables from env files
+ *
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromFile(envFiles?: string[]): Promise<Record<string, string>>;
+/**
+ * Parses environment variables from command line flags
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromEnvFlags(envFlags?: string[]): Record<string, string>;
+/**
+ * Determines which ports to expose based on image metadata
+ *
+ * @param imageMeta Metadata about the container image
+ * @param publishAll Whether to publish all ports defined in the image
+ * @param publishPorts Array of port mappings specified by the user
+ * @returns An array of port mappings
+ */
+export declare function getPortMappings(imageMeta: ContainerContainerImageConfig, publishAll?: boolean, publishPorts?: string[]): string[];
+/**
+ * Retrieves metadata for a container image
+ *
+ * @param apiClient The API client instance
+ * @param image The container image reference
+ * @param projectId The project ID for credentials
+ * @returns Metadata about the container image
+ */
+export declare function getImageMeta(apiClient: MittwaldAPIV2Client, image: string, projectId: string): Promise<ContainerContainerImageConfig>;
+export {};

package/dist/lib/resources/container/containerconfig.js

@@ -0,0 +1,82 @@
+import { assertStatus, } from "@mittwald/api-client";
+import * as fs from "fs/promises";
+import { parse } from "envfile";
+import { pathExists } from "../../util/fs/pathExists.js";
+/**
+ * Parses environment variables from command line flags and env files
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export async function parseEnvironmentVariables(envFlags = [], envFiles = []) {
+    return {
+        ...parseEnvironmentVariablesFromEnvFlags(envFlags),
+        ...(await parseEnvironmentVariablesFromFile(envFiles)),
+    };
+}
+/**
+ * Parses environment variables from env files
+ *
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export async function parseEnvironmentVariablesFromFile(envFiles = []) {
+    const result = {};
+    for (const envFile of envFiles) {
+        if (!(await pathExists(envFile))) {
+            throw new Error(`Env file not found: ${envFile}`);
+        }
+        const fileContent = await fs.readFile(envFile, { encoding: "utf-8" });
+        const parsed = parse(fileContent);
+        Object.assign(result, parsed);
+    }
+    return result;
+}
+/**
+ * Parses environment variables from command line flags
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export function parseEnvironmentVariablesFromEnvFlags(envFlags = []) {
+    const splitIntoKeyAndValue = (e) => e.split("=", 2);
+    return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
+}
+/**
+ * Determines which ports to expose based on image metadata
+ *
+ * @param imageMeta Metadata about the container image
+ * @param publishAll Whether to publish all ports defined in the image
+ * @param publishPorts Array of port mappings specified by the user
+ * @returns An array of port mappings
+ */
+export function getPortMappings(imageMeta, publishAll = false, publishPorts = []) {
+    if (publishAll) {
+        const definedPorts = imageMeta.exposedPorts ?? [];
+        const concatPort = (p) => {
+            const [port, protocol = "tcp"] = p.port.split("/", 2);
+            return `${port}:${port}/${protocol}`;
+        };
+        return definedPorts.map(concatPort);
+    }
+    return publishPorts;
+}
+/**
+ * Retrieves metadata for a container image
+ *
+ * @param apiClient The API client instance
+ * @param image The container image reference
+ * @param projectId The project ID for credentials
+ * @returns Metadata about the container image
+ */
+export async function getImageMeta(apiClient, image, projectId) {
+    const resp = await apiClient.container.getContainerImageConfig({
+        queryParameters: {
+            imageReference: image,
+            useCredentialsForProjectId: projectId,
+        },
+    });
+    assertStatus(resp, 200);
+    return resp.data;
+}

package/dist/lib/resources/container/flags.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { CommandType } from "../../context/FlagSetBuilder.js";
+import { Config } from "@oclif/core";
+export declare const containerFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"container">, containerArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"container">, withContainerId: (apiClient: MittwaldAPIV2Client, command: "flag" | "arg" | CommandType<"container">, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: Config) => Promise<string>;
+export declare function withContainerAndStackId(apiClient: MittwaldAPIV2Client, command: CommandType<"project"> | "flag" | "arg", flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: Config): Promise<[string, string]>;

package/dist/lib/resources/container/flags.js

@@ -0,0 +1,34 @@
+import { assertStatus } from "@mittwald/api-client";
+import FlagSetBuilder from "../../context/FlagSetBuilder.js";
+import { contextIDNormalizers } from "../../context/Context.js";
+import { withProjectId } from "../project/flags.js";
+async function normalize(apiClient, serviceId, ctx) {
+    const { value: stackId } = await ctx.mustGetContextValue("stack-id");
+    const result = await apiClient.container.getService({
+        stackId,
+        serviceId,
+    });
+    assertStatus(result, 200);
+    return result.data.id;
+}
+contextIDNormalizers["container-id"] = normalize;
+export const { flags: containerFlags, args: containerArgs, withId: withContainerId, } = new FlagSetBuilder("container", "c", { normalize }).build();
+export async function withContainerAndStackId(apiClient, command, flags, args, cfg) {
+    const projectId = await withProjectId(apiClient, command, flags, args, cfg);
+    const containerId = flags["container-id"] ?? args["container-id"];
+    if (typeof containerId !== "string") {
+        throw new Error("container ID, short ID or name must be specified");
+    }
+    const containerResp = await apiClient.container.listServices({
+        projectId,
+    });
+    assertStatus(containerResp, 200);
+    for (const container of containerResp.data) {
+        if (container.shortId === containerId ||
+            container.id === containerId ||
+            container.serviceName === containerId) {
+            return [container.id, container.stackId];
+        }
+    }
+    throw new Error(`no container ${containerId} found in project ${projectId}`);
+}

package/dist/lib/resources/org/flags.js

@@ -7,4 +7,10 @@ async function normalize(apiClient, customerId) {
     return customer.data.customerId;
 }
 contextIDNormalizers["org-id"] = normalize;
-export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = new FlagSetBuilder("org", "o", { normalize }).build();
+export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = new FlagSetBuilder("org", "o", {
+    normalize,
+    expectedShortIDFormat: {
+        pattern: /^\d+$/,
+        display: "000000",
+    },
+}).build();

package/dist/lib/resources/server/flags.js

@@ -7,4 +7,10 @@ async function normalize(apiClient, serverId) {
     return result.data.id;
 }
 contextIDNormalizers["server-id"] = normalize;
-export const { flags: serverFlags, args: serverArgs, withId: withServerId, } = new FlagSetBuilder("server", "s", { normalize }).build();
+export const { flags: serverFlags, args: serverArgs, withId: withServerId, } = new FlagSetBuilder("server", "s", {
+    normalize,
+    expectedShortIDFormat: {
+        pattern: /^s-.*/,
+        display: "s-XXXXXX",
+    },
+}).build();

package/dist/lib/resources/stack/enrich.d.ts

@@ -0,0 +1,4 @@
+import { type MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
+export declare function enrichStackDefinition(apiClient: MittwaldAPIV2Client, projectId: string, input: StackRequest): Promise<StackRequest>;
+export {};

package/dist/lib/resources/stack/enrich.js

@@ -0,0 +1,55 @@
+import { assertStatus, } from "@mittwald/api-client";
+import { readFile } from "fs/promises";
+import { parse } from "envfile";
+export async function enrichStackDefinition(apiClient, projectId, input) {
+    const enriched = structuredClone(input);
+    for (const serviceName of Object.keys(input.services ?? {})) {
+        let service = enriched.services[serviceName];
+        service = await setCommandAndEntrypointFromImage(apiClient, projectId, service);
+        service = await setEnvironmentFromEnvFile(service);
+        enriched.services[serviceName] = service;
+    }
+    return enriched;
+}
+async function setEnvironmentFromEnvFile(service) {
+    if (!service.env_file) {
+        return service;
+    }
+    const enriched = structuredClone(service);
+    const envFileContent = await readFile(service.env_file, "utf-8");
+    const envVars = parse(envFileContent);
+    delete enriched.env_file;
+    enriched.envs = {
+        ...envVars,
+        ...(enriched.envs ?? {}),
+    };
+    return enriched;
+}
+async function setCommandAndEntrypointFromImage(apiClient, projectId, service) {
+    const enriched = structuredClone(service);
+    const resp = await apiClient.container.getContainerImageConfig({
+        queryParameters: {
+            imageReference: service.image,
+            useCredentialsForProjectId: projectId,
+        },
+    });
+    assertStatus(resp, 200);
+    if (service.ports === undefined) {
+        enriched.ports = (resp.data.exposedPorts ?? []).map((p) => p.port);
+    }
+    if (service.command === undefined) {
+        let command = resp.data.command;
+        if (typeof command === "string") {
+            command = [command];
+        }
+        enriched.command = command;
+    }
+    if (service.entrypoint === undefined) {
+        let entrypoint = resp.data.entrypoint;
+        if (typeof entrypoint === "string") {
+            entrypoint = [entrypoint];
+        }
+        enriched.entrypoint = entrypoint;
+    }
+    return enriched;
+}

package/dist/lib/resources/stack/env.d.ts

@@ -0,0 +1 @@
+export declare function collectEnvironment(base: NodeJS.ProcessEnv, envFile: string): Promise<Record<string, string | undefined>>;

package/dist/lib/resources/stack/env.js

@@ -0,0 +1,11 @@
+import * as fs from "fs/promises";
+import { parse } from "envfile";
+import { pathExists } from "../../util/fs/pathExists.js";
+export async function collectEnvironment(base, envFile) {
+    if (!(await pathExists(envFile))) {
+        return base;
+    }
+    const defs = await fs.readFile(envFile, { encoding: "utf-8" });
+    const parsed = parse(defs);
+    return { ...base, ...parsed };
+}

package/dist/lib/resources/stack/flags.d.ts

@@ -0,0 +1,5 @@
+export declare const stackFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"stack">, stackArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"stack">, withStackId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, command: "flag" | "arg" | import("../../context/FlagSetBuilder.js").CommandType<"stack">, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/lib/resources/stack/flags.js

@@ -0,0 +1,2 @@
+import FlagSetBuilder from "../../context/FlagSetBuilder.js";
+export const { flags: stackFlags, args: stackArgs, withId: withStackId, } = new FlagSetBuilder("stack", "s").build();

package/dist/lib/resources/stack/loader.d.ts

@@ -0,0 +1,5 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
+export declare function loadStackFromFile(file: string, environment: Record<string, string | undefined>): Promise<StackRequest>;
+export declare function loadStackFromStr(input: string, environment: Record<string, string | undefined>): Promise<StackRequest>;
+export {};

package/dist/lib/resources/stack/loader.js

@@ -0,0 +1,47 @@
+import yaml from "js-yaml";
+import * as fs from "fs";
+function loadStackYAMLFromFile(file) {
+    if (file === "-") {
+        return fs.readFileSync(process.stdin.fd, { encoding: "utf-8" });
+    }
+    return fs.readFileSync(file, { encoding: "utf-8" });
+}
+export async function loadStackFromFile(file, environment) {
+    const input = loadStackYAMLFromFile(file);
+    return loadStackFromStr(input, environment);
+}
+export async function loadStackFromStr(input, environment) {
+    const stack = yaml.load(input);
+    const stackWithSubstitutedEnvironment = substituteEnvironmentVariables(stack, environment);
+    return stackWithSubstitutedEnvironment;
+}
+/**
+ * This function aims to be a (more-or-less) complete implementation of Docker
+ * Compose's variable interpolation feature.
+ *
+ * @param input Input object; may be anything coming out of a YAML file.
+ * @param environment A record of environment variables
+ * @see https://docs.docker.com/compose/how-tos/environment-variables/variable-interpolation/
+ */
+function substituteEnvironmentVariables(input, environment) {
+    if (typeof input === "string") {
+        return input.replace(/\$\{(\w+)(:?-(.*))?}/g, (_, key, defExpr, def = "") => {
+            const useDefaultIfNonEmpty = defExpr && defExpr.startsWith(":");
+            if (useDefaultIfNonEmpty) {
+                return environment[key] || def;
+            }
+            return key in environment ? environment[key] : def;
+        });
+    }
+    if (Array.isArray(input)) {
+        return input.map((item) => substituteEnvironmentVariables(item, environment));
+    }
+    if (input && typeof input === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+            result[key] = substituteEnvironmentVariables(value, environment);
+        }
+        return result;
+    }
+    return input;
+}

package/dist/lib/resources/stack/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/resources/stack/loader.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "@jest/globals";
+import { loadStackFromStr } from "./loader.js";
+describe("loadStackFromStr", () => {
+    it("should convert a stack YAML input to a stack definition", async () => {
+        const input = `services:
+  nginx:
+    image: nginx
+    ports:
+      - 80:80
+    environment:
+      FOO: bar
+    volumes:
+      data:/var/www
+volumes:
+  data:`;
+        const stack = await loadStackFromStr(input, {});
+        expect(stack).toHaveProperty("services.nginx.image", "nginx");
+    });
+    it("interpolates environment variables in a stack definition", async () => {
+        const input = `services:
+  nginx:
+    image: nginx:\${NGINX_VERSION}`;
+        const stack = await loadStackFromStr(input, { NGINX_VERSION: "0.1.0" });
+        expect(stack).toHaveProperty("services.nginx.image", "nginx:0.1.0");
+    });
+    it("interpolates environment variables with default values", async () => {
+        const input = `services:
+  nginx:
+    image: nginx:\${NGINX_VERSION:-latest}`;
+        const stack = await loadStackFromStr(input, {});
+        expect(stack).toHaveProperty("services.nginx.image", "nginx:latest");
+    });
+    it("interpolates environment variables with default values for non-empty variables", async () => {
+        const input = `services:
+  nginx:
+    image: nginx
+    environment:
+      FOO: \${FOO:-foo}`;
+        const stack = await loadStackFromStr(input, { FOO: "" });
+        expect(stack).toHaveProperty("services.nginx.environment.FOO", "foo");
+    });
+    it("interpolates environment variables with default values for empty variables", async () => {
+        const input = `services:
+  nginx:
+    image: nginx
+    environment:
+      FOO: \${FOO-foo}`;
+        const stack = await loadStackFromStr(input, { FOO: "" });
+        expect(stack).toHaveProperty("services.nginx.environment.FOO", "");
+    });
+});

package/dist/lib/resources/stack/sanitize.d.ts

@@ -0,0 +1,10 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
+/**
+ * This function is needed to work around the mStudios supposedly docker-compose
+ * compatible container stack API.
+ *
+ * @param stack
+ */
+export declare function sanitizeStackDefinition(stack: StackRequest): StackRequest;
+export {};

package/dist/lib/resources/stack/sanitize.js

@@ -0,0 +1,43 @@
+/**
+ * This function is needed to work around the mStudios supposedly docker-compose
+ * compatible container stack API.
+ *
+ * @param stack
+ */
+export function sanitizeStackDefinition(stack) {
+    const sanitized = {
+        services: structuredClone(stack.services),
+        volumes: structuredClone(stack.volumes),
+    };
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    for (const serviceKey of Object.keys(sanitized.services ?? {})) {
+        const service = sanitized.services[serviceKey];
+        // mStudio requires "command" to be a string[]; in a docker-compose file, it
+        // can also be a regular string.
+        if (typeof service.command === "string") {
+            service.command = [service.command];
+        }
+        // descriptions are required for mStudio containers; docker compose has no
+        // equivalent field.
+        if (!service.description) {
+            service.description = serviceKey;
+        }
+        // mStudio calls it "envs", docker compose calls it "environment" 🫠
+        const serviceWithEnvironment = service;
+        if (serviceWithEnvironment.environment) {
+            service.envs = serviceWithEnvironment.environment;
+            delete serviceWithEnvironment.environment;
+        }
+        if (!service.envs) {
+            service.envs = {};
+        }
+    }
+    // For mStudio, volume definitions must be empty objects, null is apparently
+    // not allowed.
+    for (const volumeKey of Object.keys(sanitized.volumes ?? {})) {
+        if (sanitized.volumes[volumeKey] === null) {
+            sanitized.volumes[volumeKey] = { name: volumeKey };
+        }
+    }
+    return sanitized;
+}

package/dist/lib/resources/stack/types.d.ts

@@ -0,0 +1,12 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type ContainerServiceDeclareRequest = MittwaldAPIV2.Components.Schemas.ContainerServiceDeclareRequest;
+export type ContainerServiceInput = ContainerServiceDeclareRequest & {
+    command?: string[] | string;
+    entrypoint?: string[] | string;
+    env_file?: string;
+    environment?: {
+        [k: string]: string;
+    };
+    ports?: string[];
+};
+export {};

package/dist/lib/resources/stack/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/util/pager.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints the given content to a pager, such as `less`. This function respects
+ * the `PAGER` environment variable.
+ *
+ * @param content
+ */
+export declare function printToPager(content: string): void;

package/dist/lib/util/pager.js

@@ -0,0 +1,21 @@
+import tempfile from "tempfile";
+import fs from "fs";
+import cp from "child_process";
+/**
+ * Prints the given content to a pager, such as `less`. This function respects
+ * the `PAGER` environment variable.
+ *
+ * @param content
+ */
+export function printToPager(content) {
+    const t = tempfile();
+    try {
+        fs.writeFileSync(t, content, { encoding: "utf8" });
+        cp.spawnSync(process.env.PAGER || "less", [t], {
+            stdio: "inherit",
+        });
+    }
+    finally {
+        fs.unlinkSync(t);
+    }
+}

package/dist/rendering/process/process.d.ts

@@ -54,7 +54,7 @@ export declare class RunnableHandler {
 export interface ProcessRenderer {
     start(): void;
     addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    runStep<TRes>(title: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
     addInfo(title: ReactNode): void;
     addConfirmation(question: ReactNode): Promise<boolean>;
     addInput(question: ReactNode, mask?: boolean): Promise<string>;

package/dist/rendering/process/process_fancy.d.ts

@@ -8,7 +8,7 @@ export declare class FancyProcessRenderer implements ProcessRenderer {
     constructor(title: string);
     start(): void;
     addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    runStep<TRes>(title: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
     addInfo(title: ReactNode): void;
     addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
     addSelect<TVal>(question: React.ReactNode, options: {

package/dist/rendering/process/process_fancy.js

@@ -40,7 +40,8 @@ export class FancyProcessRenderer {
     async runStep(title, fn) {
         const step = this.addStep(title);
         try {
-            const result = await fn();
+            const promise = typeof fn === "function" ? fn() : fn;
+            const result = await promise;
             step.complete();
             return result;
         }

package/dist/rendering/process/process_flags.js

@@ -4,7 +4,7 @@ import { SilentProcessRenderer } from "./process_quiet.js";
 export const processFlags = {
     quiet: Flags.boolean({
         char: "q",
-        summary: "suppress process output and only display a machine-readable summary.",
+        summary: "suppress process output and only display a machine-readable summary",
         description: "This flag controls if you want to see the process output or only a summary. When using <%= config.bin %> non-interactively (e.g. in scripts), you can use this flag to easily get the IDs of created resources for further processing.",
     }),
 };

package/dist/rendering/process/process_quiet.d.ts

@@ -4,7 +4,7 @@ export declare class SilentProcessRenderer implements ProcessRenderer {
     private cleanupFns;
     start(): void;
     addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(unusedTitle: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    runStep<TRes>(unusedTitle: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
     addInfo(): void;
     complete(): Promise<void>;
     error(err: unknown): Promise<void>;

package/dist/rendering/process/process_quiet.js

@@ -11,6 +11,9 @@ export class SilentProcessRenderer {
         });
     }
     runStep(unusedTitle, fn) {
+        if (fn instanceof Promise) {
+            return fn;
+        }
         return fn();
     }
     addInfo() {