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

package/dist/esm/commands/app/install/wordpress.js

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { AppInstaller, } from "../../../lib/app/Installer.js";
+const installer = new AppInstaller("da3aa3ae-4b6b-4398-a4a8-ee8def827876", "WordPress", [
+    "version",
+    "host",
+    "admin-user",
+    "admin-email",
+    "admin-pass",
+    "site-title",
+    "wait",
+]);
+export default class InstallWordPress extends ExecRenderBaseCommand {
+    static description = installer.description;
+    static flags = installer.flags;
+    async exec() {
+        return installer.exec(this.apiClient, this.args, this.flags, this.config);
+    }
+    render(result) {
+        return installer.render(result, this.flags);
+    }
+}

package/dist/esm/commands/app/list.d.ts

@@ -1,16 +1,24 @@
-import { BaseCommand } from "../../BaseCommand.js";
-export default class List extends BaseCommand<typeof List> {
+import { Simplify } from "@mittwald/api-client-commons";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../types.js";
+import { ListColumns } from "../../Formatter.js";
+import AppApp = MittwaldAPIV2.Components.Schemas.AppApp;
+import AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["app"]["listAppinstallations"]>>;
+type ExtendedResponseItem = ResponseItem & {
+    app: AppApp;
+    appVersionCurrent: AppAppVersion | undefined;
+    appVersionDesired: AppAppVersion;
+};
+export default class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
     static description: string;
     static flags: {
-        project: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        columns: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
-        sort: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
-        filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
-        csv: import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
-        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined>;
-        extended: import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
-        'no-truncate': import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
-        'no-header': import("@oclif/core/lib/interfaces/parser.js").Flag<boolean>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
     };
-    run(): Promise<void>;
+    protected getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): Promise<ExtendedResponseItem[]>;
+    protected getColumns(): ListColumns<ExtendedResponseItem>;
 }
+export {};

package/dist/esm/commands/app/list.js

