@mittwald/cli 1.4.4 → 1.5.1

package/dist/commands/registry/delete.js

@@ -0,0 +1,21 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { Args } from "@oclif/core";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a container registry";
+    static resourceName = "container registry";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = {
+        "registry-id": Args.string({
+            summary: "id of the container registry to delete",
+            required: true,
+        }),
+    };
+    async deleteResource() {
+        const registryId = this.args["registry-id"];
+        const response = await this.apiClient.container.deleteRegistry({
+            registryId,
+        });
+        assertSuccess(response);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../rendering/formatter/Table.js";
+type ContainerRegistry = MittwaldAPIV2.Components.Schemas.ContainerRegistry;
+type ResponseItem = Simplify<ContainerRegistry>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["container"]["listRegistries"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    getData(): Promise<Response>;
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/registry/list.js

@@ -0,0 +1,33 @@
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List container registries.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return this.apiClient.container.listRegistries({ projectId });
+    }
+    getColumns(data) {
+        const { id } = super.getColumns(data);
+        return {
+            id,
+            description: {},
+            uri: {
+                header: "URI",
+            },
+            credentials: {
+                header: "Credentials",
+                get: (registry) => {
+                    if (!registry.credentials) {
+                        return "";
+                    }
+                    return `${registry.credentials.username} (${registry.credentials.valid ? "valid" : "invalid"})`;
+                },
+            },
+        };
+    }
+}

package/dist/commands/registry/update.d.ts

@@ -0,0 +1,20 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+type UpdateResult = void;
+export default class Update extends ExecRenderBaseCommand<typeof Update, UpdateResult> {
+    static description: string;
+    static args: {
+        "registry-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        uri: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        username: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+    private getPassword;
+}
+export {};

package/dist/commands/registry/update.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { Text } from "ink";
+export default class Update extends ExecRenderBaseCommand {
+    static description = "Update an existing container registry";
+    static args = {
+        "registry-id": Args.string({
+            summary: "id of the container registry to update",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        description: Flags.string({
+            summary: "new description for the registry",
+        }),
+        uri: Flags.string({
+            summary: "new uri for the registry",
+        }),
+        username: Flags.string({
+            summary: "username for registry authentication",
+        }),
+        password: Flags.string({
+            summary: "password for registry authentication",
+            description: "If omitted but username is provided, the command will prompt interactively for a password.\n\nCAUTION: providing this flag may log your password in your shell history!",
+        }),
+    };
+    async exec() {
+        const registryId = this.args["registry-id"];
+        const process = makeProcessRenderer(this.flags, "Updating container registry");
+        const { description, uri, username } = this.flags;
+        const registryUpdatePayload = {};
+        if (description) {
+            registryUpdatePayload.description = description;
+        }
+        if (uri) {
+            registryUpdatePayload.uri = uri;
+        }
+        if (username) {
+            const password = await this.getPassword(process);
+            registryUpdatePayload.credentials = {
+                username,
+                password,
+            };
+        }
+        if (Object.keys(registryUpdatePayload).length == 0) {
+            await process.complete(_jsx(Success, { children: "Nothing to change. Have a good day!" }));
+            return;
+        }
+        await process.runStep("Updating container registry", async () => {
+            const response = await this.apiClient.container.updateRegistry({
+                registryId,
+                data: registryUpdatePayload,
+            });
+            assertSuccess(response);
+        });
+        await process.complete(_jsx(Success, { children: "Your container registry has successfully been updated." }));
+        return;
+    }
+    render() {
+        return true;
+    }
+    async getPassword(process) {
+        if (this.flags.password) {
+            return this.flags.password;
+        }
+        return await process.addInput(_jsx(Text, { children: "enter registry password" }), true);
+    }
+}

package/dist/commands/stack/delete.d.ts

@@ -0,0 +1,16 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+export default class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static aliases: string[];
+    static flags: {
+        "with-volumes": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "stack-id": import("@oclif/core/interfaces").Arg<string>;
+    };
+    protected deleteResource(): Promise<void>;
+    protected deleteVolumes(stackId: string, projectId: string): Promise<void>;
+}

package/dist/commands/stack/delete.js

@@ -0,0 +1,54 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { stackArgs } from "../../lib/resources/stack/flags.js";
+import { assertStatus } from "@mittwald/api-client";
+import { Flags } from "@oclif/core";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a container stack";
+    static resourceName = "container stack";
+    static aliases = ["stack:rm"];
+    static flags = {
+        ...DeleteBaseCommand.baseFlags,
+        "with-volumes": Flags.boolean({
+            summary: "also include remove volumes in removal",
+            default: false,
+            char: "v",
+        }),
+    };
+    static args = { ...stackArgs };
+    async deleteResource() {
+        const stackId = await this.withStackId(Delete);
+        const stackResponse = await this.apiClient.container.getStack({ stackId });
+        assertStatus(stackResponse, 200);
+        if (stackResponse.data.projectId !== stackResponse.data.id) {
+            throw new Error("not implemented");
+        }
+        const resp = await this.apiClient.container.declareStack({
+            stackId,
+            data: {
+                services: {},
+                volumes: {},
+            },
+        });
+        assertSuccess(resp);
+        if (this.flags["with-volumes"]) {
+            await this.deleteVolumes(stackId, stackResponse.data.projectId);
+        }
+    }
+    async deleteVolumes(stackId, projectId) {
+        const volumesResponse = await this.apiClient.container.listVolumes({
+            projectId,
+        });
+        assertStatus(volumesResponse, 200);
+        for (const volume of volumesResponse.data) {
+            if (volume.stackId !== stackId) {
+                continue;
+            }
+            const deleteVolumeResponse = await this.apiClient.container.deleteVolume({
+                stackId: stackId,
+                volumeId: volume.id,
+            });
+            assertSuccess(deleteVolumeResponse);
+        }
+    }
+}

package/dist/commands/stack/deploy.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+interface DeployResult {
+    restartedServices: string[];
+}
+export declare class Deploy extends ExecRenderBaseCommand<typeof Deploy, DeployResult> {
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        "compose-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "stack-id": import("@oclif/core/interfaces").OptionFlag<string>;
+    };
+    protected exec(): Promise<DeployResult>;
+    protected render({ restartedServices }: DeployResult): ReactNode;
+}
+export {};

package/dist/commands/stack/deploy.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { stackFlags, withStackId } from "../../lib/resources/stack/flags.js";
+import { Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { loadStackFromFile } from "../../lib/resources/stack/loader.js";
+import { assertStatus } from "@mittwald/api-client";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { collectEnvironment } from "../../lib/resources/stack/env.js";
+import { sanitizeStackDefinition } from "../../lib/resources/stack/sanitize.js";
+import { enrichStackDefinition } from "../../lib/resources/stack/enrich.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+export class Deploy extends ExecRenderBaseCommand {
+    static description = "Deploys a docker-compose compatible file to a mittwald container stack";
+    static aliases = ["stack:up"];
+    static flags = {
+        ...stackFlags,
+        ...processFlags,
+        "compose-file": Flags.string({
+            summary: 'path to a compose file, or "-" to read from stdin',
+            default: "./docker-compose.yml",
+            char: "c",
+        }),
+        "env-file": Flags.file({
+            summary: "alternative path to file with environment variables",
+            default: "./.env",
+        }),
+    };
+    async exec() {
+        const stackId = await withStackId(this.apiClient, Deploy, this.flags, this.args, this.config);
+        const { "compose-file": composeFile, "env-file": envFile } = this.flags;
+        const r = makeProcessRenderer(this.flags, "Deploying container stack");
+        const result = { restartedServices: [] };
+        const stack = await r.runStep("getting stack", async () => {
+            const resp = await this.apiClient.container.getStack({ stackId });
+            assertStatus(resp, 200);
+            return resp.data;
+        });
+        const env = await collectEnvironment(process.env, envFile);
+        let stackDefinition = await loadStackFromFile(composeFile, env);
+        stackDefinition = sanitizeStackDefinition(stackDefinition);
+        stackDefinition = await r.runStep("getting image configurations", async () => {
+            return enrichStackDefinition(this.apiClient, stack.projectId, stackDefinition);
+        });
+        this.debug("complete stack definition: %O", stackDefinition);
+        const declaredStack = await r.runStep("deploying stack", async () => {
+            const resp = await this.apiClient.container.declareStack({
+                stackId,
+                data: stackDefinition,
+            });
+            assertStatus(resp, 200);
+            return resp.data;
+        });
+        for (const service of declaredStack.services ?? []) {
+            if (service.requiresRecreate) {
+                await r.runStep(`recreating service ${service.serviceName}`, async () => {
+                    const resp = await this.apiClient.container.recreateService({
+                        stackId,
+                        serviceId: service.id,
+                    });
+                    assertSuccess(resp);
+                    result.restartedServices.push(service.serviceName);
+                });
+            }
+        }
+        return result;
+    }
+    render({ restartedServices }) {
+        if (restartedServices.length === 0) {
+            return (_jsx(Success, { children: "Deployment successful. No services were restarted." }));
+        }
+        return (_jsxs(Success, { children: ["Deployment successful. The following services were restarted:", " ", _jsx(Value, { children: restartedServices.join(", ") })] }));
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Response, Simplify } from "@mittwald/api-client-commons";
+import { type MittwaldAPIV2 } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../rendering/formatter/Table.js";
+type Stack = MittwaldAPIV2.Components.Schemas.ContainerStackResponse;
+type ListResponse = Response<Stack[]>;
+type ListItem = Simplify<Stack>;
+export declare class List extends ListBaseCommand<typeof List, ListItem, ListResponse> {
+    static description: string;
+    static aliases: string[];
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    getData(): Promise<ListResponse>;
+    protected getColumns(data: ListItem[]): ListColumns<ListItem>;
+}
+export {};

package/dist/commands/stack/list.js

@@ -0,0 +1,60 @@
+import { assertStatus } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List container stacks for a given project.";
+    static aliases = ["stack:ls"];
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        const response = await this.apiClient.container.listStacks({
+            projectId,
+        });
+        assertStatus(response, 200);
+        return response;
+    }
+    getColumns(data) {
+        const { id } = super.getColumns(data);
+        return {
+            id,
+            description: {},
+            services: {
+                get(stack) {
+                    if (stack.services === undefined || stack.services.length === 0) {
+                        return "no services";
+                    }
+                    const countByStatus = {};
+                    let requireRecreate = 0;
+                    for (const service of stack.services || []) {
+                        countByStatus[service.status] =
+                            (countByStatus[service.status] || 0) + 1;
+                        if (service.requiresRecreate) {
+                            requireRecreate++;
+                        }
+                    }
+                    const summaryItems = [];
+                    for (const status of Object.keys(countByStatus)) {
+                        summaryItems.push(countByStatus[status] + " " + status);
+                    }
+                    let summary = summaryItems.join(", ");
+                    if (requireRecreate > 0) {
+                        summary += ` (${requireRecreate} require recreation)`;
+                    }
+                    return summary;
+                },
+            },
+            volumes: {
+                get(stack) {
+                    if (stack.volumes === undefined || stack.volumes.length === 0) {
+                        return "no volumes";
+                    }
+                    return stack.volumes.length + " volumes";
+                },
+            },
+        };
+    }
+}

