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

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

@@ -0,0 +1,21 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Invite extends ExecRenderBaseCommand<typeof Invite, {
+    inviteId: string;
+}> {
+    static description: string;
+    static flags: {
+        email: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        role: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        message: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        expires: 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 getExpirationDate(): Date | undefined;
+    protected exec(): Promise<{
+        inviteId: string;
+    }>;
+    protected render(executionResult: {
+        inviteId: string;
+    }): ReactNode;
+}

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

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { orgFlags, withOrgId } from "../../lib/org/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import parseDuration from "parse-duration";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+const inviteFlags = {
+    email: Flags.string({
+        description: "The email address of the user to invite.",
+        required: true,
+    }),
+    role: Flags.string({
+        description: "The role of the user to invite.",
+        options: ["owner", "member", "accountant"],
+        default: "member",
+    }),
+    message: Flags.string({
+        description: "A message to include in the invitation email.",
+    }),
+    expires: Flags.string({
+        description: "An interval after which the invitation expires (examples: 30m, 30d, 1y).",
+    }),
+};
+export class Invite extends ExecRenderBaseCommand {
+    static description = "Invite a user to an organization.";
+    static flags = { ...orgFlags, ...processFlags, ...inviteFlags };
+    getExpirationDate() {
+        if (!this.flags.expires) {
+            return undefined;
+        }
+        const d = new Date();
+        const i = parseDuration(this.flags.expires);
+        if (!i) {
+            throw new Error("could not parse duration: " + this.flags.expires);
+        }
+        return new Date(d.getTime() + i);
+    }
+    async exec() {
+        const process = makeProcessRenderer(this.flags, "Inviting user to organization");
+        const customerId = await withOrgId(this.apiClient, this.flags, this.args, this.config);
+        const invite = await process.runStep("Creating invite", async () => {
+            const result = await this.apiClient.customer.createCustomerInvite({
+                pathParameters: { customerId },
+                data: {
+                    mailAddress: this.flags.email,
+                    role: this.flags.role,
+                    message: this.flags.message,
+                    membershipExpiresAt: this.getExpirationDate()?.toJSON(),
+                },
+            });
+            assertStatus(result, 201);
+            return result;
+        });
+        process.complete(_jsxs(Success, { children: ["The user ", _jsx(Value, { children: this.flags.email }), " was successfully invited to your organization!"] }));
+        return { inviteId: invite.data.id };
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.inviteId;
+        }
+        return undefined;
+    }
+}

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

@@ -1,11 +1,20 @@
 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 { GeneratedCustomerListCustomers, Response } from "../../generated/customer/listCustomers.js";
 import { ListColumns } from "../../Formatter.js";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
 type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2Customers.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedCustomerListCustomers<ResponseItem> {
+export type PathParams = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listCustomers"]>>;
+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>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.CustomerCustomer[];
-    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+    protected getColumns(): ListColumns<ResponseItem>;
 }
 export {};

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

