@mittwald/cli 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/commands/backup/download.js

@@ -0,0 +1,179 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import crypto from "crypto";
+import { Text } from "ink";
+import { Value } from "../../rendering/react/components/Value.js";
+import { assertStatus, } from "@mittwald/api-client-commons";
+import { waitUntil } from "../../lib/wait.js";
+import axios from "axios";
+import * as fs from "fs";
+import { formatBytes } from "../../lib/viewhelpers/size.js";
+import { Success } from "../../rendering/react/components/Success.js";
+export class Download extends ExecRenderBaseCommand {
+    static description = "Download a backup to your local disk";
+    static args = {
+        "backup-id": Args.string({
+            required: true,
+            description: "the ID of the Backup to download.",
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        output: Flags.string({
+            description: "the file to write the backup to; if omitted, the filename will be determined by the server.",
+        }),
+        format: Flags.string({
+            description: "the file format to download the backup in.",
+            options: ["tar", "zip"],
+            default: "tar",
+        }),
+        password: Flags.string({
+            summary: "the password to encrypt the backup with.",
+            description: `\
+        CAUTION #1: this is not stored anywhere.
+        CAUTION #2: it is dangerous to use this option, as the password might be stored in your shell history.`,
+            exclusive: ["generate-password", "prompt-password"],
+        }),
+        "generate-password": Flags.boolean({
+            summary: "generate a random password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "prompt-password"],
+        }),
+        "prompt-password": Flags.boolean({
+            summary: "prompt for a password to encrypt the backup with.",
+            description: "CAUTION: this is not stored anywhere.",
+            exclusive: ["password", "generate-password"],
+        }),
+        resume: Flags.boolean({
+            summary: "resume a previously interrupted download.",
+            dependsOn: ["output"],
+        }),
+    };
+    static aliases = ["project:backup:download"];
+    static deprecateAliases = true;
+    async getPassword(p) {
+        if (this.flags.password) {
+            return this.flags.password;
+        }
+        if (this.flags["generate-password"]) {
+            const password = await p.runStep("generating password", async () => {
+                return crypto.randomBytes(32).toString("ascii").substring(0, 32);
+            });
+            p.addInfo(_jsxs(Text, { children: ["generated password: ", _jsx(Value, { children: password })] }));
+            return password;
+        }
+        if (this.flags["prompt-password"]) {
+            return await p.addInput(_jsx(Text, { children: "enter backup password" }), true);
+        }
+        return undefined;
+    }
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Downloading backup");
+        const projectBackupId = this.args["backup-id"];
+        const { format } = this.flags;
+        const password = await this.getPassword(p);
+        const backup = await p.runStep("fetching backup", async () => {
+            const r = await this.apiClient.backup.getProjectBackup({
+                projectBackupId,
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        if (backup.export && backup.export.phase !== "Expired") {
+            p.addInfo(_jsx(Text, { children: "backup download is already prepared" }));
+        }
+        else {
+            await p.runStep("preparing backup download", async () => {
+                const r = await this.apiClient.backup.createProjectBackupExport({
+                    projectBackupId,
+                    data: {
+                        format: format,
+                        password,
+                    },
+                });
+                assertStatus(r, 204);
+            });
+        }
+        const backupExport = await p.runStep("waiting for backup download to be ready", () => {
+            return waitUntil(async () => {
+                const r = await this.apiClient.backup.getProjectBackup({
+                    projectBackupId,
+                });
+                assertStatus(r, 200);
+                if (r.data.export?.phase === "Completed") {
+                    return r.data.export;
+                }
+                return null;
+            }, 3600);
+        });
+        if (!backupExport.downloadURL) {
+            throw new Error("backup download is not ready");
+        }
+        const reqConfig = { responseType: "stream" };
+        if (this.flags.resume &&
+            this.flags.output &&
+            fs.existsSync(this.flags.output)) {
+            const stat = fs.statSync(this.flags.output);
+            const range = `bytes=${stat.size}-`;
+            reqConfig.headers = { Range: range };
+            p.addInfo(_jsxs(Text, { children: ["resuming download starting at ", _jsx(Value, { children: stat.size }), " bytes"] }));
+        }
+        const downloadStep = p.addStep("downloading backup");
+        const resp = await axios(backupExport.downloadURL, reqConfig);
+        const size = parseInt(resp.headers["content-length"] || "0", 10);
+        let downloaded = 0;
+        const outputFilename = this.getFilename(resp.headers);
+        const outputStream = fs.createWriteStream(outputFilename, {
+            flags: this.flags.resume ? "a" : undefined,
+        });
+        resp.data.on("data", (chunk) => {
+            downloaded += chunk.length;
+            downloadStep.progress(formatBytes(downloaded, {
+                minimumFractionDigits: 2,
+                maximumFractionDigits: 2,
+            }) +
+                " of " +
+                formatBytes(size, {
+                    minimumFractionDigits: 2,
+                    maximumFractionDigits: 2,
+                }));
+            outputStream.write(chunk);
+        });
+        await new Promise((res) => {
+            resp.data.on("end", () => {
+                downloadStep.complete();
+                res();
+            });
+            resp.data.on("error", (err) => {
+                downloadStep.error(err);
+                res();
+            });
+        });
+        p.complete(_jsxs(Success, { children: ["The backup was successfully downloaded to", " ", _jsx(Value, { children: outputFilename })] }));
+        return { outputFilename };
+    }
+    getFilename(headers) {
+        if (this.flags.output) {
+            return this.flags.output;
+        }
+        const disposition = headers["content-disposition"];
+        if (disposition) {
+            const match = disposition.match(/filename=("?)(.*)\1/);
+            if (match) {
+                return match[2];
+            }
+        }
+        if (this.flags.format === "tar") {
+            return "backup.tar.gz";
+        }
+        return "backup.zip";
+    }
+    render(executionResult) {
+        if (this.flags.quiet) {
+            return executionResult.outputFilename;
+        }
+        return undefined;
+    }
+}

package/dist/commands/backup/get.d.ts

@@ -0,0 +1,14 @@
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Get extends RenderBaseCommand<typeof Get> {
+    static description: string;
+    static args: {
+        "backup-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected render(): ReactNode;
+}

package/dist/commands/backup/get.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { useProjectBackup } from "../../lib/projectbackup/hooks.js";
+import { Args } from "@oclif/core";
+import { ProjectBackupDetails } from "../../rendering/react/components/ProjectBackup/ProjectBackupDetails.js";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+import { Box } from "ink";
+export default class Get extends RenderBaseCommand {
+    static description = "show details of a backup.";
+    static args = {
+        "backup-id": Args.string({
+            required: true,
+            description: "The ID of the Backup to show.",
+        }),
+    };
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static aliases = ["project:backup:get"];
+    static deprecateAliases = true;
+    render() {
+        const projectBackup = useProjectBackup(this.args["backup-id"]);
+        if (this.flags.output === "json") {
+            return _jsx(RenderJson, { name: "projectBackup", data: projectBackup });
+        }
+        return (_jsx(Box, { marginBottom: 1, children: _jsx(ProjectBackupDetails, { projectBackup: projectBackup }) }));
+    }
+}

package/dist/commands/backup/list.d.ts

@@ -0,0 +1,43 @@
+import { Response, Simplify } from "@mittwald/api-client-commons";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../types.js";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { ListColumns } from "../../Formatter.js";
+type BackupProjectBackup = MittwaldAPIV2.Components.Schemas.BackupProjectBackup;
+type ListResponse = Response<BackupProjectBackup[]>;
+type ListItem = Simplify<BackupProjectBackup>;
+export declare class List extends ListBaseCommand<typeof List, ListItem, ListResponse> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+        columns?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        csv?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        extended?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        filter?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        'no-header'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        'no-truncate'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        output: import("@oclif/core/lib/interfaces/parser.js").FlagProps & {
+            type: "option";
+            helpValue?: string | undefined;
+            options?: readonly string[] | undefined;
+            multiple?: boolean | undefined;
+            multipleNonGreedy?: boolean | undefined;
+            delimiter?: "," | undefined;
+            allowStdin?: boolean | "only" | undefined;
+        } & {
+            parse: import("@oclif/core/lib/interfaces/parser.js").FlagParser<string | undefined, string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            defaultHelp?: import("@oclif/core/lib/interfaces/parser.js").FlagDefaultHelp<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            input: string[];
+            default?: import("@oclif/core/lib/interfaces/parser.js").FlagDefault<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        };
+        sort?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        "no-relative-dates": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    protected mapData(data: SuccessfulResponse<ListResponse, 200>["data"]): ListItem[] | Promise<ListItem[]>;
+    getData(): Promise<ListResponse>;
+    protected getColumns(data: ListItem[]): ListColumns<ListItem>;
+}
+export {};

package/dist/commands/backup/list.js

@@ -0,0 +1,36 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+import { projectFlags } from "../../lib/project/flags.js";
+import { optionalDateRenderer } from "../../lib/viewhelpers/date.js";
+import { makeDateRendererForFlags } from "../../lib/viewhelpers/list_column_date.js";
+export class List extends ListBaseCommand {
+    static description = "List Backups for a given Project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    static aliases = ["project:backup:list"];
+    static deprecateAliases = true;
+    mapData(data) {
+        return data;
+    }
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return await this.apiClient.backup.listProjectBackups({
+            projectId,
+        });
+    }
+    getColumns(data) {
+        const { id, createdAt } = super.getColumns(data);
+        const dateRenderer = optionalDateRenderer(makeDateRendererForFlags(this.flags));
+        return {
+            id,
+            status: {},
+            createdAt,
+            expiresIn: {
+                header: "Expires in",
+                get: (r) => dateRenderer(r.expiresAt),
+            },
+        };
+    }
+}

package/dist/commands/backup/schedule/list.d.ts

@@ -0,0 +1,43 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../../types.js";
+import { ListColumns } from "../../../Formatter.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+type BackupProjectBackupSchedule = MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule;
+type ResponseItem = Simplify<BackupProjectBackupSchedule>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["backup"]["listProjectBackupSchedules"]>>;
+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>;
+        columns?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        csv?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        extended?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        filter?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        'no-header'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        'no-truncate'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        output: import("@oclif/core/lib/interfaces/parser.js").FlagProps & {
+            type: "option";
+            helpValue?: string | undefined;
+            options?: readonly string[] | undefined;
+            multiple?: boolean | undefined;
+            multipleNonGreedy?: boolean | undefined;
+            delimiter?: "," | undefined;
+            allowStdin?: boolean | "only" | undefined;
+        } & {
+            parse: import("@oclif/core/lib/interfaces/parser.js").FlagParser<string | undefined, string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            defaultHelp?: import("@oclif/core/lib/interfaces/parser.js").FlagDefaultHelp<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            input: string[];
+            default?: import("@oclif/core/lib/interfaces/parser.js").FlagDefault<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        };
+        sort?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        "no-relative-dates": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static aliases: string[];
+    static deprecateAliases: boolean;
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.BackupProjectBackupSchedule[];
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/backup/schedule/list.js

@@ -0,0 +1,31 @@
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { projectFlags, withProjectId } from "../../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List backup schedules belonging to a given project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    static aliases = ["project:backupschedule:list"];
+    static deprecateAliases = true;
+    async getData() {
+        const projectId = await withProjectId(this.apiClient, List, this.flags, this.args, this.config);
+        return await this.apiClient.backup.listProjectBackupSchedules({
+            projectId,
+        });
+    }
+    mapData(data) {
+        return data;
+    }
+    getColumns(data) {
+        const { id, createdAt } = super.getColumns(data);
+        return {
+            id,
+            isSystemBackup: { header: "System backup" },
+            schedule: {},
+            ttl: { header: "TTL" },
+            createdAt,
+        };
+    }
+}

package/dist/commands/context/get.d.ts

@@ -0,0 +1,10 @@
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Get extends RenderBaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    protected render(): ReactNode;
+}

package/dist/commands/context/get.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../rendering/react/RenderBaseCommand.js";
+import { Context, } from "../../lib/context.js";
+import { SingleResult } from "../../rendering/react/components/SingleResult.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import { Note } from "../../rendering/react/components/Note.js";
+import { Box, Text } from "ink";
+import { Set } from "./set.js";
+import { RenderJson } from "../../rendering/react/json/RenderJson.js";
+import { useRenderContext } from "../../rendering/react/context.js";
+import { LocalFilename } from "../../rendering/react/components/LocalFilename.js";
+const ContextSourceValue = ({ source }) => {
+    switch (source.type) {
+        case "user":
+            return (_jsx(ContextSourceKnownValue, { name: "user configuration", source: source }));
+        case "terraform":
+            return (_jsx(ContextSourceKnownValue, { name: "terraform state file", source: source, relative: true }));
+        case "ddev":
+            return (_jsx(ContextSourceKnownValue, { name: "DDEV configuration", source: source, relative: true }));
+        default:
+            return _jsx(ContextSourceUnknown, {});
+    }
+};
+const ContextSourceKnownValue = ({ name, source, relative }) => {
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: name }), ", in", " ", _jsx(LocalFilename, { filename: source.identifier, relative: relative })] }));
+};
+const ContextSourceUnknown = () => {
+    return _jsx(Text, { color: "yellow", children: "unknown" });
+};
+const ContextSource = ({ source }) => {
+    return (_jsxs(Text, { color: "gray", children: ["(source: ", _jsx(ContextSourceValue, { source: source }), ")"] }));
+};
+const GetContext = ({ ctx }) => {
+    const rows = {};
+    const { renderAsJson } = useRenderContext();
+    const values = {};
+    let hasTerraformSource = false;
+    let hasDDEVSource = false;
+    for (const key of [
+        "project-id",
+        "server-id",
+        "org-id",
+        "installation-id",
+    ]) {
+        const value = usePromise(ctx.getContextValue.bind(ctx), [key]);
+        if (value) {
+            rows[`--${key}`] = (_jsxs(Text, { children: [_jsx(Value, { children: value.value }), " ", _jsx(ContextSource, { source: value.source })] }));
+            values[key] = value;
+            hasTerraformSource =
+                hasTerraformSource || value.source.type === "terraform";
+            hasDDEVSource = hasDDEVSource || value.source.type === "ddev";
+        }
+        else {
+            rows[`--${key}`] = _jsx(Value, { notSet: true });
+        }
+    }
+    if (renderAsJson) {
+        return _jsx(RenderJson, { name: "context", data: values });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(SingleResult, { title: "Current CLI context", rows: rows }) }), hasTerraformSource && _jsx(TerraformHint, {}), hasDDEVSource && _jsx(DDEVHint, {}), _jsx(ContextSetHint, {})] }));
+};
+const TerraformHint = () => (_jsx(Note, { marginBottom: 1, children: "You are in a directory that contains a terraform state file; some of the context values were read from there." }));
+const DDEVHint = () => (_jsx(Note, { marginBottom: 1, children: "You are in a directory that contains a DDEV project; some of the context values were read from there." }));
+const ContextSetHint = () => (_jsxs(Note, { marginBottom: 1, children: ["Use the ", _jsx(Value, { children: "mw context set" }), " command to set one of the values listed above."] }));
+export class Get extends RenderBaseCommand {
+    static summary = "Print an overview of currently set context parameters";
+    static description = Set.description;
+    static flags = { ...RenderBaseCommand.buildFlags() };
+    render() {
+        const ctx = new Context(this.apiClient, this.config);
+        return _jsx(GetContext, { ctx: ctx });
+    }
+}

