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

package/dist/esm/commands/domain/dnszone/update.d.ts

@@ -0,0 +1,28 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type UpdateResult = void;
+export default class Update extends ExecRenderBaseCommand<typeof Update, UpdateResult> {
+    static description: string;
+    static args: {
+        "record-set": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+        "dnszone-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        managed: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        record: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        unset: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        ttl: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+    };
+    protected exec(): Promise<UpdateResult>;
+    private unsetRecordSet;
+    private resetRecordSetToManaged;
+    protected render(): ReactNode;
+}
+export {};

package/dist/esm/commands/domain/dnszone/update.js

@@ -0,0 +1,176 @@
+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 { Args, Flags } from "@oclif/core";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { dnsZoneArgs, withDnsZoneId, } from "../../../lib/domain/dnszone/flags.js";
+import { projectFlags } from "../../../lib/project/flags.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+export default class Update extends ExecRenderBaseCommand {
+    static description = "Updates a record set of a DNS zone";
+    static args = {
+        ...dnsZoneArgs,
+        "record-set": Args.string({
+            description: "The record type of the record set",
+            options: ["a", "mx", "txt", "srv", "cname"],
+            required: true,
+        }),
+    };
+    static examples = [
+        {
+            description: "Set A and AAAA records",
+            command: "<%= config.bin %> <%= command.id %> domain.example a --record 203.0.113.123 --record 2001:db8::1",
+        },
+        {
+            description: "Set MX records",
+            command: '<%= config.bin %> <%= command.id %> domain.example mx --record "10 mail1.domain.example" --record "20 mail2.domain.example"',
+        },
+    ];
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        managed: Flags.boolean({
+            description: "Reset this record set to fully-managed (only for A and MX records)",
+            required: false,
+            default: false,
+        }),
+        record: Flags.string({
+            summary: "The records to set; may not be used with --managed",
+            description: `The format depends on the record set type:
+
+- for "a" records, this parameter should contain a IPv4 or IPv6 address (we will automatically create an A or AAAA record)
+- for "mx" records, the parameter should be formatted as "<priority> <fqdn>", e.g. "10 mail.example.com"
+- for "srv" records, the parameter should be formatted as "<priority> <weight> <port> <fqdn>", e.g. "10 1 5060 sip.example.com"
+- for "txt" records, the parameter should be a string containing the TXT record value.`,
+            multiple: true,
+            required: false,
+            default: undefined,
+            exclusive: ["managed", "unset"],
+        }),
+        unset: Flags.boolean({
+            summary: "Set this to remove all records from the record set",
+            exclusive: ["managed", "record"],
+        }),
+        ttl: Flags.integer({
+            description: "The TTL of the record set; omit to use the default TTL",
+            required: false,
+            default: undefined,
+        }),
+    };
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "Updating DNS record set");
+        const dnsZoneId = await withDnsZoneId(this.apiClient, Update, this.flags, this.args, this.config);
+        const recordSet = this.args["record-set"];
+        const { managed, unset, ttl, record = [] } = this.flags;
+        const settings = {
+            ttl: ttl ? { seconds: ttl } : { auto: true },
+        };
+        if (managed) {
+            await this.resetRecordSetToManaged(process, recordSet, dnsZoneId);
+            return;
+        }
+        if (unset) {
+            await this.unsetRecordSet(process, dnsZoneId, recordSet);
+            return;
+        }
+        if (recordSet === "a") {
+            await process.runStep("updating record set", async () => {
+                const r = await this.apiClient.domain.dnsUpdateRecordSet({
+                    dnsZoneId,
+                    recordSet,
+                    data: {
+                        aaaa: record.filter((r) => !looksLikeIPv4(r)),
+                        a: record.filter(looksLikeIPv4),
+                        settings,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        else if (recordSet === "mx") {
+            await process.runStep("updating record set", async () => {
+                const r = await this.apiClient.domain.dnsUpdateRecordSet({
+                    dnsZoneId,
+                    recordSet,
+                    data: {
+                        records: record.map((r) => {
+                            const [priority, fqdn] = r.split(" ");
+                            return {
+                                fqdn,
+                                priority: parseInt(priority, 10),
+                            };
+                        }),
+                        settings,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        else if (recordSet === "srv") {
+            await process.runStep("updating record set", async () => {
+                const r = await this.apiClient.domain.dnsUpdateRecordSet({
+                    dnsZoneId,
+                    recordSet,
+                    data: {
+                        records: record.map((r) => {
+                            const [priority, weight, port, fqdn] = r.split(" ");
+                            return {
+                                fqdn,
+                                priority: parseInt(priority, 10),
+                                weight: parseInt(weight, 10),
+                                port: parseInt(port, 10),
+                            };
+                        }),
+                        settings,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        else if (recordSet === "txt") {
+            await process.runStep("updating record set", async () => {
+                const r = await this.apiClient.domain.dnsUpdateRecordSet({
+                    dnsZoneId,
+                    recordSet,
+                    data: {
+                        entries: record,
+                        settings,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        process.complete(_jsx(Success, { children: "DNS record set successfully set." }));
+        return;
+    }
+    async unsetRecordSet(process, dnsZoneId, recordSet) {
+        await process.runStep("unsetting record set", async () => {
+            const r = await this.apiClient.domain.dnsUpdateRecordSet({
+                dnsZoneId,
+                recordSet,
+            });
+            assertStatus(r, 204);
+        });
+        process.complete(_jsx(Success, { children: "DNS record set successfully unset." }));
+        return;
+    }
+    async resetRecordSetToManaged(process, recordSet, dnsZoneId) {
+        await process.runStep("resetting record set", async () => {
+            if (recordSet !== "a" && recordSet !== "mx") {
+                throw new Error("managed DNS records are only available for A and MX records");
+            }
+            const r = await this.apiClient.domain.dnsSetRecordSetManaged({
+                dnsZoneId,
+                recordSet,
+            });
+            assertStatus(r, 204);
+        });
+        process.complete(_jsx(Success, { children: "DNS record set successfully reset to fully managed." }));
+    }
+    render() {
+        return undefined;
+    }
+}
+function looksLikeIPv4(r) {
+    return r.match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/) !== null;
+}

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

@@ -1,3 +1,16 @@
-import { GeneratedDomainGetDomain } from "../../generated/domain/getDomain.js";
-export default class Get extends GeneratedDomainGetDomain {
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import React from "react";
+import DomainDomain = MittwaldAPIV2.Components.Schemas.DomainDomain;
+export declare class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    static args: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+        "domain-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+    protected render(): React.ReactNode;
+    protected getDomain(): Promise<DomainDomain>;
 }

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

@@ -1,6 +1,32 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedDomainGetDomain } from "../../generated/domain/getDomain.js";
-export default class Get extends GeneratedDomainGetDomain {
+import { jsx as _jsx } from "react/jsx-runtime";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { usePromise } from "@mittwald/react-use-promise";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { domainArgs, withDomainId } from "../../lib/domain/flags.js";
+import { DomainDetails } from "../../rendering/react/components/Domain/DomainDetails.js";
+export class Get extends RenderBaseCommand {
+    static description = "gets a specific domain";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        ...domainArgs,
+    };
+    render() {
+        const domain = usePromise(() => this.getDomain(), []);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "domain", data: domain });
+        }
+        return _jsx(DomainDetails, { domain: domain });
+    }
+    async getDomain() {
+        const domainId = await withDomainId(this.apiClient, Get, this.flags, this.args, this.config);
+        const response = await this.apiClient.domain.getDomain({
+            domainId,
+        });
+        assertStatus(response, 200);
+        return response.data;
+    }
 }

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

@@ -1,9 +1,18 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
 import { SuccessfulResponse } from "../../types.js";
-import { GeneratedDomainListDomains, Response } from "../../generated/domain/listDomains.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdDomains.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDomainListDomains<ResponseItem> {
-    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DomainDomain[];
+import { ListColumns } from "../../Formatter.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2Domains.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["listDomains"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): ResponseItem[] | Promise<ResponseItem[]>;
+    protected getColumns(): ListColumns<ResponseItem>;
 }
 export {};

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

@@ -1,6 +1,43 @@
-import { GeneratedDomainListDomains, } from "../../generated/domain/listDomains.js";
-export default class List extends GeneratedDomainListDomains {
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { projectFlags } from "../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List domains belonging to a project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return this.apiClient.domain.listDomains({
+            queryParameters: { projectId },
+        });
+    }
     mapData(data) {
         return data;
     }
+    getColumns() {
+        return {
+            id: {
+                header: "ID",
+                get: (r) => r.domainId,
+            },
+            domain: {
+                header: "Domain",
+            },
+            owner: {
+                header: "Owner",
+                get: (r) => r.handles.ownerC.current.handleFields?.find((f) => f.name === "name")
+                    ?.value,
+            },
+            connected: {
+                header: "Connected",
+            },
+            nameservers: {
+                header: "Nameservers",
+                extended: true,
+                get: (r) => r.nameservers.join(", "),
+            },
+        };
+    }
 }

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

@@ -0,0 +1,25 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import IngressIngress = MittwaldAPIV2.Components.Schemas.IngressIngress;
+type CreateResult = {
+    ingress: IngressIngress;
+};
+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>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<CreateResult>;
+    protected render({ ingress }: CreateResult): ReactNode;
+}
+export {};

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

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } 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 { 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";
+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 this.withProjectId(Create);
+        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.ingressCreateIngress({
+                data: {
+                    projectId,
+                    hostname,
+                    paths,
+                },
+            });
+            assertStatus(response, 201);
+            return response.data;
+        });
+        const ingress = await process.runStep("waiting for ingress to be ready", async () => {
+            return await waitUntil(async () => {
+                const response = await this.apiClient.domain.ingressGetIngress({
+                    ingressId,
+                });
+                if (response.status !== 200 || response.data.ips.v4.length === 0) {
+                    return null;
+                }
+                return response.data;
+            });
+        });
+        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 };
+    }
+    render({ ingress }) {
+        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"));
+        }
+        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.ingressDeleteIngress({
+            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").Flag<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,74 @@
-/* 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, jsxs as _jsxs, Fragment as _Fragment } 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 { DnsValidationErrors } from "../../../rendering/react/components/Ingress/DnsValidationErrors.js";
+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({
+            appInstallationId: id,
+        }), [path.target.installationId]);
+        assertStatus(installation, 200);
+        const app = usePromise((id) => apiClient.app.getApp({ 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 rows = {
+        "Virtual Host ID": _jsx(Value, { children: ingress.id }),
+        Hostname: _jsx(Value, { children: ingress.hostname }),
+        "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 (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.ingressGetIngress({
+            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

@@ -4,16 +4,15 @@ import { SuccessfulResponse } from "../../../types.js";
 import { ListBaseCommand } from "../../../ListBaseCommand.js";
 import { ListColumns } from "../../../Formatter.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2Ingresses.Get.Responses.$200.Content.ApplicationJson[number]>;
-export type PathParams = MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Path;
-export type Response = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["ingressListAccessible"]>>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["domain"]["ingressListIngresses"]>>;
 export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
     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>;
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
     };
     getData(): Promise<Response>;
-    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): ResponseItem[] | Promise<ResponseItem[]>;
     protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }