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

package/dist/esm/commands/database/mysql/port-forward.js

@@ -0,0 +1,44 @@
+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 * as cp from "child_process";
+import { Text } from "ink";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+import { getConnectionDetails } from "../../../lib/database/mysql/connect.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Flags } from "@oclif/core";
+export class PortForward extends ExecRenderBaseCommand {
+    static summary = "Forward the TCP port of a MySQL database to a local port";
+    static flags = {
+        ...processFlags,
+        port: Flags.integer({
+            summary: "The local TCP port to forward to",
+            default: 3306,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        const p = makeProcessRenderer(this.flags, "Port-forwarding a MySQL database");
+        const { sshUser, sshHost, hostname, database } = await getConnectionDetails(this.apiClient, databaseId, p);
+        const { port } = this.flags;
+        p.complete(_jsxs(Text, { children: ["Forwarding MySQL database ", _jsx(Value, { children: database }), " to local port", " ", _jsx(Value, { children: port }), ". Use CTRL+C to cancel."] }));
+        const sshArgs = [
+            "-T",
+            "-L",
+            `${port}:${hostname}:3306`,
+            "-l",
+            sshUser,
+            sshHost,
+            "cat",
+            "/dev/zero",
+        ];
+        cp.spawnSync("ssh", sshArgs, {
+            stdio: ["ignore", process.stdout, process.stderr],
+        });
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}

package/dist/esm/commands/database/mysql/shell.d.ts

@@ -0,0 +1,14 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Shell extends ExecRenderBaseCommand<typeof Shell, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        "mysql-password": 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>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+}

package/dist/esm/commands/database/mysql/shell.js

@@ -0,0 +1,39 @@
+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 * as cp from "child_process";
+import { Text } from "ink";
+import { mysqlArgs, mysqlConnectionFlags, withMySQLId, } from "../../../lib/database/mysql/flags.js";
+import { getConnectionDetailsWithPassword } from "../../../lib/database/mysql/connect.js";
+export class Shell extends ExecRenderBaseCommand {
+    static summary = "Connect to a MySQL database via the MySQL shell";
+    static flags = {
+        ...processFlags,
+        ...mysqlConnectionFlags,
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args, this.config);
+        const p = makeProcessRenderer(this.flags, "Starting a MySQL shell");
+        const { sshUser, sshHost, user, hostname, database, password } = await getConnectionDetailsWithPassword(this.apiClient, databaseId, p, this.flags);
+        p.complete(_jsx(Text, { children: "Starting MySQL shell -- get ready..." }));
+        const sshArgs = [
+            "-t",
+            "-l",
+            sshUser,
+            sshHost,
+            "mysql",
+            "-h",
+            hostname,
+            "-u",
+            user,
+            "-p" + password,
+            database,
+        ];
+        cp.spawnSync("ssh", sshArgs, { stdio: "inherit" });
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}

package/dist/esm/commands/database/mysql/user/get.d.ts

@@ -1,3 +1,14 @@
-import { GeneratedDatabaseGetMysqlUser } from "../../../../generated/database/getMysqlUser.js";
-export default class Get extends GeneratedDatabaseGetMysqlUser {
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../../GetBaseCommand.js";
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlUser"]>>;
+export default class Get extends GetBaseCommand<typeof Get, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
 }
+export {};

package/dist/esm/commands/database/mysql/user/get.js

@@ -1,6 +1,19 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedDatabaseGetMysqlUser } from "../../../../generated/database/getMysqlUser.js";
-export default class Get extends GeneratedDatabaseGetMysqlUser {
+import { GetBaseCommand } from "../../../../GetBaseCommand.js";
+import { Args } from "@oclif/core";
+export default class Get extends GetBaseCommand {
+    static description = "Get a MySQL user.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        id: Args.string({
+            description: "ID of the MySQL user to be retrieved.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.database.getMysqlUser({
+            pathParameters: { id: this.args.id },
+        });
+    }
 }

package/dist/esm/commands/database/mysql/user/list.d.ts

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

package/dist/esm/commands/database/mysql/user/list.js

@@ -1,6 +1,42 @@
-import { GeneratedDatabaseListMysqlUsers, } from "../../../../generated/database/listMysqlUsers.js";
-export default class List extends GeneratedDatabaseListMysqlUsers {
+import { ListBaseCommand } from "../../../../ListBaseCommand.js";
+import { Flags } from "@oclif/core";
+export class List extends ListBaseCommand {
+    static description = "List MySQL users belonging to a database.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "database-id": Flags.string({
+            description: "ID of the MySQL database to list users for.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            databaseId: this.flags["database-id"],
+        };
+        return await this.apiClient.database.listMysqlUsers({
+            pathParameters: pathParams,
+        });
+    }
     mapData(data) {
         return data;
     }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            name: {},
+            description: {},
+            mainUser: {
+                header: "Main user",
+                get: (i) => (i.mainUser ? "yes" : "no"),
+            },
+            enabled: { get: (item) => (item.disabled ? "no" : "yes") },
+            externalAccess: {
+                header: "External access",
+                get: (i) => (i.externalAccess ? "yes" : "no"),
+            },
+            createdAt: baseColumns.createdAt,
+        };
+    }
 }

package/dist/esm/commands/database/mysql/versions.d.ts

