@mittwald/cli 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/esm/lib/database/mysql/connect.d.ts

@@ -0,0 +1,19 @@
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getConnectionDetailsWithPassword(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: {
+    "mysql-password": string | undefined;
+}): Promise<{
+    password: string;
+    hostname: string;
+    database: string;
+    user: string;
+    sshHost: string;
+    sshUser: string;
+}>;
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer): Promise<{
+    hostname: string;
+    database: string;
+    user: string;
+    sshHost: string;
+    sshUser: string;
+}>;

package/dist/esm/lib/database/mysql/connect.js

@@ -0,0 +1,50 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getProject, getUser } from "../common.js";
+export async function getConnectionDetailsWithPassword(apiClient, databaseId, p, flags) {
+    const password = await getPassword(p, flags);
+    return {
+        ...(await getConnectionDetails(apiClient, databaseId, p)),
+        password,
+    };
+}
+export async function getConnectionDetails(apiClient, databaseId, p) {
+    const database = await getDatabase(apiClient, p, databaseId);
+    const databaseUser = await getDatabaseUser(apiClient, p, databaseId);
+    const project = await getProject(apiClient, p, database);
+    const user = await getUser(apiClient, p);
+    return {
+        hostname: database.hostname,
+        database: database.name,
+        user: databaseUser.name,
+        sshHost: `ssh.${project.clusterID}.${project.clusterDomain}`,
+        sshUser: `${user.email}@${project.shortId}`,
+    };
+}
+async function getPassword(p, flags) {
+    if (flags["mysql-password"]) {
+        return flags["mysql-password"];
+    }
+    return await p.addInput("enter password for MySQL user", true);
+}
+async function getDatabase(apiClient, p, id) {
+    return await p.runStep("fetching database", async () => {
+        const r = await apiClient.database.getMysqlDatabase({
+            pathParameters: { id },
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}
+async function getDatabaseUser(apiClient, p, databaseId) {
+    return await p.runStep("fetching main user", async () => {
+        const r = await apiClient.database.listMysqlUsers({
+            pathParameters: { databaseId },
+        });
+        assertStatus(r, 200);
+        const mainUser = r.data.find((u) => u.mainUser);
+        if (!mainUser) {
+            throw new Error("No main user found");
+        }
+        return mainUser;
+    });
+}

package/dist/esm/lib/database/mysql/flags.d.ts

@@ -0,0 +1,10 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ArgOutput, FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+export declare const mysqlConnectionFlags: {
+    "mysql-password": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare const mysqlArgs: {
+    "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+};
+export declare function withMySQLId(apiClient: MittwaldAPIV2Client, flags: FlagOutput, args: ArgOutput, cfg: Config): Promise<string>;

package/dist/esm/lib/database/mysql/flags.js

@@ -0,0 +1,48 @@
+import { Args, Flags } from "@oclif/core";
+import { isUuid } from "../../../Helpers.js";
+import { withProjectId } from "../../project/flags.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+export const mysqlConnectionFlags = {
+    "mysql-password": Flags.string({
+        char: "p",
+        summary: "the password to use for the MySQL user (env: MYSQL_PWD)",
+        description: `\
+The password to use for the MySQL user. If not provided, the environment variable MYSQL_PWD will be used. If that is not set either, the command will interactively ask for the password.
+
+NOTE: This is a security risk, as the password will be visible in the process list of your system, and will be visible in your Shell history. It is recommended to use the environment variable instead.\
+      `,
+        required: false,
+        env: "MYSQL_PWD",
+    }),
+};
+export const mysqlArgs = {
+    "database-id": Args.string({
+        description: "The ID of the database (when a project context is set, you can also use the name)",
+        required: true,
+    }),
+};
+function getIdCandidate(flags, args) {
+    if (args["database-id"]) {
+        return args["database-id"];
+    }
+    if (flags["database-id"]) {
+        return flags["database-id"];
+    }
+    throw new Error("No ID given");
+}
+export async function withMySQLId(apiClient, flags, args, cfg) {
+    const candidate = getIdCandidate(flags, args);
+    if (isUuid(candidate)) {
+        return candidate;
+    }
+    const projectId = await withProjectId(apiClient, flags, args, cfg);
+    const databases = await apiClient.database.listMysqlDatabases({
+        pathParameters: { projectId },
+    });
+    assertStatus(databases, 200);
+    const database = databases.data.find((db) => db.name === candidate);
+    if (!database) {
+        throw new Error(`No database with name "${candidate}" found`);
+    }
+    return database.id;
+}

package/dist/esm/lib/database/redis/connect.d.ts

@@ -0,0 +1,8 @@
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer): Promise<{
+    hostname: string;
+    database: string;
+    sshHost: string;
+    sshUser: string;
+}>;

package/dist/esm/lib/database/redis/connect.js

@@ -0,0 +1,22 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getProject, getUser } from "../common.js";
+export async function getConnectionDetails(apiClient, databaseId, p) {
+    const database = await getDatabase(apiClient, p, databaseId);
+    const project = await getProject(apiClient, p, database);
+    const user = await getUser(apiClient, p);
+    return {
+        hostname: database.hostname,
+        database: database.name,
+        sshHost: `ssh.${project.clusterID}.${project.clusterDomain}`,
+        sshUser: `${user.email}@${project.shortId}`,
+    };
+}
+async function getDatabase(apiClient, p, id) {
+    return await p.runStep("fetching database", async () => {
+        const r = await apiClient.database.getRedisDatabase({
+            pathParameters: { id },
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}

package/dist/esm/lib/database/redis/flags.d.ts

@@ -0,0 +1,7 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ArgOutput, FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+export declare const redisArgs: {
+    "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+};
+export declare function withRedisId(apiClient: MittwaldAPIV2Client, flags: FlagOutput, args: ArgOutput, cfg: Config): Promise<string>;

package/dist/esm/lib/database/redis/flags.js

@@ -0,0 +1,35 @@
+import { Args } from "@oclif/core";
+import { isUuid } from "../../../Helpers.js";
+import { withProjectId } from "../../project/flags.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+export const redisArgs = {
+    "database-id": Args.string({
+        description: "The ID of the database (when a project context is set, you can also use the name)",
+        required: true,
+    }),
+};
+function getIdCandidate(flags, args) {
+    if (args["database-id"]) {
+        return args["database-id"];
+    }
+    if (flags["database-id"]) {
+        return flags["database-id"];
+    }
+    throw new Error("No ID given");
+}
+export async function withRedisId(apiClient, flags, args, cfg) {
+    const candidate = getIdCandidate(flags, args);
+    if (isUuid(candidate)) {
+        return candidate;
+    }
+    const projectId = await withProjectId(apiClient, flags, args, cfg);
+    const databases = await apiClient.database.listRedisDatabases({
+        pathParameters: { projectId },
+    });
+    assertStatus(databases, 200);
+    const database = databases.data.find((db) => db.name === candidate);
+    if (!database) {
+        throw new Error(`No database with name "${candidate}" found`);
+    }
+    return database.id;
+}

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

@@ -1,2 +1,3 @@
 import { makeFlagSet } from "../context_flags.js";
-export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = makeFlagSet("org", "o");
+import { normalizeCustomerIdToUuid } from "../../Helpers.js";
+export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = makeFlagSet("org", "o", normalizeCustomerIdToUuid);

package/dist/esm/rendering/process/components/ProcessConfirmation.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { ProcessStep } from "../process.js";
+export declare const ProcessConfirmation: React.FC<{
+    step: ProcessStep;
+    onConfirm: (confirmed: boolean) => void;
+}>;

package/dist/esm/rendering/process/components/ProcessConfirmation.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ProcessState } from "./ProcessState.js";
+import { useInput, useStdin } from "ink";
+export const ProcessConfirmation = ({ step, onConfirm }) => {
+    const { isRawModeSupported } = useStdin();
+    if (isRawModeSupported) {
+        useInput((input) => {
+            onConfirm(input === "y");
+        });
+    }
+    return _jsx(ProcessState, { step: step });
+};

package/dist/esm/rendering/process/components/ProcessConfirmationStateSummary.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ProcessStepConfirm } from "../process.js";
+export declare const ProcessConfirmationStateSummary: React.FC<{
+    step: ProcessStepConfirm;
+}>;

package/dist/esm/rendering/process/components/ProcessConfirmationStateSummary.js

@@ -0,0 +1,18 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text, useStdin } from "ink";
+const InteractiveConfirmationDisabled = () => (_jsxs(Text, { color: "red", children: [" ", "interactive input required; start this command with --force or --quiet to disable interactive prompts"] }));
+export const ProcessConfirmationStateSummary = ({ step }) => {
+    const { isRawModeSupported } = useStdin();
+    if (!isRawModeSupported) {
+        return _jsx(InteractiveConfirmationDisabled, {});
+    }
+    if (step.confirmed) {
+        return _jsx(Text, { color: "green", children: " confirmed" });
+    }
+    else if (step.confirmed === false) {
+        return _jsx(Text, { color: "yellow", children: " not confirmed" });
+    }
+    else {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": press " }), _jsx(Text, { color: "blue", children: "y" }), _jsx(Text, { children: " or " }), _jsx(Text, { color: "blue", children: "n" }), _jsxs(Text, { color: "gray", children: [" ", "(use the --force or --quiet flags to disable this prompt)"] })] }));
+    }
+};