package/dist/commands/context/reset.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from "../../BaseCommand.js";
+export declare class Reset extends BaseCommand {
+    static summary: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/context/reset.js

@@ -0,0 +1,9 @@
+import { Context } from "../../lib/context.js";
+import { BaseCommand } from "../../BaseCommand.js";
+export class Reset extends BaseCommand {
+    static summary = "Reset context values";
+    static description = "This command resets any values for common parameters that you've previously set with 'context set'.";
+    async run() {
+        await new Context(this.apiClient, this.config).reset();
+    }
+}

package/dist/commands/context/set.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../BaseCommand.js";
+export declare class Set extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "server-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "org-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/context/set.js

@@ -0,0 +1,47 @@
+import { Flags } from "@oclif/core";
+import { Context } from "../../lib/context.js";
+import { BaseCommand } from "../../BaseCommand.js";
+import { normalizeAppInstallationId, normalizeCustomerId, normalizeProjectId, normalizeServerId, } from "../../normalize_id.js";
+export class Set extends BaseCommand {
+    static summary = "Set context values for the current project, org or server";
+    static description = "The context allows you to persistently set values for common parameters, like --project-id or --server-id, so you don't have to specify them on every command.";
+    static flags = {
+        "project-id": Flags.string({
+            description: "ID or short ID of a project",
+        }),
+        "server-id": Flags.string({
+            description: "ID or short ID of a server",
+        }),
+        "org-id": Flags.string({
+            description: "ID or short ID of an organization",
+        }),
+        "installation-id": Flags.string({
+            description: "ID or short ID of an app installation",
+            aliases: ["app-id", "app-installation-id"],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Set);
+        const ctx = new Context(this.apiClient, this.config);
+        if (flags["project-id"]) {
+            const projectId = await normalizeProjectId(this.apiClient, flags["project-id"]);
+            await ctx.setProjectId(projectId);
+            this.log(`Set project ID to ${projectId}`);
+        }
+        if (flags["server-id"]) {
+            const serverId = await normalizeServerId(this.apiClient, flags["server-id"]);
+            await ctx.setServerId(serverId);
+            this.log(`Set server ID to ${serverId}`);
+        }
+        if (flags["org-id"]) {
+            const orgId = await normalizeCustomerId(this.apiClient, flags["org-id"]);
+            await ctx.setOrgId(orgId);
+            this.log(`Set organization ID to ${orgId}`);
+        }
+        if (flags["installation-id"]) {
+            const installationId = await normalizeAppInstallationId(this.apiClient, flags["installation-id"]);
+            await ctx.setAppInstallationId(installationId);
+            this.log(`Set installation ID to ${installationId}`);
+        }
+    }
+}

package/dist/commands/conversation/categories.d.ts

@@ -0,0 +1,39 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../types.js";
+import { ListColumns } from "../../Formatter.js";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ConversationCategories.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["conversation"]["listCategories"]>>;
+export default class Categories extends ListBaseCommand<typeof Categories, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        columns?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        csv?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        extended?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        filter?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        'no-header'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        'no-truncate'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        output: import("@oclif/core/lib/interfaces/parser.js").FlagProps & {
+            type: "option";
+            helpValue?: string | undefined;
+            options?: readonly string[] | undefined;
+            multiple?: boolean | undefined;
+            multipleNonGreedy?: boolean | undefined;
+            delimiter?: "," | undefined;
+            allowStdin?: boolean | "only" | undefined;
+        } & {
+            parse: import("@oclif/core/lib/interfaces/parser.js").FlagParser<string | undefined, string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            defaultHelp?: import("@oclif/core/lib/interfaces/parser.js").FlagDefaultHelp<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            input: string[];
+            default?: import("@oclif/core/lib/interfaces/parser.js").FlagDefault<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        };
+        sort?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        "no-relative-dates": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.ConversationCategory[];
+    protected getColumns(): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/conversation/categories.js

@@ -0,0 +1,24 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export default class Categories extends ListBaseCommand {
+    static description = "Get all conversation categories.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        return await this.apiClient.conversation.listCategories();
+    }
+    mapData(data) {
+        return data;
+    }
+    getColumns() {
+        return {
+            id: {
+                header: "ID",
+                minWidth: 36,
+                extended: true,
+            },
+            name: {},
+        };
+    }
+}

package/dist/commands/conversation/close.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "../../BaseCommand.js";
+export default class Close extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conversation/close.js

@@ -0,0 +1,24 @@
+import { BaseCommand } from "../../BaseCommand.js";
+import { Args, ux } from "@oclif/core";
+import { normalizeConversationId } from "../../normalize_id.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+export default class Close extends BaseCommand {
+    static description = "Close a conversation";
+    static args = {
+        id: Args.string({
+            required: true,
+            description: "ID of the conversation to show",
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(Close);
+        const conversationId = await normalizeConversationId(this.apiClient, args.id);
+        ux.action.start(`closing conversation ${conversationId}`);
+        const response = await this.apiClient.conversation.setConversationStatus({
+            conversationId,
+            data: { status: "closed" },
+        });
+        assertStatus(response, 200);
+        ux.action.stop();
+    }
+}