@@ -1,9 +1,19 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
-import { GeneratedDatabaseListMysqlVersions, Response } from "../../../generated/database/listMysqlVersions.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2MysqlVersions.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDatabaseListMysqlVersions<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlVersions.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlVersions"]>>;
+export declare class Versions extends ListBaseCommand<typeof Versions, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseMySqlVersion[];
+    protected getColumns(): ListColumns<ResponseItem>;
 }
 export {};

package/dist/esm/commands/database/mysql/versions.js

@@ -1,6 +1,23 @@
-import { GeneratedDatabaseListMysqlVersions, } from "../../../generated/database/listMysqlVersions.js";
-export default class List extends GeneratedDatabaseListMysqlVersions {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+export class Versions extends ListBaseCommand {
+    static description = "List available MySQL versions.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        return await this.apiClient.database.listMysqlVersions({
+            pathParameters: {},
+        });
+    }
     mapData(data) {
         return data;
     }
+    getColumns() {
+        return {
+            id: { header: "ID" },
+            name: {},
+            version: { get: (item) => item.number },
+        };
+    }
 }

package/dist/esm/commands/database/redis/get.d.ts

@@ -1,3 +1,16 @@
-import { GeneratedDatabaseGetRedisDatabase } from "../../../generated/database/getRedisDatabase.js";
-export default class Get extends GeneratedDatabaseGetRedisDatabase {
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2RedisDatabasesId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getRedisDatabase"]>>;
+export declare class Get extends GetBaseCommand<typeof Get, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
 }
+export {};

package/dist/esm/commands/database/redis/get.js

@@ -1,6 +1,22 @@
-/* eslint-disable */
-/* prettier-ignore */
-/* This file is auto-generated with acg (@mittwald/api-code-generator) */
-import { GeneratedDatabaseGetRedisDatabase } from "../../../generated/database/getRedisDatabase.js";
-export default class Get extends GeneratedDatabaseGetRedisDatabase {
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+export class Get extends GetBaseCommand {
+    static description = "Get a Redis database.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        id: Args.string({
+            description: "ID of the Redis database to retrieve.",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.database.getRedisDatabase({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
 }

package/dist/esm/commands/database/redis/list.d.ts

@@ -1,9 +1,19 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
-import { GeneratedDatabaseListRedisDatabases, Response } from "../../../generated/database/listRedisDatabases.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdRedisDatabases.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDatabaseListRedisDatabases<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2ProjectsProjectIdRedisDatabases.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listRedisDatabases"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any> | import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+    };
+    getData(): Promise<Response>;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseRedisDatabase[];
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }
 export {};

package/dist/esm/commands/database/redis/list.js

@@ -1,6 +1,30 @@
-import { GeneratedDatabaseListRedisDatabases, } from "../../../generated/database/listRedisDatabases.js";
-export default class List extends GeneratedDatabaseListRedisDatabases {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List Redis databases belonging to a project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, this.flags, this.args, this.config);
+        return await this.apiClient.database.listRedisDatabases({
+            pathParameters: { projectId },
+        });
+    }
     mapData(data) {
         return data;
     }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            name: {},
+            version: {},
+            description: {},
+            hostname: {},
+            createdAt: baseColumns.createdAt,
+        };
+    }
 }

package/dist/esm/commands/database/redis/shell.d.ts

@@ -0,0 +1,13 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Shell extends ExecRenderBaseCommand<typeof Shell, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+}

package/dist/esm/commands/database/redis/shell.js

@@ -0,0 +1,26 @@
+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 * as cp from "child_process";
+import { Text } from "ink";
+import { getConnectionDetails } from "../../../lib/database/redis/connect.js";
+import { redisArgs, withRedisId } from "../../../lib/database/redis/flags.js";
+export class Shell extends ExecRenderBaseCommand {
+    static summary = "Connect to a Redis database via the redis-cli";
+    static flags = {
+        ...processFlags,
+    };
+    static args = { ...redisArgs };
+    async exec() {
+        const databaseId = await withRedisId(this.apiClient, this.flags, this.args, this.config);
+        const p = makeProcessRenderer(this.flags, "Starting a Redis shell");
+        const { sshUser, sshHost, hostname } = await getConnectionDetails(this.apiClient, databaseId, p);
+        p.complete(_jsx(Text, { children: "Starting Redis shell -- get ready..." }));
+        const sshArgs = ["-t", "-l", sshUser, sshHost, "redis-cli", "-h", hostname];
+        cp.spawnSync("ssh", sshArgs, { stdio: "inherit" });
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}

package/dist/esm/commands/database/redis/versions.d.ts

@@ -1,9 +1,17 @@
 import { Simplify } from "@mittwald/api-client-commons";
-import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SuccessfulResponse } from "../../../types.js";
-import { GeneratedDatabaseListRedisVersions, Response } from "../../../generated/database/listRedisVersions.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2RedisVersions.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedDatabaseListRedisVersions<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2RedisVersions.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listRedisVersions"]>>;
+export default class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseRedisVersion[];
 }
 export {};

package/dist/esm/commands/database/redis/versions.js

@@ -1,5 +1,15 @@
-import { GeneratedDatabaseListRedisVersions, } from "../../../generated/database/listRedisVersions.js";
-export default class List extends GeneratedDatabaseListRedisVersions {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+export default class List extends ListBaseCommand {
+    static description = "List available Redis versions.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        return await this.apiClient.database.listRedisVersions({
+            pathParameters: {},
+        });
+    }
     mapData(data) {
         return data;
     }

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/process/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>;
+}