package/dist/esm/rendering/process/components/ProcessError.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const ProcessError: React.FC<{
+    err: unknown;
+}>;

package/dist/esm/rendering/process/components/ProcessError.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isValidationError } from "../../../lib/handleError.js";
+import { ProcessValidationErrors } from "./ProcessValidationErrors.js";
+import { Box, Text } from "ink";
+export const ProcessError = ({ err }) => {
+    if (isValidationError(err)) {
+        return _jsx(ProcessValidationErrors, { err: err.response.data });
+    }
+    return (_jsxs(Box, { marginY: 1, marginX: 5, flexDirection: "column", children: [_jsx(Text, { color: "red", children: "An error occurred during this operation:" }), _jsx(Text, { color: "red", bold: true, children: err?.toString() })] }));
+};

package/dist/esm/rendering/process/components/ProcessInput.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { ProcessStepInput } from "../process.js";
+export declare const ProcessInput: React.FC<{
+    step: ProcessStepInput;
+    onSubmit: (value: string) => void;
+}>;

package/dist/esm/rendering/process/components/ProcessInput.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { ProcessStateIcon } from "./ProcessStateIcon.js";
+import { ProcessState } from "./ProcessState.js";
+import { Box, Text, useStdin } from "ink";
+import TextInput from "ink-text-input";
+const InteractiveInputDisabled = () => (_jsx(Text, { color: "red", children: "interactive input required; inspect this command's --help page to learn how to pass the required input non-interactively." }));
+export const ProcessInput = ({ step, onSubmit }) => {
+    const [value, setValue] = useState("");
+    if (!step.value) {
+        const { isRawModeSupported } = useStdin();
+        return (_jsx(_Fragment, { children: _jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsxs(Text, { children: [step.title, ": "] }), isRawModeSupported ? (_jsx(TextInput, { mask: step.mask ? "*" : undefined, value: value, onChange: setValue, onSubmit: onSubmit })) : (_jsx(InteractiveInputDisabled, {}))] }) }));
+    }
+    return _jsx(ProcessState, { step: step });
+};