package/dist/commands/stack/ps.d.ts

@@ -0,0 +1,23 @@
+import { Response, Simplify } from "@mittwald/api-client-commons";
+import { type MittwaldAPIV2 } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../rendering/formatter/Table.js";
+type ContainerServiceResponse = MittwaldAPIV2.Components.Schemas.ContainerServiceResponse;
+type ListResponse = Response<ContainerServiceResponse[]>;
+type ListItem = Simplify<ContainerServiceResponse>;
+export declare class ListContainers extends ListBaseCommand<typeof ListContainers, ListItem, ListResponse> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "stack-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    getData(): Promise<ListItem[]>;
+    protected getColumns(data: ListItem[]): ListColumns<ListItem>;
+}
+export {};

package/dist/commands/stack/ps.js

@@ -0,0 +1,51 @@
+import { assertStatus } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { stackFlags } from "../../lib/resources/stack/flags.js";
+import { makeDateRendererForFormat } from "../../rendering/textformat/formatDate.js";
+export class ListContainers extends ListBaseCommand {
+    static description = "List all services within a given container stack.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...stackFlags,
+    };
+    async getData() {
+        const stackId = await this.withStackId(ListContainers);
+        const response = await this.apiClient.container.getStack({
+            stackId,
+        });
+        assertStatus(response, 200);
+        return response.data.services || [];
+    }
+    getColumns(data) {
+        const { id } = super.getColumns(data);
+        const dateFormatter = makeDateRendererForFormat(this.flags.output, !this.flags["no-relative-dates"]);
+        return {
+            id,
+            name: {
+                get: (svc) => svc.serviceName,
+            },
+            image: {
+                get: (svc) => svc.deployedState.image,
+            },
+            command: {
+                get: (svc) => svc.deployedState.command?.join(" "),
+            },
+            description: {},
+            ports: {
+                get: (svc) => {
+                    if (svc.deployedState.ports === undefined ||
+                        svc.deployedState.ports.length === 0) {
+                        return "no ports";
+                    }
+                    return svc.deployedState.ports.join(", ");
+                },
+            },
+            status: {
+                get(svc) {
+                    return svc.status + " (" + dateFormatter(svc.statusSetAt) + ")";
+                },
+            },
+        };
+    }
+}

