@mittwald/cli 1.0.0-alpha.9 → 1.0.0-beta.2

package/dist/rendering/formatter/smartPad.js

@@ -0,0 +1,8 @@
+import stringWidth from "string-width";
+export default function smartPad(str, length) {
+    const underlength = length - stringWidth(str);
+    if (underlength <= 0) {
+        return str;
+    }
+    return str + " ".repeat(underlength);
+}

package/dist/rendering/formatter/smartPadOrTruncate.d.ts

@@ -0,0 +1 @@
+export default function smartPadOrTruncate(str: string, length: number): string;

package/dist/rendering/formatter/smartPadOrTruncate.js

@@ -0,0 +1,5 @@
+import smartTruncate from "./smartTruncate.js";
+import smartPad from "./smartPad.js";
+export default function smartPadOrTruncate(str, length) {
+    return smartTruncate(smartPad(str, length), length);
+}

package/dist/rendering/formatter/smartTruncate.d.ts

@@ -0,0 +1 @@
+export default function smartTruncate(str: string, length: number): string;

package/dist/rendering/formatter/smartTruncate.js

@@ -0,0 +1,9 @@
+import stringWidth from "string-width";
+import sliceAnsi from "slice-ansi";
+export default function smartTruncate(str, length) {
+    const overlength = stringWidth(str) - length;
+    if (overlength <= 0) {
+        return str;
+    }
+    return sliceAnsi(str, 0, length - 1) + "…";
+}

package/dist/rendering/formatter/smartTruncate.test.d.ts

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

package/dist/rendering/formatter/smartTruncate.test.js

@@ -0,0 +1,13 @@
+import smartTruncate from "./smartTruncate.js";
+import { expect, describe, it } from "@jest/globals";
+describe("smartTruncate", () => {
+    it("leaves short strings as is", () => {
+        expect(smartTruncate("short string", 100)).toBe("short string");
+    });
+    it("truncates long strings", () => {
+        expect(smartTruncate("1234567890", 5)).toBe("1234…");
+    });
+    it("truncates long strings with ANSI escape codes", () => {
+        expect(smartTruncate("\u001b[33m1234567890\u001b[0m", 5)).toBe("\u001b[33m1234\u001b[39m…");
+    });
+});

package/dist/rendering/lib/getTerminalWidth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the width of the terminal, if available.
+ *
+ * @returns The with of the terminal in characters; undefined if process is not
+ *   attached to a TTY
+ */
+export declare function getTerminalWidth(): number | undefined;

package/dist/rendering/lib/getTerminalWidth.js

@@ -0,0 +1,9 @@
+/**
+ * Get the width of the terminal, if available.
+ *
+ * @returns The with of the terminal in characters; undefined if process is not
+ *   attached to a TTY
+ */
+export function getTerminalWidth() {
+    return process.stdout.isTTY ? process.stdout.getWindowSize()[0] : undefined;
+}

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

@@ -0,0 +1 @@
+export declare const InteractiveInputDisabled: () => import("react/jsx-runtime").JSX.Element;

package/dist/rendering/process/components/InteractiveInputDisabled.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export 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." }));

package/dist/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: (_: boolean) => void;
+}>;

package/dist/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/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/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/rendering/process/components/ProcessError.d.ts

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

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

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isValidationError } from "../../../lib/error/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/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: (_: string) => void;
+}>;

package/dist/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";
+import { InteractiveInputDisabled } from "./InteractiveInputDisabled.js";
+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(Text, { color: "blue", children: _jsx(TextInput, { mask: step.mask ? "*" : undefined, value: value, onChange: setValue, onSubmit: onSubmit }) })) : (_jsx(InteractiveInputDisabled, {}))] }) }));
+    }
+    return _jsx(ProcessState, { step: step });
+};

package/dist/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/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/rendering/process/components/ProcessSelect.d.ts

