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

package/dist/lib/ddev/config_builder.js

@@ -0,0 +1,138 @@
+import { assertStatus } from "@mittwald/api-client";
+import { determineProjectTypeFromAppInstallation } from "./init_projecttype.js";
+export class DDEVConfigBuilder {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async build(appInstallationId, databaseId, type) {
+        const appInstallation = await this.getAppInstallation(appInstallationId);
+        const systemSoftwares = await this.buildSystemSoftwareVersionMap(appInstallation);
+        type = await this.determineProjectType(appInstallation, type);
+        return {
+            type,
+            webserver_type: "apache-fpm",
+            php_version: this.determinePHPVersion(systemSoftwares),
+            database: await this.determineDatabaseVersion(databaseId),
+            docroot: await this.determineDocumentRoot(appInstallation),
+            web_environment: [
+                `MITTWALD_APP_INSTALLATION_ID=${appInstallation.shortId}`,
+                `MITTWALD_DATABASE_ID=${databaseId ?? ""}`,
+            ],
+            hooks: this.buildHooks(type),
+        };
+    }
+    buildHooks(type) {
+        const postPull = [
+            { "exec-host": "ddev config --project-name $DDEV_PROJECT" },
+            { "exec-host": "ddev restart" },
+        ];
+        if (type === "typo3") {
+            postPull.push({ exec: "typo3 cache:flush" }, { exec: "typo3 cache:warmup" });
+        }
+        if (type === "wordpress") {
+            postPull.push({ exec: "wp cache flush" });
+        }
+        if (type === "shopware6") {
+            postPull.push({ exec: "bin/console cache:clear" });
+        }
+        return {
+            "post-pull": postPull,
+        };
+    }
+    async determineDocumentRoot(inst) {
+        const appVersion = await this.getAppVersion(inst.appId, inst.appVersion.desired);
+        if (appVersion.docRootUserEditable && hasCustomDocumentRoot(inst)) {
+            return stripLeadingSlash(inst.customDocumentRoot);
+        }
+        return stripLeadingSlash(appVersion.docRoot);
+    }
+    async determineProjectType(inst, type) {
+        if (type !== "auto") {
+            return type;
+        }
+        const autoDetermined = await determineProjectTypeFromAppInstallation(this.apiClient, inst);
+        if (autoDetermined) {
+            return autoDetermined;
+        }
+        throw new Error("Automatic project type detection failed. Please specify the project type manually by setting the `--override-type` flag.");
+    }
+    async determineDatabaseVersion(databaseId) {
+        if (!databaseId) {
+            return undefined;
+        }
+        const mysqlDatabase = await this.determineMySQLDatabaseVersion(databaseId);
+        if (mysqlDatabase) {
+            return mysqlDatabase;
+        }
+        return undefined;
+    }
+    async determineMySQLDatabaseVersion(mysqlDatabaseId) {
+        const r = await this.apiClient.database.getMysqlDatabase({
+            mysqlDatabaseId,
+        });
+        if (r.status !== 200) {
+            return undefined;
+        }
+        return {
+            type: "mysql",
+            version: r.data.version,
+        };
+    }
+    determinePHPVersion(systemSoftwareVersions) {
+        if (!("php" in systemSoftwareVersions)) {
+            return undefined;
+        }
+        const version = systemSoftwareVersions["php"];
+        return stripPatchLevelVersion(version);
+    }
+    async buildSystemSoftwareVersionMap(inst) {
+        const versionMap = {};
+        for (const { systemSoftwareId, systemSoftwareVersion, } of inst.systemSoftware || []) {
+            const { name } = await this.getSystemSoftware(systemSoftwareId);
+            const { externalVersion } = await this.getSystemSoftwareVersion(systemSoftwareId, systemSoftwareVersion.desired);
+            versionMap[name] = externalVersion;
+        }
+        return versionMap;
+    }
+    async getSystemSoftware(systemSoftwareId) {
+        const systemSoftwareResponse = await this.apiClient.app.getSystemsoftware({
+            systemSoftwareId,
+        });
+        assertStatus(systemSoftwareResponse, 200);
+        return systemSoftwareResponse.data;
+    }
+    async getSystemSoftwareVersion(systemSoftwareId, systemSoftwareVersionId) {
+        const r = await this.apiClient.app.getSystemsoftwareversion({
+            systemSoftwareId,
+            systemSoftwareVersionId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+    async getAppVersion(appId, appVersionId) {
+        const r = await this.apiClient.app.getAppversion({
+            appId,
+            appVersionId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+    async getAppInstallation(appInstallationId) {
+        const r = await this.apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        assertStatus(r, 200);
+        return r.data;
+    }
+}
+function hasCustomDocumentRoot(inst) {
+    return inst.customDocumentRoot !== undefined;
+}
+function stripLeadingSlash(input) {
+    return input.replace(/^\//, "");
+}
+function stripPatchLevelVersion(version) {
+    const [major, minor] = version.split(".");
+    return `${major}.${minor}`;
+}

package/dist/lib/ddev/config_loader.d.ts

@@ -0,0 +1,2 @@
+import { DDEVConfig } from "./config.js";
+export declare function loadDDEVConfig(baseDir?: string): Promise<Partial<DDEVConfig> | undefined>;

package/dist/lib/ddev/config_loader.js

@@ -0,0 +1,13 @@
+import { readFile } from "fs/promises";
+import { load } from "js-yaml";
+import { cwd } from "process";
+import path from "path";
+import { pathExists } from "../util/fs/pathExists.js";
+export async function loadDDEVConfig(baseDir = cwd()) {
+    const configPath = path.join(baseDir, ".ddev", "config.yaml");
+    if (!(await pathExists(configPath))) {
+        return undefined;
+    }
+    const existing = await readFile(".ddev/config.yaml", "utf-8");
+    return load(existing);
+}

package/dist/lib/ddev/config_render.d.ts

@@ -0,0 +1,2 @@
+import { DDEVConfig } from "./config.js";
+export declare function renderDDEVConfig(appInstallationId: string, cfg: Partial<DDEVConfig>): string;

package/dist/lib/ddev/config_render.js

@@ -0,0 +1,6 @@
+import yaml from "js-yaml";
+export function renderDDEVConfig(appInstallationId, cfg) {
+    return `# DDEV configuration for mittwald app installation '${appInstallationId}'
+# generated by 'mw ddev init-config'
+${yaml.dump(cfg)}`;
+}

package/dist/lib/ddev/flags.d.ts

@@ -0,0 +1,12 @@
+import { InferredFlags } from "@oclif/core/interfaces";
+declare const ddevDatabaseFlags: {
+    "database-id": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    "without-database": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+export declare const ddevFlags: {
+    "database-id": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    "without-database": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    "override-type": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+};
+export type DDEVDatabaseFlags = InferredFlags<typeof ddevDatabaseFlags>;
+export {};

package/dist/lib/ddev/flags.js

@@ -0,0 +1,29 @@
+import { Flags } from "@oclif/core";
+import { knownDDEVProjectTypes } from "./init_projecttype.js";
+const ddevDatabaseFlags = {
+    "database-id": Flags.string({
+        summary: "ID of the application database",
+        description: "The ID of the database to use for the DDEV project; if set to 'auto', the command will use the database linked to the app installation.\n" +
+            "\n" +
+            "Setting a database ID (either automatically or manually) is required. To create a DDEV project without a database, set the --without-database flag.",
+        required: false,
+        default: undefined,
+    }),
+    "without-database": Flags.boolean({
+        summary: "Create a DDEV project without a database",
+        description: "Use this flag to create a DDEV project without a database; this is useful for projects that do not require a database.",
+        default: false,
+        exclusive: ["database-id"],
+    }),
+};
+export const ddevFlags = {
+    "override-type": Flags.string({
+        summary: "Override the type of the generated DDEV configuration",
+        default: "auto",
+        options: [...knownDDEVProjectTypes, "auto"],
+        description: "The type of the generated DDEV configuration; this can be any of the documented DDEV project types, or 'auto' (which is also the default) for automatic discovery." +
+            "\n\n" +
+            "See https://ddev.readthedocs.io/en/latest/users/configuration/config/#type for more information",
+    }),
+    ...ddevDatabaseFlags,
+};

package/dist/lib/ddev/init_assert.d.ts

@@ -0,0 +1,3 @@
+import { ProcessRenderer } from "../../rendering/process/process.js";
+export declare function assertDDEVIsInstalled(r: ProcessRenderer): Promise<void>;
+export declare function determineDDEVVersion(r: ProcessRenderer): Promise<string>;

package/dist/lib/ddev/init_assert.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { promisify } from "util";
+import { exec } from "child_process";
+import { Value } from "../../rendering/react/components/Value.js";
+import { hasBinaryInPath } from "../util/fs/hasBinaryInPath.js";
+const execAsync = promisify(exec);
+export async function assertDDEVIsInstalled(r) {
+    await r.runStep("check if DDEV is installed", async () => {
+        if (!(await hasBinaryInPath("ddev"))) {
+            throw new Error("this command requires DDEV to be installed");
+        }
+    });
+}
+export async function determineDDEVVersion(r) {
+    const { stdout } = await execAsync("ddev --version");
+    const version = stdout.trim().replace(/^ddev version +/, "");
+    r.addInfo(_jsx(InfoDDEVVersion, { version: version }));
+    return version;
+}
+function InfoDDEVVersion({ version }) {
+    return (_jsxs(_Fragment, { children: ["detected DDEV version: ", _jsx(Value, { children: version })] }));
+}

package/dist/lib/ddev/init_database.d.ts

@@ -0,0 +1,19 @@
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import { DDEVDatabaseFlags } from "./flags.js";
+import { type MittwaldAPIV2, type MittwaldAPIV2Client } from "@mittwald/api-client";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+/**
+ * Determines the database ID to use for the DDEV project.
+ *
+ * This is done according to the following rules (in order of precedence):
+ *
+ * 1. If the `--without-database` flag is set, do not use a database.
+ * 2. If the `--database-id` flag is set, use the database with the given ID.
+ * 3. If the app installation has a linked database with the purpose "primary", use
+ *    that database.
+ * 4. Otherwise, prompt the user to select a database from the list of databases
+ *    present in the project.
+ * 5. If interactive input is not available, terminate with an error.
+ */
+export declare function determineDDEVDatabaseId(r: ProcessRenderer, apiClient: MittwaldAPIV2Client, flags: DDEVDatabaseFlags, appInstallation: AppInstallation): Promise<string | undefined>;
+export {};

package/dist/lib/ddev/init_database.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { assertStatus, } from "@mittwald/api-client";
+import { Value } from "../../rendering/react/components/Value.js";
+import { Text } from "ink";
+/**
+ * Determines the database ID to use for the DDEV project.
+ *
+ * This is done according to the following rules (in order of precedence):
+ *
+ * 1. If the `--without-database` flag is set, do not use a database.
+ * 2. If the `--database-id` flag is set, use the database with the given ID.
+ * 3. If the app installation has a linked database with the purpose "primary", use
+ *    that database.
+ * 4. Otherwise, prompt the user to select a database from the list of databases
+ *    present in the project.
+ * 5. If interactive input is not available, terminate with an error.
+ */
+export async function determineDDEVDatabaseId(r, apiClient, flags, appInstallation) {
+    let databaseId = flags["database-id"];
+    const withoutDatabase = flags["without-database"];
+    if (withoutDatabase) {
+        return undefined;
+    }
+    if (databaseId === undefined) {
+        databaseId = (appInstallation.linkedDatabases ?? []).find((db) => db.purpose === "primary")?.databaseId;
+    }
+    if (databaseId !== undefined) {
+        const mysqlDatabaseResponse = await apiClient.database.getMysqlDatabase({
+            mysqlDatabaseId: databaseId,
+        });
+        assertStatus(mysqlDatabaseResponse, 200);
+        r.addInfo(_jsx(InfoDatabase, { name: mysqlDatabaseResponse.data.name }));
+        return mysqlDatabaseResponse.data.name;
+    }
+    return await promptDatabaseFromUser(r, apiClient, appInstallation);
+}
+async function promptDatabaseFromUser(r, apiClient, appInstallation) {
+    const { projectId } = appInstallation;
+    if (!projectId) {
+        throw new Error("app installation has no project ID");
+    }
+    const mysqlDatabaseResponse = await apiClient.database.listMysqlDatabases({
+        projectId,
+    });
+    assertStatus(mysqlDatabaseResponse, 200);
+    return await r.addSelect("select the database to use", [
+        ...mysqlDatabaseResponse.data.map((db) => ({
+            value: db.name,
+            label: `${db.name} (${db.description})`,
+        })),
+        {
+            value: undefined,
+            label: "no database",
+        },
+    ]);
+}
+function InfoDatabase({ name }) {
+    return (_jsxs(Text, { children: ["using database: ", _jsx(Value, { children: name })] }));
+}

package/dist/lib/ddev/init_projecttype.d.ts

@@ -0,0 +1,32 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+/**
+ * A list of all known DDEV project types. Shamelessly stolen from
+ * https://ddev.readthedocs.io/en/latest/users/configuration/config/#type
+ */
+export declare const knownDDEVProjectTypes: readonly ["backdrop", "craftcms", "django4", "drupal6", "drupal7", "drupal", "laravel", "magento", "magento2", "php", "python", "shopware6", "silverstripe", "typo3", "wordpress"];
+export type DDEVProjectType = (typeof knownDDEVProjectTypes)[number];
+/**
+ * Determines the DDEV project type to use for the given app installation.
+ *
+ * This is done according to the following rules:
+ *
+ * 1. If an explicit override was specified (typically using the --override-type
+ *    flag), use that.
+ * 2. If the app installation is a known app type (e.g. TYPO3, WordPress, etc.),
+ *    use the corresponding DDEV project type.
+ * 3. Prompt the user to interactively select a DDEV project type.
+ */
+export declare function determineProjectType(r: ProcessRenderer, client: MittwaldAPIV2Client, inst: AppInstallation, typeOverride: DDEVProjectType | "auto"): Promise<DDEVProjectType>;
+/**
+ * Determines the project type to use for the given app installation.
+ *
+ * In most cases, this is a simple mapping from known app IDs to DDEV project
+ * types. In some cases, we might need to know the specific (major) version of
+ * an app to determine the correct project type (for example, DDEV has separate
+ * project types for the different Drupal major versions).
+ */
+export declare function determineProjectTypeFromAppInstallation(client: MittwaldAPIV2Client, inst: AppInstallation): Promise<DDEVProjectType | null>;
+export {};

package/dist/lib/ddev/init_projecttype.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { assertStatus } from "@mittwald/api-client";
+import { typo3Installer } from "../../commands/app/install/typo3.js";
+import { wordpressInstaller } from "../../commands/app/install/wordpress.js";
+import { shopware6Installer } from "../../commands/app/install/shopware6.js";
+import { drupalInstaller } from "../../commands/app/install/drupal.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { Text } from "ink";
+/**
+ * A list of all known DDEV project types. Shamelessly stolen from
+ * https://ddev.readthedocs.io/en/latest/users/configuration/config/#type
+ */
+export const knownDDEVProjectTypes = [
+    "backdrop",
+    "craftcms",
+    "django4",
+    "drupal6",
+    "drupal7",
+    "drupal",
+    "laravel",
+    "magento",
+    "magento2",
+    "php",
+    "python",
+    "shopware6",
+    "silverstripe",
+    "typo3",
+    "wordpress",
+];
+async function getAppVersion(client, appId, appVersionId) {
+    const r = await client.app.getAppversion({
+        appId,
+        appVersionId,
+    });
+    assertStatus(r, 200);
+    return r.data;
+}
+/**
+ * Determines the DDEV project type to use for the given app installation.
+ *
+ * This is done according to the following rules:
+ *
+ * 1. If an explicit override was specified (typically using the --override-type
+ *    flag), use that.
+ * 2. If the app installation is a known app type (e.g. TYPO3, WordPress, etc.),
+ *    use the corresponding DDEV project type.
+ * 3. Prompt the user to interactively select a DDEV project type.
+ */
+export async function determineProjectType(r, client, inst, typeOverride) {
+    if (typeOverride !== "auto") {
+        r.addInfo(_jsx(ProjectTypeInfoOverride, { type: typeOverride }));
+        return typeOverride;
+    }
+    const determinedProjectType = await determineProjectTypeFromAppInstallation(client, inst);
+    if (determinedProjectType !== null) {
+        r.addInfo(_jsx(ProjectTypeInfoAuto, { type: determinedProjectType }));
+        return determinedProjectType;
+    }
+    return await promptProjectTypeFromUser(r);
+}
+/**
+ * Interactively prompts the user to select a DDEV project type.
+ *
+ * The list of known project types is hardcoded in this module.
+ */
+async function promptProjectTypeFromUser(r) {
+    return r.addSelect("select the DDEV project type", knownDDEVProjectTypes.map((t) => ({ value: t, label: t })));
+}
+/**
+ * Determines the project type to use for the given app installation.
+ *
+ * In most cases, this is a simple mapping from known app IDs to DDEV project
+ * types. In some cases, we might need to know the specific (major) version of
+ * an app to determine the correct project type (for example, DDEV has separate
+ * project types for the different Drupal major versions).
+ */
+export async function determineProjectTypeFromAppInstallation(client, inst) {
+    switch (inst.appId) {
+        case typo3Installer.appId:
+            return "typo3";
+        case wordpressInstaller.appId:
+            return "wordpress";
+        case shopware6Installer.appId:
+            return "shopware6";
+        case drupalInstaller.appId: {
+            const version = await getAppVersion(client, inst.appId, inst.appVersion.desired);
+            const [major] = version.externalVersion.split(".");
+            if (major === "6" || major === "7") {
+                return `drupal${major}`;
+            }
+            return "drupal";
+        }
+        default:
+            return null;
+    }
+}
+function ProjectTypeInfoOverride({ type }) {
+    return (_jsxs(Text, { children: ["using DDEV project type: ", _jsx(Value, { children: type }), " (explicitly specified)"] }));
+}
+function ProjectTypeInfoAuto({ type }) {
+    return (_jsxs(Text, { children: ["using DDEV project type: ", _jsx(Value, { children: type }), " (derived from app installation)"] }));
+}

package/dist/lib/error/InteractiveInputRequiredError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Error thrown when a command requires interactive input, but the current
+ * terminal environment does not support it.
+ */
+export default class InteractiveInputRequiredError extends Error {
+    constructor();
+}

package/dist/lib/error/InteractiveInputRequiredError.js

@@ -0,0 +1,11 @@
+/**
+ * Error thrown when a command requires interactive input, but the current
+ * terminal environment does not support it.
+ */
+export default class InteractiveInputRequiredError extends Error {
+    constructor() {
+        super("This command requires an interactive input, but the current environment " +
+            "does not support it. Please have a look at this command's --help page " +
+            "to learn how to pass the required input non-interactively.");
+    }
+}

package/dist/lib/error/UnexpectedShortIDPassedError.d.ts

@@ -0,0 +1,5 @@
+export default class UnexpectedShortIDPassedError extends Error {
+    readonly resourceName: string;
+    readonly format: string;
+    constructor(name: string, format: string);
+}

package/dist/lib/error/UnexpectedShortIDPassedError.js

@@ -0,0 +1,10 @@
+import { articleForWord } from "../util/language/articleForWord.js";
+export default class UnexpectedShortIDPassedError extends Error {
+    resourceName;
+    format;
+    constructor(name, format) {
+        super(`This command expects ${articleForWord(name)} ${name}, which is typically formatted as ${format}. It looks like you passed a short ID for another type of resource, instead.`);
+        this.resourceName = name;
+        this.format = format;
+    }
+}

package/dist/lib/error/handleError.d.ts

@@ -0,0 +1,11 @@
+import { OclifError, PrettyPrintableError } from "@oclif/core/interfaces";
+import { ApiClientError, AxiosResponse } from "@mittwald/api-client-commons";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
+export default function handleError(error: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
+    skipOclifErrorHandling?: boolean;
+}): void;
+export declare function isValidationError(err: unknown): err is ApiClientError<CommonsValidationErrors> & {
+    response: AxiosResponse<CommonsValidationErrors>;
+};
+export {};

package/dist/lib/error/handleError.js

@@ -0,0 +1,21 @@
+import { ApiClientError } from "@mittwald/api-client-commons";
+import { ExitError } from "@oclif/core/errors";
+import { renderError } from "../../rendering/react/error.js";
+// noinspection JSUnusedGlobalSymbols
+export default function handleError(error) {
+    if (!isUnexpectedError(error)) {
+        process.exit(1);
+    }
+    if (error instanceof ExitError) {
+        process.exit(error.oclif.exit);
+    }
+    renderError(error);
+    process.exit(1);
+}
+function isUnexpectedError(err) {
+    return !isValidationError(err);
+}
+export function isValidationError(err) {
+    return (err instanceof ApiClientError &&
+        err.response?.data?.type === "ValidationError");
+}

package/dist/lib/flags/expireFlags.d.ts

@@ -0,0 +1,7 @@
+import { OptionFlag } from "@oclif/core/interfaces";
+export declare function expireFlags(resourceName: string, required: false): {
+    expires: OptionFlag<Date | undefined>;
+};
+export declare function expireFlags(resourceName: string, required: true): {
+    expires: OptionFlag<Date>;
+};

package/dist/lib/flags/expireFlags.js

@@ -0,0 +1,18 @@
+import Duration from "../units/Duration.js";
+/**
+ * Constructs a set of flags for specifying an expiration time for a resource.
+ *
+ * @param resourceName The name of the resource to expire.
+ * @param required Whether the expiration time is required. NOTE: This
+ *   function's overload signatures assert that if required, the flag will be of
+ *   type `Date`, otherwise `Date | undefined`.
+ */
+export function expireFlags(resourceName, required) {
+    return {
+        expires: Duration.absoluteFlag({
+            description: `an interval after which the ${resourceName} expires (examples: 30m, 30d, 1y).`,
+            multiple: false,
+            required,
+        }),
+    };
+}

package/dist/lib/resources/app/Installer.d.ts

@@ -0,0 +1,27 @@
+import { OutputFlags } from "@oclif/core/interfaces";
+import { AvailableFlagName, RelevantFlagInput } from "./flags.js";
+import React from "react";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { Config } from "@oclif/core";
+type ImplicitDefaultFlag = "wait" | "wait-timeout" | "site-title";
+export interface AppInstallationResult {
+    appInstallationId: string;
+}
+export declare class AppInstaller<TFlagName extends AvailableFlagName> {
+    readonly appId: string;
+    readonly appName: string;
+    readonly appSupportedFlags: readonly TFlagName[];
+    readonly defaultFlagValues: Partial<Record<AvailableFlagName, string>>;
+    readonly description: string;
+    mutateFlags?: (flags: RelevantFlagInput<readonly (TFlagName | ImplicitDefaultFlag)[]>) => unknown;
+    private static makeDescription;
+    constructor(appId: string, appName: string, appSupportedFlags: readonly TFlagName[], defaultFlagValues?: Partial<Record<AvailableFlagName, string>>);
+    get flags(): RelevantFlagInput<readonly (TFlagName | ImplicitDefaultFlag)[]>;
+    exec(apiClient: MittwaldAPIV2Client, args: {
+        [k: string]: unknown;
+    }, flags: OutputFlags<RelevantFlagInput<(TFlagName | ImplicitDefaultFlag)[]>>, config: Config): Promise<AppInstallationResult>;
+    render(result: AppInstallationResult, flags: {
+        quiet: boolean;
+    }): React.ReactNode;
+}
+export {};

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

@@ -0,0 +1,56 @@
+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 { waitUntilAppStateHasNormalized } from "./wait.js";
+import { Success } from "../../../rendering/react/components/Success.js";
+export class AppInstaller {
+    appId;
+    appName;
+    appSupportedFlags;
+    defaultFlagValues;
+    description;
+    mutateFlags;
+    static makeDescription(appName) {
+        return `Creates new ${appName} installation.`;
+    }
+    constructor(appId, appName, appSupportedFlags, defaultFlagValues = {}) {
+        this.appId = appId;
+        this.appName = appName;
+        this.appSupportedFlags = appSupportedFlags;
+        this.defaultFlagValues = defaultFlagValues;
+        this.description = AppInstaller.makeDescription(appName);
+    }
+    get flags() {
+        const flags = provideSupportedFlags([...this.appSupportedFlags, "wait", "wait-timeout", "site-title"], this.appName);
+        if (this.mutateFlags) {
+            this.mutateFlags(flags);
+        }
+        return flags;
+    }
+    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, this.defaultFlagValues);
+        const appVersion = await normalizeToAppVersionUuid(apiClient, "version" in flags ? flags.version : "latest", process, this.appId);
+        const appInstallationId = await triggerAppInstallation(apiClient, process, projectId, flags, appVersion);
+        let successText;
+        if (flags.wait) {
+            await waitUntilAppStateHasNormalized(apiClient, process, appInstallationId, "waiting for app installation to be ready", flags["wait-timeout"]);
+            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/lib/resources/app/custom_installation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests if an app installation is for a custom app (for example, a custom PHP
+ * or Node.js app). These are treated differently in the UI.
+ *
+ * @param appId
+ */
+export declare function isCustomAppInstallation(appId: string): boolean;