@@ -1,14 +1,32 @@
-import { GeneratedCustomerListCustomers, } from "../../generated/customer/listCustomers.js";
-export default class List extends GeneratedCustomerListCustomers {
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class List extends ListBaseCommand {
+    static description = "Get all organizations the authenticated user has access to.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.customer.listCustomers({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
     mapData(data) {
         return data;
     }
-    getColumns(data) {
+    getColumns() {
         return {
             id: {
+                header: "ID",
                 get: (r) => r.customerId,
                 minWidth: 36,
             },
+            customerNumber: {
+                header: "Customer No.",
+            },
             name: {},
             owner: {
                 get: (r) => {

package/dist/esm/commands/org/membership/list-own.d.ts

@@ -1,9 +1,49 @@
 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 { GeneratedCustomerListCustomerMemberships, Response } from "../../../generated/customer/listCustomerMemberships.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2CustomerMemberships.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedCustomerListCustomerMemberships<ResponseItem> {
-    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.MembershipCustomerMembership[];
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
+import CustomerCustomer = MittwaldAPIV2.Components.Schemas.CustomerCustomer;
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2CustomerMemberships.Get.Responses.$200.Content.ApplicationJson[number]> & {
+    org?: CustomerCustomer;
+};
+export type PathParams = MittwaldAPIV2.Paths.V2CustomerMemberships.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listCustomerMemberships"]>>;
+export declare class ListOwn extends ListBaseCommand<typeof ListOwn, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): Promise<(MittwaldAPIV2.Components.Schemas.MembershipCustomerMembership | {
+        org: {
+            activeSuspension?: {
+                createdAt?: string | undefined;
+            } | undefined;
+            avatarRefId?: string | undefined;
+            categoryId?: string | undefined;
+            creationDate: string;
+            customerId: string;
+            customerNumber: string;
+            executingUserRoles?: MittwaldAPIV2.Components.Schemas.CustomerRole[] | undefined;
+            isInDefaultOfPayment?: boolean | undefined;
+            memberCount: number;
+            name: string;
+            owner?: MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
+            projectCount: number;
+            vatId?: string | undefined;
+            vatIdValidationState?: "pending" | "valid" | "invalid" | "unspecified" | undefined;
+        };
+        customerId: string;
+        expiresAt?: string | undefined;
+        id: string;
+        inviteId: string;
+        memberSince?: string | undefined;
+        role: MittwaldAPIV2.Components.Schemas.MembershipCustomerRoles;
+        userId: string;
+    })[]>;
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }
 export {};

package/dist/esm/commands/org/membership/list-own.js

@@ -1,6 +1,44 @@
-import { GeneratedCustomerListCustomerMemberships, } from "../../../generated/customer/listCustomerMemberships.js";
-export default class List extends GeneratedCustomerListCustomerMemberships {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { formatRelativeDate } from "../../../lib/viewhelpers/date.js";
+export class ListOwn extends ListBaseCommand {
+    static description = "List all organization memberships for the executing user.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.customer.listCustomerMemberships({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
     mapData(data) {
-        return data;
+        return Promise.all(data.map(async (item) => {
+            const { customerId } = item;
+            const org = await this.apiClient.customer.getCustomer({
+                pathParameters: { customerId },
+            });
+            if (org.status === 200) {
+                return { ...item, org: org.data };
+            }
+            return item;
+        }));
+    }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            role: {},
+            org: {
+                get: (item) => item.org?.name ?? "(unknown org)",
+            },
+            memberSince: {
+                header: "Member since",
+                get: (item) => formatRelativeDate(item.memberSince),
+            },
+        };
     }
 }

package/dist/esm/commands/org/membership/list.d.ts

@@ -1,9 +1,37 @@
 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 { GeneratedCustomerListMembershipsForCustomer, Response } from "../../../generated/customer/listMembershipsForCustomer.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2CustomersCustomerIdMemberships.Get.Responses.$200.Content.ApplicationJson[number]>;
-export default class List extends GeneratedCustomerListMembershipsForCustomer<ResponseItem> {
-    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.MembershipCustomerMembership[];
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { ListColumns } from "../../../Formatter.js";
+import UserUser = MittwaldAPIV2.Components.Schemas.UserUser;
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2CustomersCustomerIdMemberships.Get.Responses.$200.Content.ApplicationJson[number]> & {
+    user?: UserUser;
+};
+export type PathParams = MittwaldAPIV2.Paths.V2CustomersCustomerIdMemberships.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["customer"]["listMembershipsForCustomer"]>>;
+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"]): Promise<(MittwaldAPIV2.Components.Schemas.MembershipCustomerMembership | {
+        user: {
+            avatarRef?: string | undefined;
+            email?: string | undefined;
+            person: MittwaldAPIV2.Components.Schemas.CommonsPerson;
+            phoneNumber?: string | undefined;
+            userId: string;
+        };
+        customerId: string;
+        expiresAt?: string | undefined;
+        id: string;
+        inviteId: string;
+        memberSince?: string | undefined;
+        role: MittwaldAPIV2.Components.Schemas.MembershipCustomerRoles;
+        userId: string;
+    })[]>;
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
 }
 export {};

package/dist/esm/commands/org/membership/list.js

@@ -1,6 +1,43 @@
-import { GeneratedCustomerListMembershipsForCustomer, } from "../../../generated/customer/listMembershipsForCustomer.js";
-export default class List extends GeneratedCustomerListMembershipsForCustomer {
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { orgFlags, withOrgId } from "../../../lib/org/flags.js";
+import { formatRelativeDate } from "../../../lib/viewhelpers/date.js";
+export class List extends ListBaseCommand {
+    static description = "List all memberships belonging to an organization.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...orgFlags,
+    };
+    async getData() {
+        const customerId = await withOrgId(this.apiClient, this.flags, this.args, this.config);
+        return await this.apiClient.customer.listMembershipsForCustomer({
+            pathParameters: { customerId },
+        });
+    }
     mapData(data) {
-        return data;
+        return Promise.all(data.map(async (item) => {
+            const { userId } = item;
+            const user = await this.apiClient.user.getUser({
+                pathParameters: { userId },
+            });
+            if (user.status === 200) {
+                return { ...item, user: user.data };
+            }
+            return item;
+        }));
+    }
+    getColumns(data) {
+        const baseColumns = super.getColumns(data);
+        return {
+            id: baseColumns.id,
+            role: {},
+            user: {
+                get: (item) => item.user?.email ?? "(unknown user)",
+            },
+            memberSince: {
+                header: "Member since",
+                get: (item) => formatRelativeDate(item.memberSince),
+            },
+        };
     }
 }

package/dist/esm/commands/org/membership/revoke.d.ts

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

package/dist/esm/commands/org/membership/revoke.js

@@ -0,0 +1,43 @@
+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 { Args } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+export class Revoke extends ExecRenderBaseCommand {
+    static description = "Revoke a user's membership to an organization";
+    static flags = { ...processFlags };
+    static args = {
+        "membership-id": Args.string({
+            description: "The ID of the membership to revoke",
+            required: true,
+        }),
+    };
+    async exec() {
+        const membershipId = this.args["membership-id"];
+        const process = makeProcessRenderer(this.flags, "Revoking organization membership");
+        const user = await process.runStep("Fetching existing member", async () => {
+            const memberResponse = await this.apiClient.customer.getCustomerMembership({
+                pathParameters: { membershipId },
+            });
+            assertStatus(memberResponse, 200);
+            const userResponse = await this.apiClient.user.getUser({
+                pathParameters: { userId: memberResponse.data.userId },
+            });
+            assertStatus(userResponse, 200);
+            return userResponse.data;
+        });
+        await process.runStep("Revoking membership", async () => {
+            const response = await this.apiClient.customer.deleteCustomerMembership({
+                pathParameters: { membershipId },
+            });
+            assertStatus(response, 204);
+        });
+        process.complete(_jsxs(Success, { children: ["User ", _jsx(Value, { children: user.email }), " was removed from the organization."] }));
+        return { deleted: true };
+    }
+    render() {
+        return undefined;
+    }
+}

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

@@ -6,7 +6,7 @@ import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseComma
 import { Text } from "ink";
 import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
-import { makeProcessRenderer, processFlags, } from "../../rendering/react/process_flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
 import { waitUntil } from "../../lib/wait.js";
 import { Context } from "../../lib/context.js";
 export default class Create extends ExecRenderBaseCommand {

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

@@ -15,7 +15,7 @@ import { assertStatus } from "@mittwald/api-client-commons";
 import { ByteFormat } from "../../rendering/react/components/ByteFormat.js";
 import { RenderJson } from "../../rendering/react/json/RenderJson.js";
 import Link from "ink-link";
-import { ProjectStatus } from "../../rendering/react/components/ProjectStatus.js";
+import { ProjectStatus } from "../../rendering/react/components/Project/ProjectStatus.js";
 const ProjectSpecs = ({ projectId, spec }) => {
     if ("cpu" in spec) {
         const { apiClient } = useRenderContext();
@@ -40,9 +40,13 @@ const ProjectCustomer = ({ customer }) => {
 const GetProject = ({ response }) => {
     const { apiClient } = useRenderContext();
     const customer = usePromise((id) => apiClient.customer.getCustomer({ pathParameters: { customerId: id } }), [response.customerId]);
+    const vhosts = usePromise((id) => apiClient.domain.ingressListForProject({
+        pathParameters: { projectId: id },
+    }), [response.id]);
     assertStatus(customer, 200);
-    const host = `${response.shortId}.project.space`;
-    const url = `https://${host}`;
+    assertStatus(vhosts, 200);
+    const host = vhosts.data.find((h) => h.isDefault)?.hostname;
+    const url = host ? `https://${host}` : undefined;
     const rows = {
         "Project ID": _jsx(IDAndShortID, { object: response }),
         "Created At": _jsx(CreatedAt, { object: response }),
@@ -52,7 +56,7 @@ const GetProject = ({ response }) => {
     const sections = [
         _jsx(SingleResult, { title: _jsxs(_Fragment, { children: ["PROJECT DETAILS: ", _jsx(Value, { children: response.description })] }), rows: rows }, "primary"),
         _jsx(SingleResult, { title: "Access", rows: {
-                "HTTP(S)": (_jsx(Link, { url: url, children: _jsx(Value, { children: host }) })),
+                "HTTP(S)": host && url ? (_jsx(Link, { url: url, children: _jsx(Value, { children: host }) })) : (_jsx(Value, { notSet: true })),
                 "SSH/SFTP": (_jsxs(Text, { children: [_jsxs(Value, { children: ["ssh.", response.clusterID, ".", response.clusterDomain] }), " ", _jsx(Text, { color: "gray", children: "(Use the \"project ssh\" command to connect directly using the CLI)" })] })),
             } }, "access"),
     ];

package/dist/esm/commands/project/list-react.js

@@ -6,7 +6,7 @@ import { useRenderContext } from "../../rendering/react/context.js";
 import { Table } from "../../rendering/react/components/Table/index.js";
 import { UsePromiseRenderSetup } from "../../rendering/setup/usePromiseSetup.js";
 import { TableRenderSetup } from "../../rendering/setup/TableRenderSetup.js";
-import { ProjectStatus } from "../../rendering/react/components/ProjectStatus.js";
+import { ProjectStatus } from "../../rendering/react/components/Project/ProjectStatus.js";
 const usePromiseSetup = new UsePromiseRenderSetup();
 const tableSetupInstance = new TableRenderSetup();
 export default class List extends RenderBaseCommand {

package/dist/esm/commands/user/api-token/create.js

@@ -3,7 +3,7 @@ import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import parseDuration from "parse-duration";
 import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
-import { makeProcessRenderer, processFlags, } from "../../../rendering/react/process_flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
 import { Success } from "../../../rendering/react/components/Success.js";
 import { Newline, Text } from "ink";
 import { Value } from "../../../rendering/react/components/Value.js";

package/dist/esm/commands/user/ssh-key/create.js

@@ -7,7 +7,7 @@ import * as os from "os";
 import * as fs from "fs/promises";
 import parseDuration from "parse-duration";
 import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
-import { makeProcessRenderer, processFlags, } from "../../../rendering/react/process_flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
 import { Success } from "../../../rendering/react/components/Success.js";
 import { Filename } from "../../../rendering/react/components/Filename.js";
 import { Text } from "ink";

package/dist/esm/generated/domain/listDomainOwnerships.d.ts

@@ -6,7 +6,7 @@ export declare abstract class GeneratedDomainListDomainOwnerships<TItem extends
     static description: string;
     static args: {};
     static flags: {
-        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any> | import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
     };
     getData(): Promise<Response>;
     protected mapParams(input: PathParams): Promise<PathParams> | PathParams;

package/dist/esm/generated/domain/listDomainOwnerships.js

@@ -1,18 +1,15 @@
-import { Flags } from "@oclif/core";
 import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { projectFlags, withProjectId } from "../../lib/project/flags.js";
 export class GeneratedDomainListDomainOwnerships extends ListBaseCommand {
     static description = "List all domain ownerships of a project.";
     static args = {};
     static flags = {
         ...ListBaseCommand.baseFlags,
-        "project-id": Flags.string({
-            description: "undefined",
-            required: true,
-        }),
+        ...projectFlags,
     };
     async getData() {
         const pathParams = {
-            projectId: this.flags["project-id"],
+            projectId: await withProjectId(this.apiClient, this.flags, this.args, this.config),
         };
         return await this.apiClient.domain.listDomainOwnerships({
             pathParameters: await this.mapParams(pathParams),

package/dist/esm/lib/context_flags.js

@@ -6,7 +6,8 @@ export function makeFlagSet(name, char, normalize = (_, id) => id) {
         [flagName]: Flags.string({
             char,
             required: false,
-            description: `ID or short ID of a ${name}; this flag is optional if a default ${name} is set in the context`,
+            summary: `ID or short ID of a ${name}; this flag is optional if a default ${name} is set in the context`,
+            description: `May contain a short ID or a full ID of a ${name}; you can also use the "<%= config.bin %> context set --${name}-id=<VALUE>" command to persistently set a default ${name} for all commands that accept this flag.`,
         }),
     };
     const args = {

package/dist/esm/lib/database/common.d.ts

@@ -0,0 +1,8 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ProcessRenderer } from "../../rendering/process/process.js";
+import ProjectProject = MittwaldAPIV2.Components.Schemas.ProjectProject;
+import SignupAccount = MittwaldAPIV2.Components.Schemas.SignupAccount;
+export declare function getUser(apiClient: MittwaldAPIV2Client, p: ProcessRenderer): Promise<SignupAccount>;
+export declare function getProject(apiClient: MittwaldAPIV2Client, p: ProcessRenderer, database: {
+    projectId: string;
+}): Promise<ProjectProject>;

package/dist/esm/lib/database/common.js

@@ -0,0 +1,17 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+export async function getUser(apiClient, p) {
+    return await p.runStep("fetching user", async () => {
+        const r = await apiClient.user.getOwnAccount();
+        assertStatus(r, 200);
+        return r.data;
+    });
+}
+export async function getProject(apiClient, p, database) {
+    return await p.runStep("fetching project", async () => {
+        const r = await apiClient.project.getProject({
+            pathParameters: { id: database.projectId },
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}

package/dist/esm/lib/database/mysql/connect.d.ts

@@ -0,0 +1,19 @@
+import { ProcessRenderer } from "../../../rendering/process/process.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getConnectionDetailsWithPassword(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: {
+    "mysql-password": string | undefined;
+}): Promise<{
+    password: string;
+    hostname: string;
+    database: string;
+    user: string;
+    sshHost: string;
+    sshUser: string;
+}>;
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer): Promise<{
+    hostname: string;
+    database: string;
+    user: string;
+    sshHost: string;
+    sshUser: string;
+}>;

package/dist/esm/lib/database/mysql/connect.js

@@ -0,0 +1,50 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { getProject, getUser } from "../common.js";
+export async function getConnectionDetailsWithPassword(apiClient, databaseId, p, flags) {
+    const password = await getPassword(p, flags);
+    return {
+        ...(await getConnectionDetails(apiClient, databaseId, p)),
+        password,
+    };
+}
+export async function getConnectionDetails(apiClient, databaseId, p) {
+    const database = await getDatabase(apiClient, p, databaseId);
+    const databaseUser = await getDatabaseUser(apiClient, p, databaseId);
+    const project = await getProject(apiClient, p, database);
+    const user = await getUser(apiClient, p);
+    return {
+        hostname: database.hostname,
+        database: database.name,
+        user: databaseUser.name,
+        sshHost: `ssh.${project.clusterID}.${project.clusterDomain}`,
+        sshUser: `${user.email}@${project.shortId}`,
+    };
+}
+async function getPassword(p, flags) {
+    if (flags["mysql-password"]) {
+        return flags["mysql-password"];
+    }
+    return await p.addInput("enter password for MySQL user", true);
+}
+async function getDatabase(apiClient, p, id) {
+    return await p.runStep("fetching database", async () => {
+        const r = await apiClient.database.getMysqlDatabase({
+            pathParameters: { id },
+        });
+        assertStatus(r, 200);
+        return r.data;
+    });
+}
+async function getDatabaseUser(apiClient, p, databaseId) {
+    return await p.runStep("fetching main user", async () => {
+        const r = await apiClient.database.listMysqlUsers({
+            pathParameters: { databaseId },
+        });
+        assertStatus(r, 200);
+        const mainUser = r.data.find((u) => u.mainUser);
+        if (!mainUser) {
+            throw new Error("No main user found");
+        }
+        return mainUser;
+    });
+}

package/dist/esm/lib/database/mysql/flags.d.ts

@@ -0,0 +1,10 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ArgOutput, FlagOutput } from "@oclif/core/lib/interfaces/parser.js";
+export declare const mysqlConnectionFlags: {
+    "mysql-password": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare const mysqlArgs: {
+    "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+};
+export declare function withMySQLId(apiClient: MittwaldAPIV2Client, flags: FlagOutput, args: ArgOutput, cfg: Config): Promise<string>;