@mittwald/cli 1.4.4 → 1.5.0

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>;

package/dist/lib/context/FlagSetBuilder.js

@@ -59,9 +59,13 @@ export default class FlagSetBuilder {
     buildFlags() {
         const { displayName } = this;
         const article = articleForWord(displayName);
-        const { retrieveFromContext = true } = this.opts;
-        let summary = `ID or short ID of ${article} ${displayName}`;
-        let description = `May contain a short ID or a full ID of ${article} ${displayName}`;
+        const { retrieveFromContext = true, expectedShortIDFormat } = this.opts;
+        let summary = `ID of ${article} ${displayName}`;
+        let description = `May contain a ID of ${article} ${displayName}`;
+        if (expectedShortIDFormat) {
+            summary = `ID or short ID of ${article} ${displayName}`;
+            description = `May contain a short ID or a full ID of ${article} ${displayName}`;
+        }
         if (retrieveFromContext) {
             summary += `; this flag is optional if a default ${displayName} is set in the context`;
             description += `; you can also use the "<%= config.bin %> context set --${this.flagName}=<VALUE>" command to persistently set a default ${displayName} for all commands that accept this flag.`;
@@ -83,8 +87,11 @@ export default class FlagSetBuilder {
     buildArgs() {
         const { displayName } = this;
         const article = articleForWord(displayName);
-        const { retrieveFromContext = true } = this.opts;
-        let description = `ID or short ID of ${article} ${displayName}`;
+        const { retrieveFromContext = true, expectedShortIDFormat } = this.opts;
+        let description = `ID of ${article} ${displayName}`;
+        if (expectedShortIDFormat) {
+            description = `ID or short ID of ${article} ${displayName}`;
+        }
         if (retrieveFromContext) {
             description += `; this argument is optional if a default ${displayName} is set in the context.`;
         }
@@ -99,28 +106,28 @@ export default class FlagSetBuilder {
         };
     }
     buildSanityCheck() {
-        if (this.opts.expectedShortIDFormat != null) {
-            const format = this.opts.expectedShortIDFormat;
-            return (id) => {
-                if (!validateUuid(id) && !format.pattern.test(id)) {
-                    throw new UnexpectedShortIDPassedError(this.displayName, format.display);
-                }
-            };
+        if (!this.opts.expectedShortIDFormat) {
+            return () => { };
         }
-        return () => { };
+        const format = this.opts.expectedShortIDFormat;
+        return (id) => {
+            if (!validateUuid(id) && !format.pattern.test(id)) {
+                throw new UnexpectedShortIDPassedError(this.displayName, format.display);
+            }
+        };
     }
     buildIDGetter() {
         const idInputSanityCheck = this.buildSanityCheck();
         const idFromArgsOrFlag = this.buildIDFromArgsOrFlag();
         const { normalize = (_, id) => id, retrieveFromContext = true } = this.opts;
         return async (apiClient, commandType, flags, args, cfg) => {
+            const context = new Context(apiClient, cfg);
             const idInput = idFromArgsOrFlag(flags, args);
             if (idInput) {
                 idInputSanityCheck(idInput);
-                return normalize(apiClient, idInput);
+                return normalize(apiClient, idInput, context);
             }
             if (retrieveFromContext) {
-                const context = new Context(apiClient, cfg);
                 const idFromContext = await context.getContextValue(this.flagName);
                 if (idFromContext) {
                     return idFromContext.value;

package/dist/lib/resources/container/flags.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { CommandType } from "../../context/FlagSetBuilder.js";
+import { Config } from "@oclif/core";
+export declare const containerFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"container">, containerArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"container">, withContainerId: (apiClient: MittwaldAPIV2Client, command: "flag" | "arg" | CommandType<"container">, flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: Config) => Promise<string>;
+export declare function withContainerAndStackId(apiClient: MittwaldAPIV2Client, command: CommandType<"project"> | "flag" | "arg", flags: {
+    [k: string]: unknown;
+}, args: {
+    [k: string]: unknown;
+}, cfg: Config): Promise<[string, string]>;

package/dist/lib/resources/container/flags.js

@@ -0,0 +1,34 @@
+import { assertStatus } from "@mittwald/api-client";
+import FlagSetBuilder from "../../context/FlagSetBuilder.js";
+import { contextIDNormalizers } from "../../context/Context.js";
+import { withProjectId } from "../project/flags.js";
+async function normalize(apiClient, serviceId, ctx) {
+    const { value: stackId } = await ctx.mustGetContextValue("stack-id");
+    const result = await apiClient.container.getService({
+        stackId,
+        serviceId,
+    });
+    assertStatus(result, 200);
+    return result.data.id;
+}
+contextIDNormalizers["container-id"] = normalize;
+export const { flags: containerFlags, args: containerArgs, withId: withContainerId, } = new FlagSetBuilder("container", "c", { normalize }).build();
+export async function withContainerAndStackId(apiClient, command, flags, args, cfg) {
+    const projectId = await withProjectId(apiClient, command, flags, args, cfg);
+    const containerId = flags["container-id"] ?? args["container-id"];
+    if (typeof containerId !== "string") {
+        throw new Error("container ID, short ID or name must be specified");
+    }
+    const containerResp = await apiClient.container.listServices({
+        projectId,
+    });
+    assertStatus(containerResp, 200);
+    for (const container of containerResp.data) {
+        if (container.shortId === containerId ||
+            container.id === containerId ||
+            container.serviceName === containerId) {
+            return [container.id, container.stackId];
+        }
+    }
+    throw new Error(`no container ${containerId} found in project ${projectId}`);
+}

package/dist/lib/resources/org/flags.js

@@ -7,4 +7,10 @@ async function normalize(apiClient, customerId) {
     return customer.data.customerId;
 }
 contextIDNormalizers["org-id"] = normalize;
-export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = new FlagSetBuilder("org", "o", { normalize }).build();
+export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = new FlagSetBuilder("org", "o", {
+    normalize,
+    expectedShortIDFormat: {
+        pattern: /^\d+$/,
+        display: "000000",
+    },
+}).build();

package/dist/lib/resources/server/flags.js

@@ -7,4 +7,10 @@ async function normalize(apiClient, serverId) {
     return result.data.id;
 }
 contextIDNormalizers["server-id"] = normalize;
-export const { flags: serverFlags, args: serverArgs, withId: withServerId, } = new FlagSetBuilder("server", "s", { normalize }).build();
+export const { flags: serverFlags, args: serverArgs, withId: withServerId, } = new FlagSetBuilder("server", "s", {
+    normalize,
+    expectedShortIDFormat: {
+        pattern: /^s-.*/,
+        display: "s-XXXXXX",
+    },
+}).build();

package/dist/lib/resources/stack/enrich.d.ts

@@ -0,0 +1,4 @@
+import { type MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
+export declare function enrichStackDefinition(apiClient: MittwaldAPIV2Client, projectId: string, input: StackRequest): Promise<StackRequest>;
+export {};

package/dist/lib/resources/stack/enrich.js

@@ -0,0 +1,55 @@
+import { assertStatus, } from "@mittwald/api-client";
+import { readFile } from "fs/promises";
+import { parse } from "envfile";
+export async function enrichStackDefinition(apiClient, projectId, input) {
+    const enriched = structuredClone(input);
+    for (const serviceName of Object.keys(input.services ?? {})) {
+        let service = enriched.services[serviceName];
+        service = await setCommandAndEntrypointFromImage(apiClient, projectId, service);
+        service = await setEnvironmentFromEnvFile(service);
+        enriched.services[serviceName] = service;
+    }
+    return enriched;
+}
+async function setEnvironmentFromEnvFile(service) {
+    if (!service.env_file) {
+        return service;
+    }
+    const enriched = structuredClone(service);
+    const envFileContent = await readFile(service.env_file, "utf-8");
+    const envVars = parse(envFileContent);
+    delete enriched.env_file;
+    enriched.envs = {
+        ...envVars,
+        ...(enriched.envs ?? {}),
+    };
+    return enriched;
+}
+async function setCommandAndEntrypointFromImage(apiClient, projectId, service) {
+    const enriched = structuredClone(service);
+    const resp = await apiClient.container.getContainerImageConfig({
+        queryParameters: {
+            imageReference: service.image,
+            useCredentialsForProjectId: projectId,
+        },
+    });
+    assertStatus(resp, 200);
+    if (service.ports === undefined) {
+        enriched.ports = (resp.data.exposedPorts ?? []).map((p) => p.port);
+    }
+    if (service.command === undefined) {
+        let command = resp.data.command;
+        if (typeof command === "string") {
+            command = [command];
+        }
+        enriched.command = command;
+    }
+    if (service.entrypoint === undefined) {
+        let entrypoint = resp.data.entrypoint;
+        if (typeof entrypoint === "string") {
+            entrypoint = [entrypoint];
+        }
+        enriched.entrypoint = entrypoint;
+    }
+    return enriched;
+}

package/dist/lib/resources/stack/env.d.ts

@@ -0,0 +1 @@
+export declare function collectEnvironment(base: NodeJS.ProcessEnv, envFile: string): Promise<Record<string, string | undefined>>;