package/dist/lib/basecommands/DeleteBaseCommand.js

@@ -10,7 +10,7 @@ export class DeleteBaseCommand extends ExecRenderBaseCommand {
         ...processFlags,
         force: Flags.boolean({
             char: "f",
-            description: "Do not ask for confirmation",
+            description: "do not ask for confirmation",
         }),
     };
     async exec() {

package/dist/lib/basecommands/ExtendedBaseCommand.d.ts

@@ -8,4 +8,5 @@ export declare abstract class ExtendedBaseCommand<T extends typeof BaseCommand>
     withAppInstallationId(command: CommandType<"installation"> | "flag" | "arg"): Promise<string>;
     withProjectId(command: CommandType<"project"> | "flag" | "arg"): Promise<string>;
     withServerId(command: CommandType<"server"> | "flag" | "arg"): Promise<string>;
+    withStackId(command: CommandType<"stack"> | "flag" | "arg"): Promise<string>;
 }

package/dist/lib/basecommands/ExtendedBaseCommand.js

@@ -2,6 +2,7 @@ import { BaseCommand } from "./BaseCommand.js";
 import { withAppInstallationId } from "../resources/app/flags.js";
 import { withProjectId } from "../resources/project/flags.js";
 import { withServerId } from "../resources/server/flags.js";
