@mittwald/cli 1.0.0-alpha.8 → 1.0.0-beta.1

package/dist/commands/app/list.js

@@ -0,0 +1,79 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { projectFlags, withProjectId, } from "../../lib/resources/project/flags.js";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { getAppFromUuid, getAppVersionFromUuid, } from "../../lib/resources/app/uuid.js";
+import { isCustomAppInstallation } from "../../lib/resources/app/custom_installation.js";
+import chalk from "chalk";
+export default class List extends ListBaseCommand {
+    static description = "List installed apps in a project.";
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, List, this.flags, this.args, this.config);
+        const apps = await this.apiClient.app.listAppinstallations({
+            projectId,
+        });
+        assertStatus(apps, 200);
+        return apps;
+    }
+    mapData(data) {
+        return Promise.all(data.map(async (item) => {
+            return {
+                ...item,
+                app: await getAppFromUuid(this.apiClient, item.appId),
+                appVersionCurrent: item.appVersion.current
+                    ? await getAppVersionFromUuid(this.apiClient, item.appId, item.appVersion.current)
+                    : undefined,
+                appVersionDesired: await getAppVersionFromUuid(this.apiClient, item.appId, item.appVersion.desired),
+            };
+        }));
+    }
+    getColumns(data) {
+        return this.getColumnsExtended(data);
+    }
+    getColumnsExtended(rows) {
+        const { id, shortId } = super.getColumns(rows);
+        return {
+            id,
+            shortId,
+            description: {},
+            app: {
+                header: "Application",
+                minWidth: 8,
+                get: (i) => i.app.name,
+            },
+            appVersion: {
+                header: "Version",
+                get: (i) => {
+                    if (isCustomAppInstallation(i.appId)) {
+                        return chalk.dim("n/a");
+                    }
+                    if (i.appVersionCurrent?.id === i.appVersionDesired.id) {
+                        return i.appVersionDesired.externalVersion;
+                    }
+                    if (!i.appVersionCurrent) {
+                        return i.appVersionDesired.externalVersion;
+                    }
+                    return `${i.appVersionCurrent.externalVersion} => ${i.appVersionDesired.externalVersion}`;
+                },
+            },
+            status: {
+                header: "Status",
+                get: (i) => {
+                    if (i.appVersionCurrent?.id === i.appVersionDesired.id) {
+                        return "up-to-date";
+                    }
+                    if (!i.appVersionCurrent) {
+                        return "installing";
+                    }
+                    return "updating";
+                },
+            },
+            installationPath: {
+                header: "Installed in",
+            },
+        };
+    }
+}

package/dist/commands/app/ssh.d.ts

