@mittwald/cli 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { makeProcessRenderer } from "../../rendering/process/process_flags.js";
+import { withProjectId } from "../project/flags.js";
+import { autofillFlags, provideSupportedFlags, } from "./flags.js";
+import { normalizeToAppVersionUuid } from "./versions.js";
+import { triggerAppInstallation } from "./install.js";
+import { waitUntilAppIsInstalled } from "./wait.js";
+import { Success } from "../../rendering/react/components/Success.js";
+export class AppInstaller {
+    appId;
+    appName;
+    appSupportedFlags;
+    description;
+    static makeDescription(appName) {
+        return `Creates new ${appName} installation.`;
+    }
+    constructor(appId, appName, appSupportedFlags) {
+        this.appId = appId;
+        this.appName = appName;
+        this.appSupportedFlags = appSupportedFlags;
+        this.description = AppInstaller.makeDescription(appName);
+    }
+    get flags() {
+        return provideSupportedFlags(this.appSupportedFlags, this.appName);
+    }
+    async exec(apiClient, args, flags, config) {
+        const process = makeProcessRenderer(flags, `Installing ${this.appName}`);
+        const projectId = await withProjectId(apiClient, "flag", flags, args, config);
+        await autofillFlags(apiClient, process, this.appSupportedFlags, flags, projectId, this.appName);
+        const appVersion = await normalizeToAppVersionUuid(apiClient, "version" in flags ? flags.version : "latest", process, this.appId);
+        const [appInstallationId, eventId] = await triggerAppInstallation(apiClient, process, projectId, flags, appVersion);
+        let successText;
+        if (flags.wait) {
+            await waitUntilAppIsInstalled(apiClient, process, appInstallationId, eventId);
+            successText = `Your ${this.appName} installation is now complete. Have fun! 🎉`;
+        }
+        else {
+            successText = `Your ${this.appName} installation has started. Have fun when it's ready! 🎉`;
+        }
+        process.complete(_jsx(Success, { children: successText }));
+        return { appInstallationId };
+    }
+    render(result, flags) {
+        if (flags.quiet) {
+            return result.appInstallationId;
+        }
+        return undefined;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import { ProcessFlags } from "../../rendering/process/process_flags.js";
+import { BooleanFlag, FlagInput, OptionFlag, OutputFlags } from "@oclif/core/lib/interfaces/parser.js";
+export declare const appInstallationFlags: import("../context_flags.js").ContextFlags<"project" | "installation", "project-id" | "installation-id">, appInstallationArgs: import("../context_flags.js").ContextArgs<"project" | "installation", "project-id" | "installation-id">, withAppInstallationId: (apiClient: MittwaldAPIV2Client, command: "flag" | "arg" | import("../context_flags.js").CommandType<"project" | "installation", "project-id" | "installation-id">, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;
+export declare function normalizeAppInstallationId(apiClient: MittwaldAPIV2Client, projectId: string, id: string): Promise<string>;
+export type AvailableFlagName = keyof AvailableFlags;
+interface AvailableFlags {
+    version: OptionFlag<string>;
+    host: OptionFlag<string | undefined>;
+    "admin-user": OptionFlag<string | undefined>;
+    "admin-email": OptionFlag<string | undefined>;
+    "admin-pass": OptionFlag<string | undefined>;
+    "admin-firstname": OptionFlag<string | undefined>;
+    "admin-lastname": OptionFlag<string | undefined>;
+    "site-title": OptionFlag<string | undefined>;
+    "shop-email": OptionFlag<string | undefined>;
+    "shop-lang": OptionFlag<string | undefined>;
+    "shop-currency": OptionFlag<string | undefined>;
+    "install-mode": OptionFlag<string>;
+    "document-root": OptionFlag<string>;
+    wait: BooleanFlag<boolean | undefined>;
+}
+export type RelevantFlags<TFlags extends readonly AvailableFlagName[]> = ProcessFlags & Pick<AvailableFlags, TFlags[number]>;
+export type RelevantFlagInput<TFlags extends readonly AvailableFlagName[]> = FlagInput<RelevantFlags<TFlags>>;
+export declare function provideSupportedFlags<TFlagNames extends readonly AvailableFlagName[]>(requestedFlagNames: TFlagNames, appName: string): RelevantFlagInput<TFlagNames>;
+export declare function autofillFlags(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, necessaryFlags: readonly AvailableFlagName[], flags: Partial<OutputFlags<RelevantFlagInput<AvailableFlagName[]>>>, projectId: string, appName: string): Promise<void>;
+export {};

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

@@ -0,0 +1,212 @@
+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 { makeProjectFlagSet, projectFlags } from "../project/flags.js";
+import { processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { generatePasswordWithSpecialChars } from "../password.js";
+import { isUuid } from "../../Helpers.js";
+export const { flags: appInstallationFlags, args: appInstallationArgs, withId: withAppInstallationId, } = makeProjectFlagSet("installation", "i", {
+    displayName: "app installation",
+    normalize: normalizeAppInstallationId,
+    supportsContext: true,
+});
+export async function normalizeAppInstallationId(apiClient, projectId, id) {
+    if (isUuid(id)) {
+        return id;
+    }
+    const appInstallations = await apiClient.app.listAppinstallations({
+        projectId,
+    });
+    assertStatus(appInstallations, 200);
+    return appInstallations.data.find((inst) => inst.shortId === id)?.id ?? id;
+}
+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",
+        }),
+        "document-root": Flags.string({
+            required: true,
+            summary: `The document root from which your ${appName} will be served (relative to the installation path)`,
+            description: "This is the document root from which the files of your application will be served by the web server. This directory is specified relative to the installation path.",
+            default: "/",
+        }),
+        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/hooks.d.ts

@@ -0,0 +1,11 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import AppSystemSoftware = MittwaldAPIV2.Components.Schemas.AppSystemSoftware;
+import AppSystemSoftwareVersion = MittwaldAPIV2.Components.Schemas.AppSystemSoftwareVersion;
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+import AppApp = MittwaldAPIV2.Components.Schemas.AppApp;
+import AppAppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+export declare function useApp(appId: string): AppApp;
+export declare function useAppInstallation(appInstallationId: string): AppAppInstallation;
+export declare function useAppVersion(appId: string, appVersionId: string): AppAppVersion;
+export declare function useSystemSoftware(systemSoftwareId: string): AppSystemSoftware;
+export declare function useSystemSoftwareVersion(systemSoftwareId: string, systemSoftwareVersionId: string): AppSystemSoftwareVersion;

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

@@ -0,0 +1,43 @@
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { useRenderContext } from "../../rendering/react/context.js";
+export function useApp(appId) {
+    const { apiClient } = useRenderContext();
+    const app = usePromise((id) => apiClient.app.getApp({ appId: id }), [appId]);
+    assertStatus(app, 200);
+    return app.data;
+}
+export function useAppInstallation(appInstallationId) {
+    const { apiClient } = useRenderContext();
+    const appInstallation = usePromise((id) => apiClient.app.getAppinstallation({
+        appInstallationId: id,
+    }), [appInstallationId]);
+    assertStatus(appInstallation, 200);
+    return appInstallation.data;
+}
+export function useAppVersion(appId, appVersionId) {
+    const { apiClient } = useRenderContext();
+    const appVersion = usePromise((appId, appVersionId) => apiClient.app.getAppversion({
+        appId,
+        appVersionId,
+    }), [appId, appVersionId]);
+    assertStatus(appVersion, 200);
+    return appVersion.data;
+}
+export function useSystemSoftware(systemSoftwareId) {
+    const { apiClient } = useRenderContext();
+    const systemSoftware = usePromise((id) => apiClient.app.getSystemsoftware({
+        systemSoftwareId: id,
+    }), [systemSoftwareId]);
+    assertStatus(systemSoftware, 200);
+    return systemSoftware.data;
+}
+export function useSystemSoftwareVersion(systemSoftwareId, systemSoftwareVersionId) {
+    const { apiClient } = useRenderContext();
+    const systemSoftwareVersion = usePromise((systemSoftwareId, systemSoftwareVersionId) => apiClient.app.getSystemsoftwareversion({
+        systemSoftwareId,
+        systemSoftwareVersionId,
+    }), [systemSoftwareId, systemSoftwareVersionId]);
+    assertStatus(systemSoftwareVersion, 200);
+    return systemSoftwareVersion.data;
+}

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,43 @@
+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({
+            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"]];
+    });
+    await process.runStep("waiting for installation to be retrievable", async () => {
+        for (let attempts = 0; attempts < 10; attempts++) {
+            const result = await apiClient.app.getAppinstallation({
+                appInstallationId,
+            });
+            if (result.status === 200) {
+                return result.data;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    });
+    if ("document-root" in flags && flags["document-root"] !== "/") {
+        await process.runStep("setting document root", async () => {
+            const result = await apiClient.app.patchAppinstallation({
+                appInstallationId,
+                headers: { "if-event-reached": eventId },
+                data: {
+                    customDocumentRoot: flags["document-root"],
+                },
+            });
+            assertStatus(result, 204);
+        });
+    }
+    return [appInstallationId, eventId];
+}

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

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getAppUuidFromAppName(apiClient: MittwaldAPIV2Client, softwareName: string): Promise<string>;
+export declare function getAppNameFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;
+export declare function getAppVersionFromUuid(apiClient: MittwaldAPIV2Client, appId: string, appVersionId: string): Promise<string>;

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

@@ -0,0 +1,44 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { isUuid } from "../../Helpers.js";
+// Get App UUID from App Name
+export async function getAppUuidFromAppName(apiClient, softwareName) {
+    const apps = await apiClient.app.listApps();
+    assertStatus(apps, 200);
+    const foundApp = apps.data.find((item) => {
+        return (item.name.toLowerCase().replace(/[!. ]/g, "") ===
+            softwareName.toLowerCase().replace(/[!. ]/g, ""));
+    });
+    if (foundApp) {
+        return foundApp.id;
+    }
+    throw new Error("Access Denied.");
+}
+// Get App Human readable Name from App UUID
+export async function getAppNameFromUuid(apiClient, uuid) {
+    if (!isUuid(uuid)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const apps = await apiClient.app.listApps();
+    assertStatus(apps, 200);
+    const foundApp = apps.data.find((item) => {
+        return item.id === uuid;
+    });
+    if (foundApp) {
+        return foundApp.name;
+    }
+    throw new Error("App not found.");
+}
+// Get App Human Readable Version from App Version
+export async function getAppVersionFromUuid(apiClient, appId, appVersionId) {
+    if (!isUuid(appId) && !isUuid(appVersionId)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const appVersion = await apiClient.app.getAppversion({
+        appId: appId,
+        appVersionId: appVersionId,
+    });
+    if (appVersion.data.externalVersion) {
+        return appVersion.data.externalVersion;
+    }
+    throw new Error("AppVersion not found.");
+}

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

@@ -0,0 +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/versions.js

@@ -0,0 +1,49 @@
+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({
+        appId,
+    });
+    assertStatus(versions, 200);
+    if (versions.data.length === 0) {
+        return undefined;
+    }
+    let latestVersion = "0.0.0";
+    for (const version of versions.data) {
+        if (gt(version.internalVersion, latestVersion)) {
+            latestVersion = version.internalVersion;
+        }
+    }
+    return versions.data.find((item) => item.internalVersion === latestVersion);
+}
+// App Version UUID from App Version irellevant if internal or external
+export async function getAppVersionUuidFromAppVersion(apiClient, appId, appVersion) {
+    const versions = await apiClient.app.listAppversions({
+        appId,
+    });
+    if (!appVersion) {
+        return getLatestAvailableAppVersionForApp(apiClient, appId);
+    }
+    assertStatus(versions, 200);
+    return versions.data.find((item) => item.internalVersion === appVersion ||
+        item.externalVersion === appVersion);
+}

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({
+            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/assert_success.d.ts

@@ -0,0 +1,3 @@
+import { Response } from "@mittwald/api-client-commons";
+export declare function assertSuccess<T extends Response>(response: T): void;
+export default assertSuccess;

package/dist/esm/lib/assert_success.js

@@ -0,0 +1,7 @@
+import { ApiClientError } from "@mittwald/api-client-commons";
+export function assertSuccess(response) {
+    if (response.status >= 300) {
+        throw ApiClientError.fromResponse(`Unexpected response status (expected <300, got: ${response.status})`, response);
+    }
+}
+export default assertSuccess;

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

@@ -0,0 +1 @@
+export declare function parseBytes(input: string): number;

package/dist/esm/lib/bytes.js

@@ -0,0 +1,16 @@
+export function parseBytes(input) {
+    const numeric = parseInt(input.replace(/[^0-9]/g, ""), 10);
+    if (`${numeric}` == input) {
+        return numeric;
+    }
+    if (input.toLowerCase().endsWith("gi")) {
+        return numeric * (1 << 30);
+    }
+    if (input.toLowerCase().endsWith("mi")) {
+        return numeric * (1 << 20);
+    }
+    if (input.toLowerCase().endsWith("ki")) {
+        return numeric * (1 << 10);
+    }
+    throw new Error("unsupported byte unit; supported are 'gi', 'mi', 'ki'");
+}

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

@@ -0,0 +1,37 @@
+import { Config } from "@oclif/core";
+export type ContextNames = "project" | "server" | "org" | "installation" | "domain" | "dnszone";
+export type ContextKey<N extends ContextNames = ContextNames> = `${N}-id`;
+export type ContextMap = Partial<Record<ContextKey, ContextValue>>;
+export type ContextMapUpdate = Partial<Record<ContextKey, string>>;
+export type ContextValueSource = {
+    type: string;
+    identifier: string;
+};
+export type ContextValue = {
+    value: string;
+    source: ContextValueSource;
+};
+export interface ContextProvider {
+    name: string;
+    getOverrides(): Promise<ContextMap>;
+}
+export interface WritableContextProvider extends ContextProvider {
+    update(data: ContextMapUpdate): Promise<void>;
+}
+export declare class Context {
+    private readonly contextData;
+    readonly providers: ContextProvider[];
+    constructor(config: Config);
+    private initializeContextData;
+    private persist;
+    private setContextValue;
+    getContextValue(key: ContextKey): Promise<ContextValue | undefined>;
+    setProjectId: (id: string) => Promise<void>;
+    setServerId: (id: string) => Promise<void>;
+    setOrgId: (id: string) => Promise<void>;
+    setAppInstallationId: (id: string) => Promise<void>;
+    projectId: () => Promise<ContextValue | undefined>;
+    serverId: () => Promise<ContextValue | undefined>;
+    orgId: () => Promise<ContextValue | undefined>;
+    appInstallationId: () => Promise<ContextValue | undefined>;
+}

package/dist/esm/lib/context.js

@@ -0,0 +1,49 @@
+import { TerraformContextProvider } from "./context_terraform.js";
+import { UserContextProvider } from "./context_user.js";
+function isWritable(p) {
+    return "update" in p;
+}
+export class Context {
+    contextData;
+    providers;
+    constructor(config) {
+        this.providers = [
+            new UserContextProvider(config),
+            new TerraformContextProvider(),
+        ];
+        this.contextData = this.initializeContextData();
+    }
+    async initializeContextData() {
+        const contextData = {};
+        for (const provider of this.providers) {
+            const overrides = await provider.getOverrides();
+            Object.assign(contextData, overrides);
+        }
+        return contextData;
+    }
+    async persist(data) {
+        for (const provider of this.providers) {
+            if (isWritable(provider)) {
+                await provider.update(data);
+            }
+        }
+    }
+    async setContextValue(key, value) {
+        return await this.persist({ [key]: value });
+    }
+    async getContextValue(key) {
+        const data = await this.contextData;
+        if (key in data) {
+            return data[key];
+        }
+        return undefined;
+    }
+    setProjectId = (id) => this.setContextValue("project-id", id);
+    setServerId = (id) => this.setContextValue("server-id", id);
+    setOrgId = (id) => this.setContextValue("org-id", id);
+    setAppInstallationId = (id) => this.setContextValue("installation-id", id);
+    projectId = () => this.getContextValue("project-id");
+    serverId = () => this.getContextValue("server-id");
+    orgId = () => this.getContextValue("org-id");
+    appInstallationId = () => this.getContextValue("installation-id");
+}