+import { withStackId } from "../resources/stack/flags.js";
 export class ExtendedBaseCommand extends BaseCommand {
     flags;
     args;
@@ -25,4 +26,7 @@ export class ExtendedBaseCommand extends BaseCommand {
     async withServerId(command) {
         return withServerId(this.apiClient, command, this.flags, this.args, this.config);
     }
+    async withStackId(command) {
+        return withStackId(this.apiClient, command, this.flags, this.args, this.config);
+    }
 }

package/dist/lib/context/Context.d.ts

@@ -1,7 +1,7 @@
 import { Config } from "@oclif/core";
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 import ContextProvider from "./ContextProvider.js";
-export type ContextNames = "project" | "server" | "org" | "installation" | "domain" | "dnszone" | "mailaddress" | "maildeliverybox" | "conversation" | "backup";
+export type ContextNames = "project" | "server" | "org" | "installation" | "domain" | "dnszone" | "mailaddress" | "maildeliverybox" | "conversation" | "backup" | "stack" | "container";
 export type ContextKey<N extends ContextNames = ContextNames> = `${N}-id`;
 export type ContextMap = Partial<Record<ContextKey, ContextValue>>;
 export type ContextMapUpdate = Partial<Record<ContextKey, string>>;
@@ -14,7 +14,7 @@ export type ContextValue = {
     source: ContextValueSource;
 };
 export declare const contextIDNormalizers: {
-    [k in ContextKey]?: (apiClient: MittwaldAPIV2Client, id: string) => Promise<string>;
+    [k in ContextKey]?: (apiClient: MittwaldAPIV2Client, id: string, ctx: Context) => Promise<string>;
 };
 export interface ContextOptions {
     onInitError: (err: unknown) => void;
@@ -29,13 +29,16 @@ export default class Context {
     reset(): Promise<void>;
     private persist;
     private setContextValue;
+    mustGetContextValue(key: ContextKey): Promise<ContextValue>;
     getContextValue(key: ContextKey): Promise<ContextValue | undefined>;
     setProjectId: (id: string) => Promise<string>;
     setServerId: (id: string) => Promise<string>;
     setOrgId: (id: string) => Promise<string>;
     setAppInstallationId: (id: string) => Promise<string>;
+    setStackId: (id: string) => Promise<string>;
     projectId: () => Promise<ContextValue | undefined>;
     serverId: () => Promise<ContextValue | undefined>;
     orgId: () => Promise<ContextValue | undefined>;
     appInstallationId: () => Promise<ContextValue | undefined>;
+    stackId: () => Promise<ContextValue | undefined>;
 }

package/dist/lib/context/Context.js

@@ -57,11 +57,18 @@ export default class Context {
     }
     async setContextValue(key, value) {
         if (key in contextIDNormalizers) {
-            value = await contextIDNormalizers[key](this.apiClient, value);
+            value = await contextIDNormalizers[key](this.apiClient, value, this);
         }
         await this.persist({ [key]: value });
         return value;
     }
+    async mustGetContextValue(key) {
+        const value = await this.getContextValue(key);
+        if (!value) {
+            throw new InvalidContextError(`Context value for "${key}" is not set.`);
+        }
+        return value;
+    }
     async getContextValue(key) {
         const data = await this.contextData;
         if (key in data) {
@@ -73,8 +80,10 @@ export default class Context {
     setServerId = (id) => this.setContextValue("server-id", id);
     setOrgId = (id) => this.setContextValue("org-id", id);
     setAppInstallationId = (id) => this.setContextValue("installation-id", id);
+    setStackId = (id) => this.setContextValue("stack-id", id);
     projectId = () => this.getContextValue("project-id");
     serverId = () => this.getContextValue("server-id");
     orgId = () => this.getContextValue("org-id");
     appInstallationId = () => this.getContextValue("installation-id");
+    stackId = () => this.getContextValue("stack-id");
 }

package/dist/lib/context/FlagSetBuilder.d.ts

@@ -1,7 +1,6 @@
-import { Arg, OptionFlag } from "@oclif/core/interfaces";
+import { AlphabetLowercase, Arg, OptionFlag } from "@oclif/core/interfaces";
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
-import { AlphabetLowercase } from "@oclif/core/interfaces";
-import { ContextKey, ContextNames } from "./Context.js";
+import Context, { ContextKey, ContextNames } from "./Context.js";
 import FlagSet from "./FlagSet.js";
 export type ContextFlags<N extends ContextNames, TID extends string = ContextKey<N>> = {
     [k in TID]: OptionFlag<string>;
@@ -33,7 +32,7 @@ export type FlagSetOptions = {
         display: string;
     };
 };
-export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string) => string | Promise<string>;
+export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string, ctx: Context) => string | Promise<string>;
 export declare function makeMissingContextInputError<TName extends ContextNames>(commandType: {
     flags: {
         [k in ContextKey<TName>]: OptionFlag<string>;