@@ -0,0 +1,16 @@
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+export default class Ssh extends ExtendedBaseCommand<typeof Ssh> {
+    static summary: string;
+    static description: string;
+    static args: {
+        "installation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        cd: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        info: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        test: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/app/ssh.js

@@ -0,0 +1,61 @@
+import * as child_process from "child_process";
+import { appInstallationArgs } from "../../lib/resources/app/flags.js";
+import { Flags } from "@oclif/core";
+import { ExtendedBaseCommand } from "../../lib/basecommands/ExtendedBaseCommand.js";
+import { getSSHConnectionForAppInstallation } from "../../lib/resources/ssh/appinstall.js";
+import { sshConnectionFlags, } from "../../lib/resources/ssh/flags.js";
+import { sshWrapperDocumentation } from "../../lib/resources/ssh/doc.js";
+import { buildSSHClientFlags } from "../../lib/resources/ssh/connection.js";
+export default class Ssh extends ExtendedBaseCommand {
+    static summary = "Connect to an app via SSH";
+    static description = "Establishes an interactive SSH connection to an app installation.\n\n" +
+        sshWrapperDocumentation;
+    static args = { ...appInstallationArgs };
+    static flags = {
+        ...sshConnectionFlags,
+        cd: Flags.boolean({
+            summary: "change to installation path after connecting",
+            default: true,
+            allowNo: true,
+        }),
+        info: Flags.boolean({
+            summary: "only print connection information, without actually connecting",
+        }),
+        test: Flags.boolean({
+            summary: "test connection and exit",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Ssh);
+        const appInstallationId = await this.withAppInstallationId(Ssh);
+        const { host, user, directory } = await getSSHConnectionForAppInstallation(this.apiClient, appInstallationId, flags["ssh-user"]);
+        if (flags.info) {
+            this.log("hostname: %o", host);
+            this.log("username: %o", user);
+            this.log("directory: %o", directory);
+            return;
+        }
+        this.log("connecting to %o as %o", host, user);
+        const [cmd, args] = buildSSHCmdAndFlags(user, host, directory, this.flags);
+        this.debug("running ssh %o, with command %o", args, cmd);
+        if (flags.cd) {
+            this.log("changing to %o; use --no-cd to disable this behaviour", directory);
+        }
+        child_process.spawnSync("/usr/bin/ssh", [...args, cmd], {
+            stdio: "inherit",
+        });
+    }
+}
+function buildSSHCmdAndFlags(user, host, directory, flags) {
+    const args = buildSSHClientFlags(user, host, flags, {
+        interactive: true,
+        additionalFlags: flags.test ? ["-q"] : [],
+    });
+    if (flags.test) {
+        return ["/bin/true", args];
+    }
+    if (flags.cd) {
+        return [`cd ${directory} && exec bash -l`, args];
+    }
+    return ["exec bash -l", args];
+}

package/dist/commands/app/uninstall.d.ts

@@ -0,0 +1,9 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+export default class Uninstall extends DeleteBaseCommand<typeof Uninstall> {
+    static description: string;
+    static resourceName: string;
+    static args: {
+        "installation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/commands/app/uninstall.js

@@ -0,0 +1,17 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+import { appInstallationArgs } from "../../lib/resources/app/flags.js";
+export default class Uninstall extends DeleteBaseCommand {
+    static description = "Uninstall an app";
+    static resourceName = "app installation";
+    static args = {
+        ...appInstallationArgs,
+    };
+    async deleteResource() {
+        const appInstallationId = await this.withAppInstallationId(Uninstall);
+        const response = await this.apiClient.app.uninstallAppinstallation({
+            appInstallationId,
+        });
+        assertStatus(response, 204);
+    }
+}

package/dist/commands/app/update.d.ts

@@ -0,0 +1,16 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import React from "react";
+export declare class Update extends ExecRenderBaseCommand<typeof Update, void> {
+    static summary: string;
+    static args: {
+        "installation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        entrypoint: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "document-root": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): React.ReactNode;
+}

package/dist/commands/app/update.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { appInstallationArgs, withAppInstallationId, } from "../../lib/resources/app/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { Flags } from "@oclif/core";
+export class Update extends ExecRenderBaseCommand {
+    static summary = "Update properties of an app installation (use 'upgrade' to update the app version)";
+    static args = { ...appInstallationArgs };
+    static flags = {
+        ...processFlags,
+        description: Flags.string({
+            summary: "update the description of the app installation",
+            description: "This flag updates the description of the app installation. If omitted, the description will not be changed.",
+            default: undefined,
+            required: false,
+        }),
+        entrypoint: Flags.string({
+            summary: "update the entrypoint of the app installation (Python and Node.js only)",
+            description: "Updates the entrypoint of the app installation. If omitted, the entrypoint will not be changed. Note that this field is only available for some types of apps (like Python and Node.js).",
+            required: false,
+            default: undefined,
+        }),
+        "document-root": Flags.string({
+            summary: "update the document root of the app installation",
+            description: "Updates the document root of the app installation. If omitted, the document root will not be changed. Note that not all apps support this field.",
+            required: false,
+            default: undefined,
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Updating app installation");
+        const appInstallationId = await withAppInstallationId(this.apiClient, Update, this.flags, this.args, this.config);
+        const [updateBody, info] = buildUpdateBodyFromFlags(this.flags);
+        info.forEach((i) => p.addInfo(i));
+        if (Object.keys(updateBody).length === 0) {
+            p.addInfo("skipping update");
+            await p.complete(_jsx(Success, { children: "No changes to apply" }));
+            return;
+        }
+        this.debug("updating app installation: %O", updateBody);
+        await p.runStep("updating app", async () => {
+            await this.apiClient.app.patchAppinstallation({
+                appInstallationId,
+                data: updateBody,
+            });
+        });
+        await p.complete(_jsx(Success, { children: "App installation successfully updated" }));
+    }
+    render() {
+        return undefined;
+    }
+}
+function buildUpdateBodyFromFlags(flags) {
+    const updateBody = {};
+    const info = [];
+    if (flags.entrypoint) {
+        info.push(_jsx(UpdateFieldInfo, { name: "entrypoint", value: flags.entrypoint }));
+        updateBody.userInputs = [
+            ...(updateBody.userInputs || []),
+            {
+                name: "entrypoint",
+                value: flags.entrypoint,
+            },
+        ];
+    }
+    if (flags["document-root"]) {
+        info.push(_jsx(UpdateFieldInfo, { name: "document root", value: flags["document-root"] }));
+        updateBody.customDocumentRoot = flags["document-root"];
+    }
+    if (flags.description !== undefined) {
+        info.push(_jsx(UpdateFieldInfo, { name: "description", value: flags.description }));
+        updateBody.description = flags.description;
+    }
+    return [updateBody, info];
+}
+function UpdateFieldInfo({ name, value }) {
+    return (_jsxs(_Fragment, { children: ["setting ", name, " to ", _jsx(Value, { children: value })] }));
+}

package/dist/commands/app/upgrade.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class UpgradeApp extends ExecRenderBaseCommand<typeof UpgradeApp, void> {
+    static description: string;
+    static args: {
+        "installation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "wait-timeout": import("@oclif/core/interfaces").OptionFlag<import("../../lib/units/Duration.js").default, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        "target-version": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}

package/dist/commands/app/upgrade.js

@@ -0,0 +1,172 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { appInstallationArgs, withAppInstallationId, } from "../../lib/resources/app/flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { Flags, ux } from "@oclif/core";
+import { Text } from "ink";
+import { getAppFromUuid, getAppInstallationFromUuid, getAppVersionFromUuid, } from "../../lib/resources/app/uuid.js";
+import { getAllUpgradeCandidatesFromAppInstallationId, getAvailableTargetAppVersionFromExternalVersion, getLatestAvailableTargetAppVersionForAppVersionUpgradeCandidates, } from "../../lib/resources/app/versions.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { waitUntilAppStateHasNormalized } from "../../lib/resources/app/wait.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { waitFlags } from "../../lib/wait.js";
+import semver from "semver/preload.js";
+export class UpgradeApp extends ExecRenderBaseCommand {
+    static description = "Upgrade app installation to target version";
+    static args = {
+        ...appInstallationArgs,
+    };
+    static flags = {
+        "target-version": Flags.string({
+            description: "target version to upgrade app to; if omitted, target version will be prompted interactively",
+        }),
+        force: Flags.boolean({
+            char: "f",
+            description: "Do not ask for confirmation.",
+        }),
+        ...projectFlags,
+        ...processFlags,
+        ...waitFlags,
+    };
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "App upgrade");
+        const appInstallationId = await withAppInstallationId(this.apiClient, UpgradeApp, this.flags, this.args, this.config);
+        const currentAppInstallation = await getAppInstallationFromUuid(this.apiClient, appInstallationId), currentApp = await getAppFromUuid(this.apiClient, currentAppInstallation.appId);
+        const targetAppVersionCandidates = await getAllUpgradeCandidatesFromAppInstallationId(this.apiClient, currentAppInstallation.id);
+        if (currentAppInstallation.appVersion.current === undefined) {
+            process.error("Current version could not be determined properly.");
+            ux.exit(1);
+        }
+        const currentAppVersion = await getAppVersionFromUuid(this.apiClient, currentApp.id, currentAppInstallation.appVersion.current);
+        if (targetAppVersionCandidates.length == 0) {
+            process.complete(_jsxs(Text, { children: ["Your ", currentApp.name, " ", currentAppVersion.externalVersion, " is already Up-To-Date. \u2705"] }));
+            return;
+        }
+        let targetAppVersion;
+        if (this.flags["target-version"] == "latest") {
+            targetAppVersion =
+                (await getLatestAvailableTargetAppVersionForAppVersionUpgradeCandidates(this.apiClient, currentApp.id, currentAppVersion.id));
+        }
+        else if (this.flags["target-version"]) {
+            const targetVersionMatchFromCandidates = targetAppVersionCandidates.find((targetAppVersionCandidate) => targetAppVersionCandidate.externalVersion ===
+                this.flags["target-version"]);
+            if (targetVersionMatchFromCandidates) {
+                targetAppVersion = targetVersionMatchFromCandidates;
+            }
+            else {
+                process.addInfo(_jsx(Text, { children: "The given target upgrade version does not seem to be a valid upgrade candidate." }));
+                targetAppVersion = (await forceTargetVersionSelection(process, this.apiClient, targetAppVersionCandidates, currentApp, currentAppVersion));
+            }
+        }
+        else {
+            targetAppVersion = (await forceTargetVersionSelection(process, this.apiClient, targetAppVersionCandidates, currentApp, currentAppVersion));
+        }
+        if (!targetAppVersion) {
+            process.error("Target app version could not be determined properly.");
+            ux.exit(1);
+        }
+        if (!this.flags.force) {
+            const confirmed = await process.addConfirmation(_jsxs(Text, { children: ["Confirm upgrading ", currentApp.name, " ", currentAppVersion.externalVersion, " (", currentAppInstallation.description, ") to version", " ", targetAppVersion.externalVersion] }));
+            if (!confirmed) {
+                process.addInfo(_jsx(Text, { children: "Upgrade will not be triggered." }));
+                process.complete(_jsx(_Fragment, {}));
+                ux.exit(1);
+            }
+        }
+        else {
+            process.addInfo(_jsxs(Text, { children: ["Commencing upgrade of ", currentApp.name, " ", currentAppVersion.externalVersion, " (", currentAppInstallation.description, ") to Version", " ", targetAppVersion.externalVersion, "."] }));
+        }
+        const appUpgradePayload = {
+            appVersionId: targetAppVersion.id,
+        };
+        const missingDependencies = await this.apiClient.app.getMissingDependenciesForAppinstallation({
+            queryParameters: {
+                targetAppVersionID: targetAppVersion.id,
+            },
+            appInstallationId,
+        });
+        if (missingDependencies.data.missingSystemSoftwareDependencies) {
+            appUpgradePayload.systemSoftware = {};
+            process.addStep(_jsxs(Text, { children: ["In order to upgrade your ", currentApp.name, " to Version", " ", targetAppVersion.externalVersion, " some dependencies need to be upgraded too."] }));
+            for (const missingSystemSoftwareDependency of missingDependencies.data
+                .missingSystemSoftwareDependencies) {
+                const dependencyUpdateData = await updateMissingSystemSoftwareDependency(process, this.apiClient, missingSystemSoftwareDependency);
+                appUpgradePayload.systemSoftware[dependencyUpdateData.dependencySoftwareId] = {
+                    systemSoftwareVersion: dependencyUpdateData.dependencyTargetVersionId,
+                };
+            }
+            if (!this.flags.force) {
+                const confirmed = await process.addConfirmation(_jsx(Text, { children: "Do you want to continue?" }));
+                if (!confirmed) {
+                    process.addInfo(_jsx(Text, { children: "Upgrade will not be triggered." }));
+                    process.complete(_jsx(_Fragment, {}));
+                    ux.exit(1);
+                }
+            }
+        }
+        const patchAppTriggerResponse = await this.apiClient.app.patchAppinstallation({
+            appInstallationId,
+            data: appUpgradePayload,
+        });
+        assertStatus(patchAppTriggerResponse, 204);
+        let successText;
+        if (this.flags.wait) {
+            await waitUntilAppStateHasNormalized(this.apiClient, process, appInstallationId, "waiting for app upgrade to be done", this.flags["wait-timeout"]);
+            successText =
+                "The upgrade finished successfully. Please check if everything is in its place. 🔎";
+        }
+        else {
+            successText = "The upgrade has been started. Buckle up! 🚀";
+        }
+        await process.complete(_jsx(Success, { children: successText }));
+    }
+    render() {
+        return true;
+    }
+}
+async function forceTargetVersionSelection(process, apiClient, targetAppVersionCandidates, currentApp, currentAppVersion) {
+    const targetAppVersionString = await process.addSelect(`Please select target upgrade for your ${currentApp.name} ${currentAppVersion.externalVersion} from one of the following`, [
+        ...targetAppVersionCandidates.map((targetAppVersionCandidate) => ({
+            value: targetAppVersionCandidate.externalVersion,
+            label: `${targetAppVersionCandidate.externalVersion}`,
+        })),
+    ]);
+    return await getAvailableTargetAppVersionFromExternalVersion(apiClient, currentApp.id, currentAppVersion.id, targetAppVersionString);
+}
+async function updateMissingSystemSoftwareDependency(process, apiClient, dependency) {
+    const dependencySoftware = await apiClient.app.getSystemsoftware({
+        systemSoftwareId: dependency.systemSoftwareId,
+    });
+    assertStatus(dependencySoftware, 200);
+    const dependencyVersionList = await apiClient.app.listSystemsoftwareversions({
+        systemSoftwareId: dependency.systemSoftwareId,
+        queryParameters: {
+            versionRange: dependency.versionRange,
+            recommended: true,
+        },
+    });
+    assertStatus(dependencyVersionList, 200);
+    let dependencyTargetVersion = {
+        id: "not yet set",
+        externalVersion: "0.0.0",
+        internalVersion: "0.0.0",
+    };
+    for (const dependencyVersion of dependencyVersionList.data) {
+        if (semver.gt(dependencyVersion.internalVersion, dependencyTargetVersion.internalVersion)) {
+            dependencyTargetVersion = dependencyVersion;
+        }
+    }
+    if (dependencyTargetVersion.internalVersion == "0.0.0") {
+        throw new Error("Dependency Target Version for " +
+            dependencySoftware.data.name +
+            " could not be determined");
+    }
+    else {
+        process.addInfo(_jsxs(Text, { children: [dependencySoftware.data.name, " will be upgraded to Version", " ", dependencyTargetVersion.externalVersion, "."] }));
+        return {
+            dependencySoftwareId: dependencySoftware.data.id,
+            dependencyTargetVersionId: dependencyTargetVersion.id,
+        };
+    }
+}

package/dist/commands/app/upload.d.ts

@@ -0,0 +1,20 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Upload extends ExecRenderBaseCommand<typeof Upload, void> {
+    static summary: string;
+    static description: string;
+    static args: {
+        "installation-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    static flags: {
+        source: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        exclude: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+        "dry-run": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        delete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}

package/dist/commands/app/upload.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { appInstallationArgs } from "../../lib/resources/app/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { Success } from "../../rendering/react/components/Success.js";
+import { getSSHConnectionForAppInstallation } from "../../lib/resources/ssh/appinstall.js";
+import { spawnInProcess } from "../../rendering/process/process_exec.js";
+import { sshConnectionFlags } from "../../lib/resources/ssh/flags.js";
+import { sshUsageDocumentation } from "../../lib/resources/ssh/doc.js";
+import { appInstallationSyncFlags, appInstallationSyncFlagsToRsyncFlags, filterFileDocumentation, filterFileToRsyncFlagsIfPresent, } from "../../lib/resources/app/sync.js";
+import { hasBinaryInPath } from "../../lib/util/fs/hasBinaryInPath.js";
+export class Upload extends ExecRenderBaseCommand {
+    static summary = "Upload the filesystem of an app to a project";
+    static description = "Upload the filesystem of an app from your local machine to a project.\n\n" +
+        "For this, rsync needs to be installed on your system.\n\n" +
+        "CAUTION: This is a potentially destructive operation. It will overwrite files on the server with the files from your local machine. " +
+        "This is NOT a turnkey deployment solution. It is intended for development purposes only.\n\n" +
+        sshUsageDocumentation +
+        "\n\n" +
+        filterFileDocumentation;
+    static args = {
+        ...appInstallationArgs,
+    };
+    static flags = {
+        ...processFlags,
+        ...sshConnectionFlags,
+        ...appInstallationSyncFlags("upload"),
+        source: Flags.directory({
+            description: "source directory from which to upload the app installation",
+            required: true,
+            exists: true,
+        }),
+    };
+    async exec() {
+        const appInstallationId = await this.withAppInstallationId(Upload);
+        const { "dry-run": dryRun, source, "ssh-user": sshUser } = this.flags;
+        const p = makeProcessRenderer(this.flags, "Uploading app installation");
+        const { host, user, directory } = await p.runStep("getting connection data", async () => {
+            return getSSHConnectionForAppInstallation(this.apiClient, appInstallationId, sshUser);
+        });
+        await p.runStep("check if rsync is installed", async () => {
+            if (!(await hasBinaryInPath("rsync"))) {
+                throw new Error("this command requires rsync to be installed");
+            }
+        });
+        const rsyncOpts = [
+            ...appInstallationSyncFlagsToRsyncFlags(this.flags),
+            ...(await filterFileToRsyncFlagsIfPresent(source)),
+        ];
+        await spawnInProcess(p, "uploading app installation" + (dryRun ? " (dry-run)" : ""), "rsync", [...rsyncOpts, source, `${user}@${host}:${directory}/`]);
+        await p.complete(_jsx(UploadSuccess, { dryRun: dryRun }));
+    }
+    render() {
+        return undefined;
+    }
+}
+function UploadSuccess({ dryRun }) {
+    if (dryRun) {
+        return (_jsx(Success, { children: "App would (probably) have successfully been uploaded. \uD83D\uDE42" }));
+    }
+    return _jsx(Success, { children: "App successfully uploaded; have fun! \uD83D\uDE80" });
+}

package/dist/commands/app/versions.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export default class AppVersions extends BaseCommand {
+    static description: string;
+    static args: {
+        app: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    protected getApp(apiClient: MittwaldAPIV2Client, appId: string): Promise<string>;
+    protected getAllApps(apiClient: MittwaldAPIV2Client): Promise<string[]>;
+    protected outputVersionsForAppUuid(apiClient: MittwaldAPIV2Client, appUuid: string): Promise<void>;
+}

package/dist/commands/app/versions.js

@@ -0,0 +1,44 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+import { Args } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { validate as validateUuid } from "uuid";
+import { getAppNameFromUuid, getAppUuidFromAppName, } from "../../lib/resources/app/uuid.js";
+export default class AppVersions extends BaseCommand {
+    static description = "List supported Apps and Versions";
+    static args = {
+        app: Args.string({
+            description: "name of specific app to get versions for",
+            required: false,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(AppVersions);
+        const appUuidsToGetVersionsFor = args.app
+            ? [await this.getApp(this.apiClient, args.app)]
+            : await this.getAllApps(this.apiClient);
+        for (const appUuid of appUuidsToGetVersionsFor) {
+            console.log(`Available ${await getAppNameFromUuid(this.apiClient, appUuid)} Versions:`);
+            await this.outputVersionsForAppUuid(this.apiClient, appUuid);
+            console.log("");
+        }
+    }
+    async getApp(apiClient, appId) {
+        return validateUuid(appId)
+            ? appId
+            : await getAppUuidFromAppName(apiClient, appId);
+    }
+    async getAllApps(apiClient) {
+        const apps = await apiClient.app.listApps();
+        assertStatus(apps, 200);
+        return apps.data.map((app) => app.id);
+    }
+    async outputVersionsForAppUuid(apiClient, appUuid) {
+        const versions = await apiClient.app.listAppversions({
+            appId: appUuid,
+        });
+        assertStatus(versions, 200);
+        for (const version of versions.data) {
+            console.log(version.externalVersion);
+        }
+    }
+}

package/dist/commands/backup/create.d.ts

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type CreateResult = {
+    backupId: string;
+};
+export declare class Create extends ExecRenderBaseCommand<typeof Create, CreateResult> {
+    static summary: string;
+    static flags: {
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "wait-timeout": import("@oclif/core/interfaces").OptionFlag<import("../../lib/units/Duration.js").default, import("@oclif/core/interfaces").CustomOptions>;
+        expires: import("@oclif/core/interfaces").OptionFlag<Date>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected exec(): Promise<CreateResult>;
+    protected render(executionResult: CreateResult): ReactNode;
+}
+export {};