@mittwald/cli 1.0.0-alpha.19 → 1.0.0-alpha.20

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

@@ -1,7 +1,196 @@
-import { Args } from "@oclif/core";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getDefaultIngressForProject } from "../project/ingress.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { getProjectShortIdFromUuid } from "../project/shortId.js";
+import { Text } from "ink";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { projectFlags } from "../project/flags.js";
+import { processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags, Args } from "@oclif/core";
+import { generatePasswordWithSpecialChars } from "../password.js";
 export const appInstallationFlags = {
     "installation-id": Args.string({
         description: "ID of the app installation to get",
         required: true,
     }),
 };
+function buildFlagsWithDescription(appName) {
+    return {
+        version: Flags.string({
+            required: true,
+            summary: `Version of ${appName} to be installed.`,
+            description: `Specify the Version in which your ${appName} will be installed. 
+      If none is given the ${appName} will be installed in the latest available version.`,
+            default: "latest",
+        }),
+        host: Flags.string({
+            required: false,
+            summary: `Host to initially configure your ${appName} installation with; needs to be created separately.`,
+            description: `Specify a host which will be used during the installation and as an initial host for the ${appName} configuration.
+      If not given the default host for the given Project will be used. 
+      This does not change the target of the used Host and can be changed later by configuring the Host and your ${appName} installation.`,
+        }),
+        "admin-user": Flags.string({
+            required: false,
+            summary: "Username for your administrator-user.",
+            description: `Username of the first administrator-user which will be created during the ${appName} installation. 
+      If not given an adequate username will be created from your mStudio Account Data.
+      After the installation is finished the Username can be changed and additional administrator-users can be created.`,
+        }),
+        "admin-email": Flags.string({
+            required: false,
+            summary: "E-Mail-Address of your administrator-user.",
+            description: `E-Mail-Address that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If not given your mStudio Account-E-Mail-Address will be used. This E-Mail-Address can be changed after the installation is finished.`,
+        }),
+        "admin-pass": Flags.string({
+            required: false,
+            summary: "Password of your administrator-user.",
+            description: `Password that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If not given a random secure Password will be generated and sent to stdout. This Password can be changed after the installation is finished`,
+        }),
+        "admin-firstname": Flags.string({
+            required: false,
+            summary: "Firstname of your administrator-user.",
+            description: `Firstname that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If none is given your mStudio Account-Firstname will be used. This Firstname can be changed after the installation is finished`,
+        }),
+        "admin-lastname": Flags.string({
+            required: false,
+            summary: "Lastname of your administrator-user.",
+            description: `Lastname that will correlate to the first administrator-user which will be created during the ${appName} installation.
+      If none is given your mStudio Account-Firstname will be used. This Lastname can be changed after the installation is finished`,
+        }),
+        "site-title": Flags.string({
+            required: false,
+            summary: `Site Title for your ${appName} installation.`,
+            description: `Site Title which will be displayed in the Tab and at the top of the Frontend of your ${appName} installation.
+      It is also the Title shown in the App-Overview in the mStudio.
+      If none is given the Software Name and the given Project will be used. The Title can be changed after the installation is finished`,
+        }),
+        "shop-email": Flags.string({
+            required: false,
+            summary: `E-Mail-Address your ${appName} will be working with.`,
+            description: `The E-Mail-Address your ${appName} shop will be using for correspondence..
+      If not given your mStudio Account-E-Mail-Address will be used. This E-Mail-Address can be changed after the installation is finished.`,
+        }),
+        "shop-lang": Flags.string({
+            required: false,
+            summary: `Language your ${appName} will be working with.`,
+            description: `The default Language your ${appName} shop will be using.
+      The Front- and Backend will be displayed using the given language.
+      If not given will default to German(de_DE). The language can be changed after the installation is finished.`,
+        }),
+        "shop-currency": Flags.string({
+            required: false,
+            summary: `Currency your ${appName} will be working with.`,
+            description: `The default Currency your ${appName} shop communicates prices and calculates transactions with.
+      If not given will default to EUR(€). The currency can be changed after the installation is finished.`,
+        }),
+        "install-mode": Flags.string({
+            required: true,
+            summary: `The installation variant your ${appName} will be installed with.`,
+            description: `${appName} can be installed in one of two different ways.  your ${appName} shop communicates prices and calculates transactions with.
+      Either as a composer project or in a more manual fashion using the source directory and the ${appName} console install wizard.
+      If not given will default to composer installation. This can not be changed later.`,
+            options: ["composer", "symlink"],
+            default: "composer",
+        }),
+        wait: Flags.boolean({
+            char: "w",
+            description: `Wait for your ${appName} to be ready.`,
+        }),
+    };
+}
+export function provideSupportedFlags(requestedFlagNames, appName) {
+    const availableFlags = buildFlagsWithDescription(appName);
+    const supportedFlags = requestedFlagNames.reduce((collector, currentValue) => {
+        return {
+            ...collector,
+            [currentValue]: availableFlags[currentValue],
+        };
+    }, {});
+    const flagsToReturn = {
+        ...projectFlags,
+        ...processFlags,
+        ...supportedFlags,
+        json: Flags.boolean({}),
+    };
+    return flagsToReturn;
+}
+export async function autofillFlags(apiClient, process, necessaryFlags, flags, projectId, appName) {
+    const ownUser = await apiClient.user.getOwnAccount();
+    assertStatus(ownUser, 200);
+    // Version
+    if (necessaryFlags.includes("version") && !flags.version) {
+        flags.version = "latest";
+    }
+    // Host
+    if (necessaryFlags.includes("host") && !flags.host) {
+        flags.host =
+            "https://" + (await getDefaultIngressForProject(apiClient, projectId));
+        process.addInfo(_jsxs(Text, { children: ["Using default Host ", _jsx(Value, { children: flags["host"] })] }));
+    }
+    // Title
+    if (necessaryFlags.includes("site-title") && !flags["site-title"]) {
+        flags["site-title"] =
+            appName + " " + (await getProjectShortIdFromUuid(apiClient, projectId));
+    }
+    // Admin User
+    if (necessaryFlags.includes("admin-user") && !flags["admin-user"]) {
+        if (ownUser.data.person) {
+            flags["admin-user"] =
+                ownUser.data.person.firstName.charAt(0).toLowerCase() +
+                    ownUser.data.person.lastName.toLowerCase();
+        }
+        else {
+            flags["admin-user"] = await getProjectShortIdFromUuid(apiClient, projectId);
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using generated Admin User: ", _jsx(Value, { children: flags["admin-user"] })] }));
+    }
+    // Admin Pass
+    if (necessaryFlags.includes("admin-pass") && !flags["admin-pass"]) {
+        flags["admin-pass"] = generatePasswordWithSpecialChars();
+        process.addInfo(_jsxs(Text, { children: ["Using generated random Admin Pass: ", _jsx(Value, { children: flags["admin-pass"] })] }));
+    }
+    // Admin Firstname
+    if (necessaryFlags.includes("admin-firstname") && !flags["admin-firstname"]) {
+        if (ownUser.data.person) {
+            flags["admin-firstname"] = ownUser.data.person.firstName;
+        }
+        else {
+            flags["admin-firstname"] = "Max";
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio firstname as Admin firstname (", _jsx(Value, { children: flags["admin-firstname"] }), ")"] }));
+    }
+    // Admin Lastname
+    if (necessaryFlags.includes("admin-lastname") && !flags["admin-lastname"]) {
+        if (ownUser.data.person) {
+            flags["admin-lastname"] = ownUser.data.person.lastName;
+        }
+        else {
+            flags["admin-lastname"] = "Mustermann";
+        }
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio lastname as Admin lastname (", _jsx(Value, { children: flags["admin-lastname"] }), ")"] }));
+    }
+    // Admin E-Mail
+    if (necessaryFlags.includes("admin-email") && !flags["admin-email"]) {
+        flags["admin-email"] = ownUser.data.email;
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Admin email (", _jsx(Value, { children: flags["admin-email"] }), ")"] }));
+    }
+    // Shop E-Mail
+    if (necessaryFlags.includes("shop-email") && !flags["shop-email"]) {
+        flags["shop-email"] = ownUser.data.email;
+        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Shop email (", _jsx(Value, { children: flags["shop-email"] }), ")"] }));
+    }
+    // Shop Language Code
+    if (necessaryFlags.includes("shop-lang") && !flags["shop-lang"]) {
+        flags["shop-lang"] = "de-DE";
+        process.addInfo(_jsx(Text, { children: "Using default shop language 'de_DE'." }));
+    }
+    // Shop Currency
+    if (necessaryFlags.includes("shop-currency") && !flags["shop-currency"]) {
+        flags["shop-currency"] = "EUR";
+        process.addInfo(_jsx(Text, { children: "Using default shop currency '\u20AC'." }));
+    }
+}

package/dist/esm/lib/app/install.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare function triggerAppInstallation(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, projectId: string, flags: Record<string, string>, appVersion: AppAppVersion): Promise<string[]>;

package/dist/esm/lib/app/install.js

@@ -0,0 +1,20 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function triggerAppInstallation(apiClient, process, projectId, flags, appVersion) {
+    const [appInstallationId, eventId] = await process.runStep("starting installation", async () => {
+        const result = await apiClient.app.requestAppinstallation({
+            pathParameters: { projectId },
+            data: {
+                appVersionId: appVersion.id,
+                description: flags["site-title"],
+                updatePolicy: "none",
+                userInputs: Object.keys(flags).map((k) => ({
+                    name: k.replace("-", "_"),
+                    value: flags[k],
+                })),
+            },
+        });
+        assertStatus(result, 201);
+        return [result.data.id, result.headers["etag"]];
+    });
+    return [appInstallationId, eventId];
+}

package/dist/esm/lib/app/{appVersionHelpers.d.ts → versions.d.ts}

@@ -1,5 +1,8 @@
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+import { ProcessRenderer } from "../../rendering/process/process.js";
 type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare function normalizeToAppVersionUuid(apiClient: MittwaldAPIV2Client, version: string, process: ProcessRenderer, appUuid: string): Promise<AppAppVersion>;
 export declare function getLatestAvailableAppVersionForApp(apiClient: MittwaldAPIV2Client, appId: string): Promise<AppVersion | undefined>;
 export declare function getAppVersionUuidFromAppVersion(apiClient: MittwaldAPIV2Client, appId: string, appVersion: string | undefined): Promise<AppVersion | undefined>;
 export {};

package/dist/esm/lib/app/{appVersionHelpers.js → versions.js}

@@ -1,5 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { gt } from "semver";
+import { Value } from "../../rendering/react/components/Value.js";
+import { Text } from "ink";
+import { getAppNameFromUuid } from "./uuid.js";
+export async function normalizeToAppVersionUuid(apiClient, version, process, appUuid) {
+    let appVersion;
+    if (version && version !== "latest") {
+        appVersion = await getAppVersionUuidFromAppVersion(apiClient, appUuid, version);
+    }
+    else {
+        appVersion = await getLatestAvailableAppVersionForApp(apiClient, appUuid);
+    }
+    if (!appVersion) {
+        throw new Error(`${await getAppNameFromUuid(apiClient, appUuid)} version ${version} does not seem to exist for the mStudio.`);
+    }
+    process.addInfo(_jsxs(Text, { children: ["installing version: ", _jsx(Value, { children: appVersion.externalVersion })] }));
+    return appVersion;
+}
 // Get latest available Internal App Version for App UUID
 export async function getLatestAvailableAppVersionForApp(apiClient, appId) {
     const versions = await apiClient.app.listAppversions({

package/dist/esm/lib/app/wait.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+export declare function waitUntilAppIsInstalled(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, appInstallationId: string, eventId: string): Promise<void>;

package/dist/esm/lib/app/wait.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { waitUntil } from "../wait.js";
+import { Text } from "ink";
+export async function waitUntilAppIsInstalled(apiClient, process, appInstallationId, eventId) {
+    const stepWaiting = process.addStep(_jsx(Text, { children: "waiting for app installation to be ready" }));
+    await waitUntil(async () => {
+        const installationResponse = await apiClient.app.getAppinstallation({
+            pathParameters: { appInstallationId },
+            // TODO: Remove once @mittwald/api-client supports this
+            headers: { "if-event-reached": eventId }, // eslint-disable-line
+        });
+        if (installationResponse.status === 200 &&
+            installationResponse.data.appVersion.current ==
+                installationResponse.data.appVersion.desired) {
+            return true;
+        }
+    });
+    stepWaiting.complete();
+}

package/dist/esm/lib/expires.d.ts

@@ -0,0 +1,11 @@
+export type ExpireFlags = {
+    expires: string;
+};
+export declare function expireFlags(resourceName: string): {
+    expires: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare function expireFlagsRequired(resourceName: string): {
+    expires: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare function expirationDateFromFlagsOptional(flags: Partial<ExpireFlags>): Date | undefined;
+export declare function expirationDateFromFlags(flags: ExpireFlags): Date;

package/dist/esm/lib/expires.js

@@ -0,0 +1,31 @@
+import { Flags } from "@oclif/core";
+import parseDuration from "parse-duration";
+export function expireFlags(resourceName) {
+    return {
+        expires: Flags.string({
+            description: `An interval after which the ${resourceName} expires (examples: 30m, 30d, 1y).`,
+        }),
+    };
+}
+export function expireFlagsRequired(resourceName) {
+    return {
+        expires: Flags.string({
+            description: `An interval after which the ${resourceName} expires (examples: 30m, 30d, 1y).`,
+            required: true,
+        }),
+    };
+}
+export function expirationDateFromFlagsOptional(flags) {
+    if (!flags.expires) {
+        return undefined;
+    }
+    return expirationDateFromFlags(flags);
+}
+export function expirationDateFromFlags(flags) {
+    const d = new Date();
+    const i = parseDuration(flags.expires);
+    if (!i) {
+        throw new Error("could not parse duration: " + flags.expires);
+    }
+    return new Date(d.getTime() + i);
+}

package/dist/esm/lib/password.d.ts

@@ -0,0 +1,2 @@
+export declare function generatePassword(length?: number): string;
+export declare function generatePasswordWithSpecialChars(length?: number, amountSpecialChars?: number): string;

package/dist/esm/lib/password.js

@@ -0,0 +1,20 @@
+import crypto from "crypto";
+const passwordAllowedSpecialChars = ["%", "_", "-", "+", "&"];
+const defaultPasswordLength = 32;
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - 1) + min);
+}
+function getRandomSpecialCharacter() {
+    return passwordAllowedSpecialChars[randomInt(0, passwordAllowedSpecialChars.length - 1)];
+}
+export function generatePassword(length = defaultPasswordLength) {
+    return crypto.randomBytes(length).toString("base64").substring(0, length);
+}
+export function generatePasswordWithSpecialChars(length = defaultPasswordLength, amountSpecialChars = Math.floor(length / 8)) {
+    const passwordCharacters = generatePassword(length).split("");
+    for (let i = 0; i < amountSpecialChars; i++) {
+        passwordCharacters[randomInt(1, passwordCharacters.length - 1)] =
+            getRandomSpecialCharacter();
+    }
+    return passwordCharacters.join("");
+}

package/dist/esm/lib/project/hooks.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import ProjectProject = MittwaldAPIV2.Components.Schemas.ProjectProject;
+export declare function useProject(projectId: string): ProjectProject;

package/dist/esm/lib/project/hooks.js

@@ -0,0 +1,11 @@
+import { useRenderContext } from "../../rendering/react/context.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+export function useProject(projectId) {
+    const { apiClient } = useRenderContext();
+    const project = usePromise((id) => apiClient.project.getProject({
+        pathParameters: { id },
+    }), [projectId]);
+    assertStatus(project, 200);
+    return project.data;
+}

package/dist/esm/lib/project/ingress.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getDefaultIngressForProject(apiClient: MittwaldAPIV2Client, projectId: string): Promise<string>;

package/dist/esm/lib/project/ingress.js

@@ -0,0 +1,16 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { normalizeProjectIdToUuid } from "../../Helpers.js";
+export async function getDefaultIngressForProject(apiClient, projectId) {
+    const projectUuid = await normalizeProjectIdToUuid(apiClient, projectId);
+    const projectIngresses = await apiClient.domain.ingressListForProject({
+        pathParameters: { projectId: projectUuid },
+    });
+    assertStatus(projectIngresses, 200);
+    const foundIngress = projectIngresses.data.find((item) => {
+        return item.isDefault === true;
+    });
+    if (foundIngress) {
+        return foundIngress.hostname;
+    }
+    throw new Error(`Given ID ${projectUuid} does not seem to be valid`);
+}

package/dist/esm/lib/project/shortId.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getProjectShortIdFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;

package/dist/esm/lib/project/shortId.js

@@ -0,0 +1,11 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function getProjectShortIdFromUuid(apiClient, uuid) {
+    const project = await apiClient.project.getProject({
+        pathParameters: { id: uuid },
+    });
+    assertStatus(project, 200);
+    if (project.data.shortId) {
+        return project.data.shortId;
+    }
+    throw new Error(`Given ID ${uuid} does not seem to be valid`);
+}

package/dist/esm/lib/projectbackup/hooks.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+import BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+export declare function useProjectBackup(projectBackupId: string): BackupProjectBackup;
+export declare function useProjectBackupSchedule(projectBackupScheduleId: string): BackupProjectBackupSchedule;

package/dist/esm/lib/projectbackup/hooks.js

@@ -0,0 +1,19 @@
+import { useRenderContext } from "../../rendering/react/context.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+export function useProjectBackup(projectBackupId) {
+    const { apiClient } = useRenderContext();
+    const projectBackup = usePromise((id) => apiClient.backup.getProjectBackup({
+        pathParameters: { projectBackupId: id },
+    }), [projectBackupId]);
+    assertStatus(projectBackup, 200);
+    return projectBackup.data;
+}
+export function useProjectBackupSchedule(projectBackupScheduleId) {
+    const { apiClient } = useRenderContext();
+    const projectBackupSchedule = usePromise((id) => apiClient.backup.getProjectBackupSchedule({
+        pathParameters: { projectBackupScheduleId: id },
+    }), [projectBackupScheduleId]);
+    assertStatus(projectBackupSchedule, 200);
+    return projectBackupSchedule.data;
+}

package/dist/esm/lib/viewhelpers/size.d.ts

@@ -1 +1,2 @@
-export declare function formatBytes(bytes?: number): string;
+import { Options } from "pretty-bytes";
+export declare function formatBytes(bytes?: number, opts?: Options): string;

package/dist/esm/lib/viewhelpers/size.js

@@ -1,4 +1,4 @@
 import prettyBytes from "pretty-bytes";
-export function formatBytes(bytes = 0) {
-    return prettyBytes(bytes, { binary: true });
+export function formatBytes(bytes = 0, opts = {}) {
+    return prettyBytes(bytes, { binary: true, ...opts });
 }

package/dist/esm/lib/wait.d.ts

@@ -1 +1,5 @@
+export declare const waitFlags: {
+    wait: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    "wait-timeout": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
 export declare function waitUntil<T>(tester: () => Promise<T | null>, timeoutSeconds?: number): Promise<T>;

package/dist/esm/lib/wait.js

@@ -1,6 +1,17 @@
-export async function waitUntil(tester, timeoutSeconds = 120) {
+import { Flags } from "@oclif/core";
+export const waitFlags = {
+    wait: Flags.boolean({
+        char: "w",
+        description: "Wait for the resource to be ready.",
+    }),
+    "wait-timeout": Flags.integer({
+        description: "The number of seconds to wait for the resource to be ready.",
+        default: 600,
+    }),
+};
+export async function waitUntil(tester, timeoutSeconds = 600) {
     let waited = 0;
-    while (waited < 120) {
+    while (waited < timeoutSeconds) {
         const result = await tester();
         if (result) {
             return result;

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

@@ -22,6 +22,9 @@ export const ProcessStateSummary = ({ step, }) => {
         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/esm/rendering/process/process.d.ts

@@ -8,6 +8,7 @@ export type ProcessStepRunnable = {
     title: ReactNode;
     phase: "running" | "completed" | "failed" | "aborted";
     error?: unknown;
+    progress?: string;
 };
 export type ProcessStepConfirm = {
     type: "confirm";
@@ -28,6 +29,7 @@ export declare class RunnableHandler {
     get done(): boolean;
     abort(): void;
     complete(): void;
+    progress(p: string): void;
     error(err: unknown): void;
 }
 export interface ProcessRenderer {

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

@@ -16,6 +16,10 @@ export class RunnableHandler {
         this.processStep.phase = "completed";
         this.listener();
     }
+    progress(p) {
+        this.processStep.progress = p;
+        this.listener();
+    }
     error(err) {
         this.processStep.phase = "failed";
         this.processStep.error = err;

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupDetails.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+export declare const ProjectBackupDetails: FC<{
+    projectBackup: BackupProjectBackup;
+}>;

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupDetails.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { SingleResult, SingleResultTable } from "../SingleResult.js";
+import { Text } from "ink";
+import { Value } from "../Value.js";
+import { useProjectBackupSchedule } from "../../../../lib/projectbackup/hooks.js";
+import { FormattedDate } from "../FormattedDate.js";
+import { ProjectBackupStatus } from "./ProjectBackupStatus.js";
+import { useProject } from "../../../../lib/project/hooks.js";
+import { IDAndShortID } from "../IDAndShortID.js";
+export const ProjectBackupDetails = ({ projectBackup }) => {
+    const project = useProject(projectBackup.projectId);
+    const schedule = projectBackup.parentId
+        ? useProjectBackupSchedule(projectBackup.parentId)
+        : undefined;
+    return (_jsx(SingleResult, { title: _jsxs(Text, { children: ["PROJECT BACKUP: ", _jsx(Value, { children: projectBackup.id })] }), rows: {
+            ID: _jsx(Value, { children: projectBackup.id }),
+            "Created at": projectBackup.createdAt ? (_jsx(Value, { children: _jsx(FormattedDate, { date: projectBackup.createdAt, relative: true, absolute: true }) })) : (_jsx(Value, { notSet: true })),
+            "Expires in": projectBackup.expiresAt ? (_jsx(Value, { children: _jsx(FormattedDate, { date: projectBackup.expiresAt, relative: true, absolute: true }) })) : (_jsx(Value, { notSet: true })),
+            Status: _jsx(ProjectBackupStatus, { projectBackup: projectBackup }),
+            Project: (_jsx(SingleResultTable, { rows: {
+                    ID: _jsx(IDAndShortID, { object: project }),
+                    Description: _jsx(Value, { children: project.description }),
+                } })),
+            Schedule: schedule ? (_jsx(SingleResultTable, { rows: {
+                    ID: _jsx(Value, { children: schedule.id }),
+                    Schedule: _jsx(Value, { children: schedule.schedule }),
+                } })) : (_jsx(Value, { notSet: true })),
+        } }));
+};

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupStatus.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+export declare const ProjectBackupStatus: FC<{
+    projectBackup: BackupProjectBackup;
+}>;

package/dist/esm/rendering/react/components/ProjectBackup/ProjectBackupStatus.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+export const ProjectBackupStatus = ({ projectBackup }) => {
+    if (projectBackup.status === "Completed") {
+        return _jsx(Text, { color: "green", children: "\u2705 completed" });
+    }
+    return _jsx(Text, { color: "yellow", children: projectBackup.status });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.0.0-alpha.19",
+  "version": "1.0.0-alpha.20",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {

package/dist/esm/commands/project/backupschedule/get.d.ts

@@ -1,3 +0,0 @@
-import { GeneratedBackupGetProjectBackupSchedule } from "../../../generated/backup/getProjectBackupSchedule.js";
-export default class Get extends GeneratedBackupGetProjectBackupSchedule {
-}

package/dist/esm/commands/project/backupschedule/get.js

@@ -1,6 +0,0 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedBackupGetProjectBackupSchedule } from "../../../generated/backup/getProjectBackupSchedule.js";
-export default class Get extends GeneratedBackupGetProjectBackupSchedule {
-}

package/dist/esm/generated/backup/getProjectBackup.d.ts

@@ -1,16 +0,0 @@
-import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
-import { GetBaseCommand } from "../../GetBaseCommand.js";
-export type PathParams = MittwaldAPIV2.Paths.V2ProjectBackupsProjectBackupId.Get.Parameters.Path;
-type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["backup"]["getProjectBackup"]>>;
-export declare abstract class GeneratedBackupGetProjectBackup extends GetBaseCommand<typeof GeneratedBackupGetProjectBackup, APIResponse> {
-    static description: string;
-    static flags: {
-        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
-    };
-    static args: {
-        projectBackupId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
-    };
-    protected getData(): Promise<APIResponse>;
-    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
-}
-export {};