package/dist/esm/rendering/process/components/ProcessInputStateSummary.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ProcessStepInput } from "../process.js";
+export declare const ProcessInputStateSummary: React.FC<{
+    step: ProcessStepInput;
+}>;

package/dist/esm/rendering/process/components/ProcessInputStateSummary.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProcessInputStateSummary = ({ step }) => {
+    if (step.value && step.mask) {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": " }), _jsx(Text, { color: "blue", children: "[secret]" })] }));
+    }
+    if (step.value) {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": " }), _jsx(Text, { color: "green", children: step.value })] }));
+    }
+    else {
+        return _jsx(Text, { children: ": " });
+    }
+};

package/dist/esm/rendering/process/components/ProcessState.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ProcessStep } from "../process.js";
+export declare const ProcessState: React.FC<{
+    step: ProcessStep;
+}>;

package/dist/esm/rendering/process/components/ProcessState.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ProcessStateIcon } from "./ProcessStateIcon.js";
+import { ProcessStateSummary } from "./ProcessStateSummary.js";
+import { ProcessError } from "./ProcessError.js";
+import { Box, Text } from "ink";
+export const ProcessState = ({ step }) => {
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsx(Text, { children: step.title }), _jsx(ProcessStateSummary, { step: step })] }), step.type === "step" && step.error ? (_jsx(ProcessError, { err: step.error })) : null] }));
+};

package/dist/esm/rendering/process/components/ProcessStateIcon.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ProcessStep } from "../process.js";
+export declare const ProcessStateIcon: React.FC<{
+    step: ProcessStep;
+}>;

package/dist/esm/rendering/process/components/ProcessStateIcon.js

@@ -0,0 +1,22 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProcessStateIcon = ({ step }) => {
+    if (step.type === "info") {
+        return _jsxs(Text, { children: ["\u2139\uFE0F", "  "] });
+    }
+    else if (step.type === "confirm" || step.type === "input") {
+        return _jsx(Text, { children: "\u2753" });
+    }
+    else if (step.phase === "completed") {
+        return _jsx(Text, { children: "\u2705" });
+    }
+    else if (step.phase === "aborted") {
+        return _jsx(Text, { children: "\u23E9\uFE0F " });
+    }
+    else if (step.phase === "failed") {
+        return _jsx(Text, { children: "\u274C" });
+    }
+    else {
+        return _jsx(Text, { children: "\uD83D\uDD01 " });
+    }
+};