@@ -1,64 +1,81 @@
-import { Flags, ux } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
-import { BaseCommand } from "../../BaseCommand.js";
-import { normalizeProjectIdToUuid } from "../../Helpers.js";
-import { getAppNameFromUuid, getAppVersionFromUuid } from "../../Translator.js";
-export default class List extends BaseCommand {
-    static description = "List projects";
+import { getAppFromUuid, getAppVersionFromUuid } from "../../Translator.js";
+import { projectFlags, withProjectId } from "../../lib/project/flags.js";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { phpInstaller } from "./create/php.js";
+import { nodeInstaller } from "./create/node.js";
+export default class List extends ListBaseCommand {
+    static description = "List installed apps in a project.";
     static flags = {
-        ...ux.table.flags(),
-        project: Flags.string({
-            char: "p",
-            description: "project to run the command for",
-            required: true,
-        }),
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
     };
-    async run() {
-        ux.action.start("Gathering Appinstallations");
-        const { flags } = await this.parse(List);
-        const uuid = await normalizeProjectIdToUuid(this.apiClient, flags.project);
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, List, this.flags, this.args, this.config);
         const apps = await this.apiClient.app.listAppinstallations({
-            pathParameters: { projectId: uuid },
+            projectId,
         });
         assertStatus(apps, 200);
-        if (flags.json) {
-            this.logJson(apps.data);
-            return;
-        }
-        const relevantAppInfo = await Promise.all(apps.data.map(async (app) => {
+        return apps;
+    }
+    mapData(data) {
+        return Promise.all(data.map(async (item) => {
             return {
-                id: app.id,
-                description: app.description,
-                app: await getAppNameFromUuid(this.apiClient, app.appId),
-                appVersion: await getAppVersionFromUuid(this.apiClient, app.appId, app.appVersion.current),
-                installPath: app.installationPath,
+                ...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),
             };
         }));
-        ux.action.stop();
-        ux.table(relevantAppInfo, {
+    }
+    getColumns() {
+        return {
             id: {
                 header: "ID",
                 minWidth: 36,
             },
-            description: {
-                header: "Description",
-                minWidth: 36,
+            shortId: {
+                header: "Short ID",
+                minWidth: 8,
             },
+            description: {},
             app: {
                 header: "Application",
                 minWidth: 8,
+                get: (i) => i.app.name,
             },
             appVersion: {
                 header: "Version",
-                minWidth: 8,
+                get: (i) => {
+                    if ([phpInstaller.appId, nodeInstaller.appId].includes(i.appId)) {
+                        return "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}`;
+                },
             },
-            installPath: {
-                header: "InstallDir",
-                minWidth: 12,
+            status: {
+                header: "Status",
+                get: (i) => {
+                    if (i.appVersionCurrent?.id === i.appVersionDesired.id) {
+                        return "up-to-date";
+                    }
+                    if (!i.appVersionCurrent) {
+                        return "installing";
+                    }
+                    return "updating";
+                },
             },
-        }, {
-            printLine: this.log.bind(this),
-            ...flags,
-        });
+            installationPath: {
+                header: "Installed in",
+            },
+        };
     }
 }

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

@@ -0,0 +1,13 @@
+import { ExtendedBaseCommand } from "../../ExtendedBaseCommand.js";
+export default class Ssh extends ExtendedBaseCommand<typeof Ssh> {
+    static description: string;
+    static args: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+    static flags: {
+        cd: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        info: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/esm/commands/app/ssh.js

@@ -0,0 +1,55 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import * as child_process from "child_process";
+import { appInstallationArgs } from "../../lib/app/flags.js";
+import { Flags } from "@oclif/core";
+import * as path from "path";
+import { ExtendedBaseCommand } from "../../ExtendedBaseCommand.js";
+export default class Ssh extends ExtendedBaseCommand {
+    static description = "Connect to an app via SSH";
+    static args = { ...appInstallationArgs };
+    static flags = {
+        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",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Ssh);
+        const appInstallationId = await this.withAppInstallationId(Ssh);
+        const appInstallationResponse = await this.apiClient.app.getAppinstallation({
+            appInstallationId,
+        });
+        assertStatus(appInstallationResponse, 200);
+        if (appInstallationResponse.data.projectId === undefined) {
+            throw new Error("Project ID of app must not be undefined");
+        }
+        const projectResponse = await this.apiClient.project.getProject({
+            projectId: appInstallationResponse.data.projectId,
+        });
+        assertStatus(projectResponse, 200);
+        const userResponse = await this.apiClient.user.getOwnAccount();
+        assertStatus(userResponse, 200);
+        const sshHost = `ssh.${projectResponse.data.clusterID}.${projectResponse.data.clusterDomain}`;
+        const sshUser = `${userResponse.data.email}@${appInstallationResponse.data.shortId}`;
+        const absoluteInstallPath = path.join(projectResponse.data.directories["Web"], appInstallationResponse.data.installationPath);
+        if (flags.info) {
+            this.log("hostname: %o", sshHost);
+            this.log("username: %o", sshUser);
+            this.log("directory: %o", absoluteInstallPath);
+            return;
+        }
+        this.log("connecting to %o as %o", sshHost, sshUser);
+        let cmd = "exec bash -l";
+        if (flags.cd) {
+            cmd = flags.cd ? `cd ${absoluteInstallPath} && exec bash -l` : "bash -l";
+            this.log("changing to %o; use --no-cd to disable this behaviour", absoluteInstallPath);
+        }
+        child_process.spawnSync("/usr/bin/ssh", ["-t", "-l", sshUser, sshHost, cmd], {
+            stdio: "inherit",
+        });
+    }
+}

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

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

package/dist/esm/commands/app/uninstall.js

@@ -0,0 +1,17 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+import { appInstallationArgs } from "../../lib/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/esm/commands/app/versions.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../BaseCommand.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export default class AppVersions extends BaseCommand {
+    static description: string;
+    static args: {
+        app: import("@oclif/core/lib/interfaces/parser.js").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/esm/commands/app/versions.js

@@ -0,0 +1,53 @@
+import { BaseCommand } from "../../BaseCommand.js";
+import { Args } from "@oclif/core";
+import { isUuid } from "../../Helpers.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getAppNameFromUuid, getAppUuidFromAppName, } from "../../lib/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) {
+        let appUuid;
+        if (isUuid(appId)) {
+            appUuid = appId;
+        }
+        else {
+            appUuid = await getAppUuidFromAppName(apiClient, appId);
+        }
+        return [appUuid];
+    }
+    async getAllApps(apiClient) {
+        const apps = await apiClient.app.listApps();
+        assertStatus(apps, 200);
+        const appUuids = [];
+        for (const app of apps.data) {
+            appUuids.push(app.id);
+        }
+        return appUuids;
+    }
+    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/esm/commands/backup/create.d.ts

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/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/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "wait-timeout": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        expires: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected exec(): Promise<CreateResult>;
+    protected render(executionResult: CreateResult): ReactNode;
+}
+export {};

package/dist/esm/commands/backup/create.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/project/flags.js";
+import { Flags } from "@oclif/core";
+import { expirationDateFromFlags, expireFlagsRequired, } from "../../lib/expires.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+import { waitFlags, waitUntil } from "../../lib/wait.js";
+import { Text } from "ink";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new backup of a project";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        description: Flags.string({
+            description: "a description for the backup.",
+        }),
+        ...expireFlagsRequired("backup"),
+        ...waitFlags,
+    };
+    static aliases = ["project:backup:create"];
+    static deprecateAliases = true;
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating backup");
+        const projectId = await this.withProjectId(Create);
+        const { description } = this.flags;
+        const expirationTime = expirationDateFromFlags(this.flags);
+        const backup = await p.runStep("creating backup", async () => {
+            const r = await this.apiClient.backup.createProjectBackup({
+                projectId,
+                data: {
+                    description,
+                    expirationTime: expirationTime.toJSON(),
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+        if (this.flags.wait) {
+            const stepWaiting = p.addStep(_jsx(Text, { children: "waiting for backup to be complete" }));
+            await waitUntil(async () => {
+                const backupResponse = await this.apiClient.backup.getProjectBackup({
+                    projectBackupId: backup.id,
+                });
+                if (backupResponse.status === 200 &&
+                    backupResponse.data.status === "Completed") {
+                    return true;
+                }
+            }, this.flags["wait-timeout"]);
+            stepWaiting.complete();
+        }
+        p.complete(_jsx(Success, { children: "Backup successfully created." }));
+        return { backupId: backup.id };
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.backupId;
+        }
+    }
+}

package/dist/esm/commands/backup/delete.d.ts

@@ -0,0 +1,15 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+export declare class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static flags: {
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "backup-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected deleteResource(): Promise<void>;
+}

package/dist/esm/commands/backup/delete.js

@@ -0,0 +1,23 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Args } from "@oclif/core";
+export class Delete extends DeleteBaseCommand {
+    static description = "Delete a backup";
+    static resourceName = "backup";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = {
+        "backup-id": Args.string({
+            required: true,
+            description: "The ID of the Backup to show.",
+        }),
+    };
+    static aliases = ["project:backup:delete"];
+    static deprecateAliases = true;
+    async deleteResource() {
+        const projectBackupId = this.args["backup-id"];
+        const response = await this.apiClient.backup.deleteProjectBackup({
+            projectBackupId,
+        });
+        assertStatus(response, 204);
+    }
+}

package/dist/esm/commands/backup/download.d.ts

@@ -0,0 +1,29 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "@mittwald/api-client-commons";
+type Result = {
+    outputFilename: string;
+};
+export declare class Download extends ExecRenderBaseCommand<typeof Download, Result> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        format: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        password: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "generate-password": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "prompt-password": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        resume: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected getPassword(p: ProcessRenderer): Promise<string | undefined>;
+    protected exec(): Promise<Result>;
+    protected getFilename(headers: RawAxiosResponseHeaders | AxiosResponseHeaders): string;
+    protected render(executionResult: Result): ReactNode;
+}
+export {};