@@ -0,0 +1,6 @@
+import { ProcessStepSelect } from "../process.js";
+export declare function ProcessSelect<TVal>({ step, onSubmit, onError, }: {
+    step: ProcessStepSelect<TVal>;
+    onSubmit: (_: TVal) => void;
+    onError?: (err: unknown) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/rendering/process/components/ProcessSelect.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { ProcessStateIcon } from "./ProcessStateIcon.js";
+import { ProcessState } from "./ProcessState.js";
+import { Box, Text, useInput, useStdin } from "ink";
+import { InteractiveInputDisabled } from "./InteractiveInputDisabled.js";
+import InteractiveInputRequiredError from "../../../lib/error/InteractiveInputRequiredError.js";
+function useSelectControls(initial, length, onSelect) {
+    const { isRawModeSupported } = useStdin();
+    const [value, setValue] = useState(initial);
+    const [extraUsageHint, setExtraUsageHint] = useState(false);
+    if (!isRawModeSupported) {
+        return {
+            value: undefined,
+            extraUsageHint: false,
+        };
+    }
+    useInput((_, key) => {
+        if (key.return) {
+            if (value !== undefined) {
+                setValue(value);
+                onSelect(value);
+            }
+            else {
+                setExtraUsageHint(true);
+            }
+        }
+        else if (key.downArrow) {
+            setExtraUsageHint(false);
+            setValue((prev) => prev === undefined ? 0 : Math.min(length - 1, prev + 1));
+        }
+        else if (key.upArrow) {
+            setExtraUsageHint(false);
+            setValue((prev) => (prev === undefined ? 0 : Math.max(prev - 1, 0)));
+        }
+    });
+    return {
+        value,
+        extraUsageHint,
+    };
+}
+export function ProcessSelect({ step, onSubmit, onError, }) {
+    const { value, extraUsageHint } = useSelectControls(Math.max(step.options.findIndex((o) => o.value === step.selected), 0), step.options.length, (idx) => onSubmit(step.options[idx].value));
+    const { isRawModeSupported } = useStdin();
+    if (step.selected === undefined) {
+        if (!isRawModeSupported) {
+            useEffect(() => {
+                if (onError) {
+                    onError(new InteractiveInputRequiredError());
+                }
+            });
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsxs(Text, { children: [step.title, ": "] })] }), _jsx(Box, { marginX: 8, children: _jsx(InteractiveInputDisabled, {}) })] }));
+        }
+        return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsxs(Text, { children: [step.title, ": "] })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(SelectUsageHint, { extraHint: extraUsageHint }), step.options.map((option, index) => (_jsx(SelectOption, { selected: index === value, label: option.label }, index)))] })] }));
+    }
+    return _jsx(ProcessState, { step: step });
+}
+function SelectUsageHint({ extraHint }) {
+    return (_jsx(Box, { marginLeft: 4, children: _jsx(Text, { color: extraHint ? "red" : "gray", bold: extraHint, children: "(use the up and down keys to select an option)" }) }));
+}
+function SelectOption({ selected, label, }) {
+    return (_jsx(Box, { marginLeft: 4, children: _jsxs(Text, { color: "blue", children: [selected ? "👉︎ " : "   ", label] }) }));
+}

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

@@ -0,0 +1,4 @@
+import { ProcessStepSelect } from "../process.js";
+export declare function ProcessSelectStateSummary<TVal>({ step, }: {
+    step: ProcessStepSelect<TVal>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/rendering/process/components/ProcessSelectStateSummary.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+export function ProcessSelectStateSummary({ step, }) {
+    if (step.selected) {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: ": " }), _jsx(Text, { color: "green", children: step.options.find((o) => o.value === step.selected)?.label })] }));
+    }
+    else {
+        return _jsx(Text, { children: ": " });
+    }
+}

package/dist/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/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.output ? (_jsx(Box, { marginX: 6, children: _jsx(Text, { color: "gray", children: step.output.split("\n").slice(-10).join("\n") }) })) : null, step.type === "step" && step.error ? (_jsx(ProcessError, { err: step.error })) : null] }));
+};