package/dist/esm/rendering/process/components/ProcessStateSummary.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { ProcessStep } from "../process.js";
+export declare const ProcessStateSummary: React.FC<{
+    step: ProcessStep;
+}>;

package/dist/esm/rendering/process/components/ProcessStateSummary.js

@@ -0,0 +1,27 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ProcessConfirmationStateSummary } from "./ProcessConfirmationStateSummary.js";
+import { ProcessInputStateSummary } from "./ProcessInputStateSummary.js";
+import { Text } from "ink";
+export const ProcessStateSummary = ({ step, }) => {
+    if (step.type === "info") {
+        return _jsx(_Fragment, {});
+    }
+    else if (step.type === "confirm") {
+        return _jsx(ProcessConfirmationStateSummary, { step: step });
+    }
+    else if (step.type === "input") {
+        return _jsx(ProcessInputStateSummary, { step: step });
+    }
+    else if (step.phase === "completed") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "green", children: "done" })] }));
+    }
+    else if (step.phase === "aborted") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "yellow", children: "cancelled" })] }));
+    }
+    else if (step.phase === "failed") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ". " }), _jsx(Text, { color: "red", children: "error" })] }));
+    }
+    else {
+        return _jsx(Text, { children: "..." });
+    }
+};

package/dist/esm/rendering/process/components/ProcessValidationErrors.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
+export declare const ProcessValidationErrors: React.FC<{
+    err: CommonsValidationErrors;
+    color?: string;
+}>;

package/dist/esm/rendering/process/components/ProcessValidationErrors.js

@@ -0,0 +1,15 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const boxProps = {
+    marginY: 1,
+    marginX: 5,
+    paddingX: 1,
+    borderColor: "color",
+    borderStyle: "round",
+    flexDirection: "column",
+    width: 80,
+};
+export const ProcessValidationErrors = ({ err, color = "red" }) => {
+    const errorItems = err.validationErrors.map((e, idx) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { minWidth: e.path.length + 2, children: _jsxs(Text, { color: color, bold: true, children: [e.path, ":", " "] }) }), _jsx(Text, { color: color, children: e.message })] }, idx)));
+    return (_jsxs(Box, { ...boxProps, children: [_jsx(Text, { color: color, children: "Your input contained invalid data:" }), _jsx(Box, { flexDirection: "column", marginY: 1, children: errorItems }), _jsx(Text, { color: color, children: "Please correct the errors and try again. Consult this command's help page (by invoking it with the --help flag) for more information." })] }));
+};

package/dist/esm/rendering/{react → process}/process.d.ts

@@ -1,22 +1,22 @@
 import { ReactElement, ReactNode } from "react";
 export type ProcessStepInfo = {
     type: "info";
-    title: ReactElement;
+    title: ReactNode;
 };
 export type ProcessStepRunnable = {
     type: "step";
-    title: ReactElement;
+    title: ReactNode;
     phase: "running" | "completed" | "failed" | "aborted";
     error?: unknown;
 };
 export type ProcessStepConfirm = {
     type: "confirm";
-    title: ReactElement;
+    title: ReactNode;
     confirmed: boolean | undefined;
 };
 export type ProcessStepInput = {
     type: "input";
-    title: ReactElement;
+    title: ReactNode;
     mask?: boolean;
     value?: string;
 };
@@ -36,7 +36,7 @@ export interface ProcessRenderer {
     runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
     addInfo(title: ReactElement): void;
     addConfirmation(question: ReactElement): Promise<boolean>;
-    addInput(question: ReactElement, mask?: boolean): Promise<string>;
+    addInput(question: ReactNode, mask?: boolean): Promise<string>;
     complete(summary: ReactElement): void;
     error(err: unknown): void;
 }

package/dist/esm/rendering/{react → process}/process_fancy.d.ts

@@ -1,5 +1,5 @@
 import React, { ReactElement, ReactNode } from "react";
