@mittwald/cli 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/esm/Formatter.js

@@ -25,6 +25,9 @@ export class ListFormatter {
         };
     }
     log(output, columns, opts) {
+        if (output.length === 0) {
+            return;
+        }
         ux.table(output, columns, {
             printLine: console.log,
             ...opts,

package/dist/esm/ListBaseCommand.js

@@ -28,7 +28,12 @@ export class ListBaseCommand extends BaseCommand {
     }
     getColumns(data) {
         if (data.length === 0) {
-            return {};
+            return {
+                id: {
+                    header: "ID",
+                    minWidth: 36,
+                },
+            };
         }
         // define some default columns, can be overwritten by child class
         let columns = {

package/dist/esm/commands/domain/ownership/list.js

@@ -1,6 +1,7 @@
 import { GeneratedDomainListDomainOwnerships, } from "../../../generated/domain/listDomainOwnerships.js";
 export default class List extends GeneratedDomainListDomainOwnerships {
     mapData(data) {
+        console.log(data);
         return data;
     }
 }

package/dist/esm/commands/domain/virtualhost/create.d.ts

@@ -0,0 +1,26 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import IngressIngress = MittwaldAPIV2.Components.Schemas.IngressIngress;
+import DomainDomainOwnership = MittwaldAPIV2.Components.Schemas.DomainDomainOwnership;
+type CreateResult = {
+    ingress: IngressIngress;
+    ownership: DomainDomainOwnership | null;
+};
+export default class Create extends ExecRenderBaseCommand<typeof Create, CreateResult> {
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        hostname: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "path-to-dir": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "path-to-app": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "path-to-url": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<CreateResult>;
+    protected render({ ingress, ownership }: CreateResult): ReactNode;
+}
+export {};

package/dist/esm/commands/domain/virtualhost/create.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/react/process_flags.js";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Flags } from "@oclif/core";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { waitUntil } from "../../../lib/wait.js";
+import { Box } from "ink";
+import { DnsValidationErrors } from "../../../rendering/react/components/Ingress/DnsValidationErrors.js";
+import { DomainOwnership } from "../../../rendering/react/components/Ingress/DomainOwnership.js";
+export default class Create extends ExecRenderBaseCommand {
+    static description = "Create a new ingress";
+    static examples = [
+        {
+            description: "Create a new ingress, with the root path mapping to your project's root directory",
+            command: "<%= config.bin %> <%= command.id %> --hostname mw.example --path-to-dir /:/",
+        },
+        {
+            description: "Create a new ingress, with the root path mapping to an app",
+            command: "<%= config.bin %> <%= command.id %> --hostname mw.example --path-to-app /:3ecaf1a9-6eb4-4869-b811-8a13c3a2e745",
+        },
+        {
+            description: "Create a new ingress, with the root path mapping to a URL",
+            command: "<%= config.bin %> <%= command.id %> --hostname mw.example --path-to-url /:https://redirect.example",
+        },
+    ];
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        hostname: Flags.string({
+            description: "the hostname of the ingress",
+            required: true,
+        }),
+        "path-to-dir": Flags.string({
+            summary: "add a path mapping to a directory",
+            multiple: true,
+            description: "This flag can be used to map a specific URL path to a directory in your project's file system; the value for this flag should be the URL path and the filesystem path, separated by a colon, e.g. /:/ or /:/some/sub/path. You can specify this flag multiple times to map multiple paths to different directories, and also combine it with the other --path-to-* flags.",
+        }),
+        "path-to-app": Flags.string({
+            summary: "add a path mapping to an app",
+            description: "This flag can be used to map a specific URL path to an app; the value for this flag should be the URL path and the app ID, separated by a colon, e.g. /:3ecaf1a9-6eb4-4869-b811-8a13c3a2e745. You can specify this flag multiple times to map multiple paths to different apps, and also combine it with the other --path-to-* flags.",
+            multiple: true,
+        }),
+        "path-to-url": Flags.string({
+            summary: "add a path mapping to an external url",
+            multiple: true,
+            description: "This flag can be used to map a specific URL path to an external URL; the value for this flag should be the URL path and the external URL, separated by a colon, e.g. /:https://redirect.example. You can specify this flag multiple times to map multiple paths to different external URLs, and also combine it with the other --path-to-* flags.",
+        }),
+    };
+    async exec() {
+        const projectId = await withProjectId(this.apiClient, this.flags, this.args, this.config);
+        const process = makeProcessRenderer(this.flags, "Creating a new ingress");
+        const { hostname } = this.flags;
+        const paths = [];
+        for (const pathToDir of this.flags["path-to-dir"] ?? []) {
+            const [path, directory] = pathToDir.split(":");
+            paths.push({ path, target: { directory } });
+        }
+        for (const pathToApp of this.flags["path-to-app"] ?? []) {
+            const [path, installationId] = pathToApp.split(":");
+            paths.push({ path, target: { installationId } });
+        }
+        for (const pathToUrl of this.flags["path-to-url"] ?? []) {
+            const [path, url] = pathToUrl.split(":");
+            paths.push({ path, target: { url } });
+        }
+        const { id: ingressId } = await process.runStep("creating ingress", async () => {
+            const response = await this.apiClient.domain.ingressCreate({
+                data: {
+                    projectId,
+                    hostname,
+                    paths,
+                },
+            });
+            assertStatus(response, 201);
+            return response.data;
+        });
+        const [ingress, ownership] = await process.runStep("waiting for ingress to be ready", async () => {
+            return await waitUntil(async () => {
+                const response = await this.apiClient.domain.ingressGetSpecific({
+                    pathParameters: { ingressId },
+                });
+                if (response.status !== 200) {
+                    return null;
+                }
+                const ownershipResponse = await this.apiClient.domain.listDomainOwnerships({
+                    pathParameters: { projectId },
+                });
+                if (ownershipResponse.status === 200) {
+                    const ownership = ownershipResponse.data.find((o) => o.domain === hostname);
+                    if (ownership) {
+                        return [response.data, ownership];
+                    }
+                }
+                if (response.data.ips.v4.length === 0) {
+                    return null;
+                }
+                return [response.data, null];
+            });
+        });
+        process.complete(_jsxs(Success, { children: ["You virtual host for ", _jsx(Value, { children: hostname }), " was successfully created! \uD83D\uDE80", " ", ingress.ips.v4.length > 0
+                    ? "Please point your DNS records to the following IP addresses: " +
+                        ingress.ips.v4.join(", ")
+                    : "Please follow the instructions below to verify your domain ownership."] }));
+        return { ingress, ownership };
+    }
+    render({ ingress, ownership }) {
+        if (this.flags.quiet) {
+            this.log(ingress.id);
+        }
+        const output = [];
+        if (ingress.dnsValidationErrors.length > 0) {
+            output.push(_jsx(Box, { marginLeft: 2, children: _jsx(DnsValidationErrors, { ingress: ingress }) }, "dns"));
+        }
+        if (ownership) {
+            output.push(_jsx(Box, { marginLeft: 2, children: _jsx(DomainOwnership, { ownership: ownership }) }, "ownership"));
+        }
+        return output;
+    }
+}

package/dist/esm/commands/domain/virtualhost/delete.d.ts

@@ -0,0 +1,13 @@
+import { DeleteBaseCommand } from "../../../DeleteBaseCommand.js";
+export default 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: {
+        "virtual-host-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/esm/commands/domain/virtualhost/delete.js

@@ -0,0 +1,21 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { DeleteBaseCommand } from "../../../DeleteBaseCommand.js";
+import { Args } from "@oclif/core";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a virtual host";
+    static resourceName = "virtual host";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = {
+        "virtual-host-id": Args.string({
+            description: "ID of the virtual host to delete",
+            required: true,
+        }),
+    };
+    async deleteResource() {
+        const ingressId = this.args["virtual-host-id"];
+        const response = await this.apiClient.domain.ingressDelete({
+            pathParameters: { ingressId },
+        });
+        assertStatus(response, 204);
+    }
+}

package/dist/esm/commands/domain/virtualhost/get.d.ts

@@ -1,3 +1,14 @@
-import { GeneratedIngressGetSpecific } from "../../../generated/domain/ingressGetSpecific.js";
-export default class Get extends GeneratedIngressGetSpecific {
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { RenderBaseCommand } from "../../../rendering/react/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export type PathParams = MittwaldAPIV2.Paths.V2IngressesIngressId.Get.Parameters.Path;
+export declare class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        "ingress-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected render(): ReactNode;
 }

package/dist/esm/commands/domain/virtualhost/get.js

@@ -1,6 +1,86 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedIngressGetSpecific } from "../../../generated/domain/ingressGetSpecific.js";
-export default class Get extends GeneratedIngressGetSpecific {
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { Args } from "@oclif/core";
+import { RenderBaseCommand } from "../../../rendering/react/RenderBaseCommand.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { RenderJson } from "../../../rendering/react/json/RenderJson.js";
+import { useRenderContext } from "../../../rendering/react/context.js";
+import { SingleResult } from "../../../rendering/react/components/SingleResult.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Box, Text } from "ink";
+import { Header } from "../../../rendering/react/components/Header.js";
+import { DomainOwnership } from "../../../rendering/react/components/Ingress/DomainOwnership.js";
+import { DnsValidationErrors } from "../../../rendering/react/components/Ingress/DnsValidationErrors.js";
+const IngressOwnershipVerificationSummary = ({ ownership }) => {
+    return ownership ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "still required" }), _jsx(Text, { color: "gray", children: " (see instructions below)" })] })) : (_jsx(Text, { color: "green", children: "verified" }));
+};
+const IngressPath = ({ path }) => {
+    if ("directory" in path.target) {
+        return (_jsxs(Text, { children: ["->", " Local directory: ", _jsx(Value, { children: path.target.directory })] }));
+    }
+    if ("url" in path.target) {
+        return (_jsxs(Text, { children: ["->", " Redirect: ", _jsx(Value, { children: path.target.url })] }));
+    }
+    if ("installationId" in path.target) {
+        const { apiClient } = useRenderContext();
+        const installation = usePromise((id) => apiClient.app.getAppinstallation({
+            pathParameters: { appInstallationId: id },
+        }), [path.target.installationId]);
+        assertStatus(installation, 200);
+        const app = usePromise((id) => apiClient.app.getApp({ pathParameters: { appId: id } }), [installation.data.appId]);
+        assertStatus(app, 200);
+        return (_jsxs(Text, { children: ["->", " App: ", _jsx(Value, { children: app.data.name }), ", installed at", " ", _jsx(Value, { children: installation.data.installationPath })] }));
+    }
+};
+const IngressPaths = ({ ingress }) => {
+    const paths = {};
+    for (const path of ingress.paths) {
+        paths[path.path] = _jsx(IngressPath, { path: path });
+    }
+    return _jsx(SingleResult, { title: "Paths", rows: paths });
+};
+const GetIngress = ({ ingress }) => {
+    const { apiClient } = useRenderContext();
+    const ownerships = usePromise((projectId) => apiClient.domain.listDomainOwnerships({ pathParameters: { projectId } }), [ingress.projectId]);
+    assertStatus(ownerships, 200);
+    const ownership = ownerships.data.find((o) => o.domain === ingress.hostname);
+    const rows = {
+        "Virtual Host ID": _jsx(Value, { children: ingress.id }),
+        Hostname: _jsx(Value, { children: ingress.hostname }),
+        "Verification of ownership": (_jsx(IngressOwnershipVerificationSummary, { ownership: ownership })),
+        "IP addresses": _jsx(Value, { children: ingress.ips.v4.join("\n") }),
+    };
+    const sections = [
+        _jsx(SingleResult, { title: _jsxs(_Fragment, { children: ["VIRTUAL HOST DETAILS: ", _jsx(Value, { children: ingress.hostname })] }), rows: rows }, "primary"),
+        _jsx(IngressPaths, { ingress: ingress }, "paths"),
+    ];
+    if (ownership) {
+        sections.push(_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginY: 1, children: _jsx(Header, { title: "Pending ownership verification" }) }), _jsx(DomainOwnership, { ownership: ownership })] }, "ownership"));
+    }
+    if (ingress.dnsValidationErrors.length > 0) {
+        sections.push(_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginY: 1, children: _jsx(Header, { title: "DNS validation errors" }) }), _jsx(DnsValidationErrors, { ingress: ingress })] }, "dns-validation-errors"));
+    }
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: sections }));
+};
+export class Get extends RenderBaseCommand {
+    static description = "Get a virtual host.";
+    static flags = { ...GetBaseCommand.baseFlags };
+    static args = {
+        "ingress-id": Args.string({
+            summary: "The ID of the ingress to get.",
+            required: true,
+        }),
+    };
+    render() {
+        const ingressId = this.args["ingress-id"];
+        const ingressResponse = usePromise((id) => this.apiClient.domain.ingressGetSpecific({
+            pathParameters: { ingressId: id },
+        }), [ingressId]);
+        assertStatus(ingressResponse, 200);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "ingress", data: ingressResponse.data });
+        }
+        return _jsx(GetIngress, { ingress: ingressResponse.data });
+    }
 }