package/dist/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/rendering/process/components/ProcessStateIcon.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProcessStateIcon = ({ step }) => {
+    if (step.type === "info") {
+        return _jsx(Text, { children: "\uD83D\uDCA1 " });
+    }
+    else if (step.type === "confirm" ||
+        step.type === "input" ||
+        step.type === "select") {
+        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/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/rendering/process/components/ProcessStateSummary.js

@@ -0,0 +1,34 @@
+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";
+import { ProcessSelectStateSummary } from "./ProcessSelectStateSummary.js";
+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.type === "select") {
+        return _jsx(ProcessSelectStateSummary, { 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 {
+        if (step.progress) {
+            return (_jsxs(_Fragment, { children: [_jsx(Text, { children: "... " }), _jsx(Text, { color: "blue", children: step.progress })] }));
+        }
+        return _jsx(Text, { children: "..." });
+    }
+};

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

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

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

@@ -0,0 +1,17 @@
+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) => {
+        return (_jsxs(Box, { flexDirection: "row", children: [e.path && (_jsx(Box, { minWidth: e.path + 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/rendering/process/process.d.ts

@@ -0,0 +1,68 @@
+import { ReactElement, ReactNode } from "react";
+export type ProcessStepInfo = {
+    type: "info";
+    title: ReactNode;
+};
+export type ProcessStepRunnable = {
+    type: "step";
+    title: ReactNode;
+    phase: "running" | "completed" | "failed" | "aborted";
+    error?: unknown;
+    progress?: string;
+    output?: string;
+};
+export type ProcessStepConfirm = {
+    type: "confirm";
+    title: ReactNode;
+    confirmed: boolean | undefined;
+};
+export type ProcessStepInput = {
+    type: "input";
+    title: ReactNode;
+    mask?: boolean;
+    value?: string;
+};
+export type ProcessStepSelect<TVal> = {
+    type: "select";
+    title: ReactNode;
+    options: {
+        value: TVal;
+        label: ReactNode;
+    }[];
+    selected?: TVal;
+};
+export type ProcessStep = ProcessStepInfo | ProcessStepRunnable | ProcessStepConfirm | ProcessStepInput | ProcessStepSelect<unknown>;
+export type CleanupFunction = {
+    title: ReactNode;
+    fn: () => Promise<unknown>;
+};
+export declare class RunnableHandler {
+    private readonly listener;
+    private readonly processStep;
+    private readonly promise;
+    private resolve;
+    private reject;
+    constructor(state: ProcessStepRunnable, l: () => void);
+    get done(): boolean;
+    wait(): Promise<void>;
+    abort(): void;
+    complete(): void;
+    progress(p: string): void;
+    appendOutput(o: string): void;
+    error(err: unknown): void;
+}
+export interface ProcessRenderer {
+    start(): void;
+    addStep(title: ReactNode): RunnableHandler;
+    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    addInfo(title: ReactNode): void;
+    addConfirmation(question: ReactNode): Promise<boolean>;
+    addInput(question: ReactNode, mask?: boolean): Promise<string>;
+    addSelect<TVal>(question: ReactNode, options: {
+        value: TVal;
+        label: ReactNode;
+    }[]): Promise<TVal>;
+    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    complete(summary: ReactElement): Promise<void>;
+    error(err: unknown): Promise<void>;
+}

package/dist/rendering/process/process.js

@@ -0,0 +1,49 @@
+export class RunnableHandler {
+    listener;
+    processStep;
+    promise;
+    resolve = () => { };
+    reject = () => { };
+    constructor(state, l) {
+        this.processStep = state;
+        this.listener = l;
+        this.promise = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+        this.promise.catch(() => { });
+    }
+    get done() {
+        return this.processStep.phase !== "running";
+    }
+    wait() {
+        return this.promise;
+    }
+    abort() {
+        this.processStep.phase = "aborted";
+        this.listener();
+        this.resolve();
+    }
+    complete() {
+        this.processStep.phase = "completed";
+        this.listener();
+        this.resolve();
+    }
+    progress(p) {
+        this.processStep.progress = p;
+        this.listener();
+    }
+    appendOutput(o) {
+        if (this.processStep.output === undefined) {
+            this.processStep.output = "";
+        }
+        this.processStep.output += o;
+        this.listener();
+    }
+    error(err) {
+        this.processStep.phase = "failed";
+        this.processStep.error = err;
+        this.listener();
+        this.reject(err);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { ProcessRenderer } from "./process.js";
+import { ReactNode } from "react";
+export declare function spawnInProcess(r: ProcessRenderer, title: ReactNode, cmd: string, args: string[]): Promise<void>;

package/dist/rendering/process/process_exec.js

@@ -0,0 +1,30 @@
+import { spawn } from "child_process";
+import debug from "debug";
+const d = debug("mw:exec");
+export async function spawnInProcess(r, title, cmd, args) {
+    const step = r.addStep(title);
+    d("spawning %o with args %o", cmd, args);
+    const child = spawn(cmd, args, {
+        shell: false,
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    const appendOutput = (chunk) => {
+        if (typeof chunk === "string") {
+            step.appendOutput(chunk);
+        }
+        if (Buffer.isBuffer(chunk)) {
+            step.appendOutput(chunk.toString());
+        }
+    };
+    child.stdout.on("data", appendOutput);
+    child.stderr.on("data", appendOutput);
+    child.on("exit", (code) => {
+        if (code === 0) {
+            step.complete();
+        }
+        else {
+            step.error(new Error(`${cmd} exited with code ${code}`));
+        }
+    });
+    await step.wait();
+}

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

@@ -0,0 +1,24 @@
+import React, { ReactElement, ReactNode } from "react";
+import { ProcessRenderer, RunnableHandler } from "./process.js";
+export declare class FancyProcessRenderer implements ProcessRenderer {
+    private readonly title;
+    private started;
+    private currentHandler;
+    private cleanupFns;
+    constructor(title: string);
+    start(): void;
+    addStep(title: ReactNode): RunnableHandler;
+    runStep<TRes>(title: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
+    addInfo(title: ReactNode): void;
+    addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
+    addSelect<TVal>(question: React.ReactNode, options: {
+        value: TVal;
+        label: React.ReactNode;
+    }[]): Promise<TVal>;
+    addConfirmation(question: ReactElement): Promise<boolean>;
+    complete(summary: ReactElement): Promise<void>;
+    error(err: unknown): Promise<void>;
+    private renderStart;
+    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    private cleanup;
+}