-import { ProcessRenderer, ProcessStep, ProcessStepInput, RunnableHandler } from "./process.js";
+import { ProcessRenderer, RunnableHandler } from "./process.js";
 export declare class FancyProcessRenderer implements ProcessRenderer {
     private readonly title;
     private started;
@@ -15,14 +15,3 @@ export declare class FancyProcessRenderer implements ProcessRenderer {
     error(err: unknown): void;
     private renderStart;
 }
-export declare const ProcessState: React.FC<{
-    step: ProcessStep;
-}>;
-export declare const ProcessConfirmation: React.FC<{
-    step: ProcessStep;
-    onConfirm: (confirmed: boolean) => void;
-}>;
-export declare const ProcessInput: React.FC<{
-    step: ProcessStepInput;
-    onSubmit: (value: string) => void;
-}>;

package/dist/esm/rendering/process/process_fancy.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RunnableHandler } from "./process.js";
+import { Header } from "../react/components/Header.js";
+import { Box, render, Text } from "ink";
+import { ProcessState } from "./components/ProcessState.js";
+import { ProcessConfirmation } from "./components/ProcessConfirmation.js";
+import { ProcessInput } from "./components/ProcessInput.js";
+export class FancyProcessRenderer {
+    title;
+    started = false;
+    currentHandler = null;
+    constructor(title) {
+        this.title = title;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        render(this.renderStart(), {}).unmount();
+    }
+    addStep(title) {
+        this.start();
+        if (this.currentHandler !== null) {
+            this.currentHandler.abort();
+        }
+        const state = { type: "step", title, phase: "running" };
+        const renderHandle = render(_jsx(ProcessState, { step: state }));
+        this.currentHandler = new RunnableHandler(state, () => {
+            renderHandle.rerender(_jsx(ProcessState, { step: state }));
+            if (this.currentHandler?.done) {
+                this.currentHandler = null;
+                renderHandle.unmount();
+            }
+        });
+        return this.currentHandler;
+    }
+    async runStep(title, fn) {
+        const step = this.addStep(title);
+        try {
+            const result = await fn();
+            step.complete();
+            return result;
+        }
+        catch (err) {
+            step.error(err);
+            throw err;
+        }
+    }
+    addInfo(title) {
+        this.start();
+        if (this.currentHandler !== null) {
+            this.currentHandler.complete();
+        }
+        const state = { type: "info", title };
+        render(_jsx(ProcessState, { step: state })).unmount();
+    }
+    addInput(question, mask) {
+        this.start();
+        if (this.currentHandler !== null) {
+            this.currentHandler.complete();
+        }
+        const state = {
+            type: "input",
+            title: question,
+            mask,
+        };
+        return new Promise((res) => {
+            const onInput = (value) => {
+                res(value);
+                state.value = value;
+                if (renderHandle) {
+                    renderHandle.rerender(_jsx(ProcessInput, { step: state, onSubmit: onInput }));
+                    renderHandle.unmount();
+                }
+            };
+            const renderHandle = render(_jsx(ProcessInput, { step: state, onSubmit: onInput }));
+        });
+    }
+    addConfirmation(question) {
+        this.start();
+        if (this.currentHandler !== null) {
+            this.currentHandler.complete();
+        }
+        const state = {
+            type: "confirm",
+            title: question,
+            confirmed: undefined,
+        };
+        return new Promise((res) => {
+            const onConfirm = (confirmed) => {
+                res(confirmed);
+                state.confirmed = confirmed;
+                if (renderHandle) {
+                    renderHandle.rerender(_jsx(ProcessConfirmation, { step: state, onConfirm: onConfirm }));
+                    renderHandle.unmount();
+                }
+            };
+            const renderHandle = render(_jsx(ProcessConfirmation, { step: state, onConfirm: onConfirm }));
+        });
+    }
+    complete(summary) {
+        if (this.currentHandler) {
+            this.currentHandler.complete();
+        }
+        render(_jsx(Box, { marginY: 1, marginX: 2, children: summary })).unmount();
+    }
+    error(err) {
+        if (this.currentHandler) {
+            this.currentHandler.error(err);
+        }
+        else {
+            render(_jsx(Box, { marginY: 1, marginX: 2, borderStyle: "round", borderColor: "red", children: _jsxs(Text, { color: "red", children: ["Error: ", err?.toString()] }) })).unmount();
+        }
+    }
+    renderStart() {
+        return (_jsx(Box, { marginY: 1, marginX: 2, children: _jsx(Header, { title: this.title }) }));
+    }
+}

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

@@ -0,0 +1,20 @@
+import { ProcessRenderer } from "./process.js";
+import { InferredFlags } from "@oclif/core/lib/interfaces/index.js";
+export declare const processFlags: {
+    quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+};
+export type ProcessFlags = InferredFlags<typeof processFlags>;
+/**
+ * Create a ProcessRenderer based on the given flags. Currently, only two
+ * renderers are available:
+ *
+ * - `FancyProcessRenderer` for interactive output
+ * - `SilentProcessRenderer` for non-interactive output when the `quiet` flag is
+ *   set
+ *
+ * More renderers may be added in the future.
+ *
+ * @param flags
+ * @param title
+ */
+export declare const makeProcessRenderer: (flags: ProcessFlags, title: string) => ProcessRenderer;