package/dist/esm/commands/domain/virtualhost/list.d.ts

@@ -10,7 +10,7 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
     static description: string;
     static args: {};
     static flags: {
-        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        all: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     getData(): Promise<Response>;
     protected mapParams(input: PathParams): Promise<PathParams> | PathParams;

package/dist/esm/commands/domain/virtualhost/list.js

@@ -1,22 +1,25 @@
 import { ListBaseCommand } from "../../../ListBaseCommand.js";
 import { Flags } from "@oclif/core";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
 export class List extends ListBaseCommand {
-    static description = "List Ingresses the user has access to.";
+    static description = "List virtualhosts for a project.";
     static args = {};
     static flags = {
         ...ListBaseCommand.baseFlags,
-        "project-id": Flags.string({
-            description: "Project ID to filter by; if omitted this will list virtual hosts in all projects you have access to.",
-            required: false,
+        ...projectFlags,
+        all: Flags.boolean({
+            char: "a",
+            description: "List all virtual hosts that you have access to, regardless of project",
         }),
     };
     async getData() {
-        if (this.flags["project-id"]) {
-            return await this.apiClient.domain.ingressListForProject({
-                pathParameters: { projectId: this.flags["project-id"] },
-            });
+        if (this.flags.all) {
+            return await this.apiClient.domain.ingressListAccessible({});
         }
-        return await this.apiClient.domain.ingressListAccessible({});
+        const projectId = await withProjectId(this.apiClient, this.flags, this.args, this.config);
+        return await this.apiClient.domain.ingressListForProject({
+            pathParameters: { projectId },
+        });
     }
     mapParams(input) {
         return input;
@@ -26,7 +29,7 @@ export class List extends ListBaseCommand {
     }
     getColumns(data) {
         const baseColumns = super.getColumns(data);
-        return {
+        const columns = {
             id: baseColumns.id,
             projectId: { header: "Project ID" },
             hostname: {},
@@ -34,19 +37,32 @@ export class List extends ListBaseCommand {
                 get: (r) => r.paths
                     .map((p) => {
                     if ("directory" in p.target) {
-                        return `${p.path} -> directory (${p.target.directory})`;
+                        return `${p.path} → directory (${p.target.directory})`;
                     }
                     if ("url" in p.target) {
-                        return `${p.path} -> url (${p.target.url})`;
+                        return `${p.path} → url (${p.target.url})`;
                     }
-                    return `${p.path} -> app (${p.target.installationId})`;
+                    return `${p.path} → app (${p.target.installationId})`;
                 })
                     .join("\n"),
             },
+            status: {
+                header: "Status",
+                get: (r) => {
+                    if (r.dnsValidationErrors.length === 0) {
+                        return "ready";
+                    }
+                    return `${r.dnsValidationErrors.length} issues`;
+                },
+            },
             ips: {
                 header: "IP addresses",
                 get: (r) => r.ips.v4.join(", "),
             },
         };
+        if (!this.flags.all) {
+            delete columns.projectId;
+        }
+        return columns;
     }
 }

package/dist/esm/commands/mail/address/create.d.ts

@@ -1,20 +1,28 @@
 import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
 import { ReactNode } from "react";
-export default class Create extends ExecRenderBaseCommand<typeof Create, {
+import { ProcessRenderer } from "../../../rendering/react/process.js";
+type CreateResult = {
     addressId: string;
-}> {
+    generatedPassword: string | null;
+};
+export default class Create extends ExecRenderBaseCommand<typeof Create, CreateResult> {
+    static summary: string;
     static description: string;
     static flags: {
         address: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         "catch-all": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         "enable-spam-protection": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         quota: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+        "random-password": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
-    protected exec(): Promise<{
-        addressId: string;
-    }>;
-    protected render(executionResult: {
-        addressId: string;
-    }): ReactNode;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    protected getPassword(process: ProcessRenderer): Promise<[string, boolean]>;
+    protected exec(): Promise<CreateResult>;
+    protected render(executionResult: CreateResult): ReactNode;
 }
+export {};

package/dist/esm/commands/mail/address/create.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
@@ -6,34 +6,70 @@ import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCo
 import { makeProcessRenderer, processFlags, } from "../../../rendering/react/process_flags.js";
 import { Text } from "ink";
 import { Success } from "../../../rendering/react/components/Success.js";
+import * as crypto from "crypto";
+import { Value } from "../../../rendering/react/components/Value.js";
 export default class Create extends ExecRenderBaseCommand {
-    static description = "Create a new mail address";
+    static summary = "Create a new mail address";
+    static description = `\
+    When running this command with the --quiet flag, the output will contain the ID of the newly created address.
+    In addition, when run with --generated-password the output will be the ID of the newly created address, followed by a tab character and the generated password.`;
     static flags = {
         ...projectFlags,
         ...processFlags,
         address: Flags.string({
             char: "a",
-            description: "Mail address",
+            summary: "mail address",
             required: true,
         }),
         "catch-all": Flags.boolean({
-            description: "Make this a catch-all mail address",
+            description: "make this a catch-all mail address",
         }),
         "enable-spam-protection": Flags.boolean({
-            description: "Enable spam protection for this mailbox",
+            description: "enable spam protection for this mailbox",
             default: true,
             allowNo: true,
         }),
         quota: Flags.integer({
-            description: "Mailbox quota in mebibytes",
+            description: "mailbox quota in mebibytes",
             default: 1024,
         }),
+        password: Flags.string({
+            summary: "mailbox password",
+            description: "This is the password that should be used for the mailbox; if omitted, the command will prompt interactively for a password.\n\nCAUTION: providing this flag may log your password in your shell history!",
+        }),
+        "random-password": Flags.boolean({
+            summary: "generate a random password",
+            description: "This flag will cause the command to generate a random 32-character password for the mailbox; when running with --quiet, the address ID and the password will be printed to stdout, separated by a tab character.",
+        }),
     };
+    static examples = [
+        {
+            description: "Create non-interactively with password",
+            command: "$ read -s PASSWORD &&\n <%= config.bin %> <%= command.id %> --password $PASSWORD --address foo@bar.example",
+        },
+        {
+            description: "Create non-interactively with random password",
+            command: "<%= config.bin %> <%= command.id %> --random-password --address foo@bar.example",
+        },
+    ];
+    async getPassword(process) {
+        if (this.flags.password) {
+            return [this.flags.password, false];
+        }
+        if (this.flags["random-password"]) {
+            const generated = await process.runStep("generating random password", async () => {
+                return crypto.randomBytes(32).toString("base64").substring(0, 32);
+            });
+            process.addInfo(_jsxs(Text, { children: ["generated password: ", _jsx(Value, { children: generated })] }));
+            return [generated, true];
+        }
+        return [await process.addInput(_jsx(Text, { children: "Mailbox password" }), true), false];
+    }
     async exec() {
         const { flags } = await this.parse(Create);
         const projectId = await withProjectId(this.apiClient, flags, {}, this.config);
         const process = makeProcessRenderer(flags, "Creating a new mail address");
-        const password = await process.addInput(_jsx(Text, { children: "Mailbox password" }), true);
+        const [password, passwordGenerated] = await this.getPassword(process);
         const response = await process.runStep("creating mail address", async () => {
             const response = await this.apiClient.mail.mailaddressCreate({
                 pathParameters: { projectId },
@@ -51,11 +87,17 @@ export default class Create extends ExecRenderBaseCommand {
             return response;
         });
         process.complete(_jsx(Success, { children: "Your mail address was successfully created." }));
-        return { addressId: response.data.id };
+        return {
+            addressId: response.data.id,
+            generatedPassword: passwordGenerated ? password : null,
+        };
     }
     render(executionResult) {
         if (this.flags.quiet) {
-            return executionResult.addressId;
+            if (executionResult.generatedPassword) {
+                return (_jsxs(Text, { children: [executionResult.addressId, "\t", executionResult.generatedPassword] }));
+            }
+            return _jsx(Text, { children: executionResult.addressId });
         }
     }
 }

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

@@ -0,0 +1,13 @@
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+export default 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: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
+    };
+    protected deleteResource(): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { DeleteBaseCommand } from "../../DeleteBaseCommand.js";
+import { projectArgs } from "../../lib/project/flags.js";
+import { withOrgId } from "../../lib/org/flags.js";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete an organization";
+    static resourceName = "organization";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = { ...projectArgs };
+    async deleteResource() {
+        const customerId = await withOrgId(this.apiClient, {}, this.args, this.config);
+        const response = await this.apiClient.customer.deleteCustomer({
+            pathParameters: { customerId },
+        });
+        assertStatus(response, 200);
+    }
+}