@mittwald/cli 1.5.0 → 1.5.1

package/dist/commands/container/run.d.ts

@@ -34,23 +34,7 @@ export declare class Run extends ExecRenderBaseCommand<typeof Run, Result> {
      * @returns A properly formatted container service request
      */
     private buildServiceRequest;
-    /**
-     * Parses environment variables from command line flags and env files
-     *
-     * @returns An object containing environment variable key-value pairs
-     */
-    private parseEnvironmentVariables;
-    private parseEnvironmentVariablesFromFile;
-    private parseEnvironmentVariablesFromEnvFlags;
-    /**
-     * Determines which ports to expose based on flags and image metadata
-     *
-     * @param imageMeta Metadata about the container image
-     * @returns An array of port mappings
-     */
-    private getPortMappings;
     private getImageAndMeta;
-    private getImageMeta;
     private getServiceName;
     protected render({ serviceId }: Result): ReactNode;
 }

package/dist/commands/container/run.js

@@ -7,9 +7,7 @@ import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
 import * as dockerNames from "docker-names";
 import { assertStatus } from "@mittwald/api-client";
-import * as fs from "fs/promises";
-import { parse } from "envfile";
-import { pathExists } from "../../lib/util/fs/pathExists.js";
+import { parseEnvironmentVariables, getPortMappings, getImageMeta, } from "../../lib/resources/container/containerconfig.js";
 export class Run extends ExecRenderBaseCommand {
     static summary = "Creates and starts a new container.";
     static flags = {
@@ -133,8 +131,8 @@ export class Run extends ExecRenderBaseCommand {
             ? [this.flags.entrypoint]
             : imageMeta.entrypoint;
         const description = this.flags.description ?? serviceName;
-        const envs = await this.parseEnvironmentVariables();
-        const ports = this.getPortMappings(imageMeta);
+        const envs = await parseEnvironmentVariables(this.flags.env, this.flags["env-file"]);
+        const ports = getPortMappings(imageMeta, this.flags["publish-all"], this.flags.publish);
         const volumes = this.flags.volume;
         return {
             image,
@@ -146,66 +144,11 @@ export class Run extends ExecRenderBaseCommand {
             volumes,
         };
     }
-    /**
-     * Parses environment variables from command line flags and env files
-     *
-     * @returns An object containing environment variable key-value pairs
-     */
-    async parseEnvironmentVariables() {
-        return {
-            ...this.parseEnvironmentVariablesFromEnvFlags(),
-            ...(await this.parseEnvironmentVariablesFromFile()),
-        };
-    }
-    async parseEnvironmentVariablesFromFile() {
-        const result = {};
-        for (const envFile of this.flags["env-file"] ?? []) {
-            if (!(await pathExists(envFile))) {
-                throw new Error(`Env file not found: ${envFile}`);
-            }
-            const fileContent = await fs.readFile(envFile, { encoding: "utf-8" });
-            const parsed = parse(fileContent);
-            Object.assign(result, parsed);
-        }
-        return result;
-    }
-    parseEnvironmentVariablesFromEnvFlags() {
-        const splitIntoKeyAndValue = (e) => e.split("=", 2);
-        const envFlags = this.flags.env ?? [];
-        return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
-    }
-    /**
-     * Determines which ports to expose based on flags and image metadata
-     *
-     * @param imageMeta Metadata about the container image
-     * @returns An array of port mappings
-     */
-    getPortMappings(imageMeta) {
-        if (this.flags["publish-all"]) {
-            const definedPorts = imageMeta.exposedPorts ?? [];
-            const concatPort = (p) => {
-                const [port, protocol = "tcp"] = p.port.split("/", 2);
-                return `${port}:${port}/${protocol}`;
-            };
-            return definedPorts.map(concatPort);
-        }
-        return this.flags.publish ?? [];
-    }
     async getImageAndMeta(projectId) {
         const { image } = this.args;
-        const meta = await this.getImageMeta(image, projectId);
+        const meta = await getImageMeta(this.apiClient, image, projectId);
         return { image, meta };
     }
-    async getImageMeta(image, projectId) {
-        const resp = await this.apiClient.container.getContainerImageConfig({
-            queryParameters: {
-                imageReference: image,
-                useCredentialsForProjectId: projectId,
-            },
-        });
-        assertStatus(resp, 200);
-        return resp.data;
-    }
     getServiceName() {
         const { name } = this.flags;
         if (name !== undefined) {

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

@@ -0,0 +1,36 @@
+import { ReactNode } from "react";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+type Result = {
+    serviceId: string;
+};
+export declare class Update extends ExecRenderBaseCommand<typeof Update, Result> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        image: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        entrypoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        command: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        publish: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "publish-all": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        volume: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        recreate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "container-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    /**
+     * Builds a container service update request from command line flags
+     *
+     * @returns A properly formatted container service request with only the
+     *   fields to update
+     */
+    private buildUpdateRequest;
+    protected render({ serviceId }: Result): ReactNode;
+}
+export {};

package/dist/commands/container/update.js

@@ -0,0 +1,174 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Args, Flags } from "@oclif/core";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { assertStatus } from "@mittwald/api-client";
+import { parseEnvironmentVariables, getPortMappings, getImageMeta, } from "../../lib/resources/container/containerconfig.js";
+export class Update extends ExecRenderBaseCommand {
+    static summary = "Updates an existing container.";
+    static description = "Updates attributes of an existing container such as image, environment variables, etc.";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        image: Flags.string({
+            summary: "update the container image",
+            description: "Specify a new image to use for the container.",
+            required: false,
+        }),
+        env: Flags.string({
+            summary: "set environment variables in the container",
+            description: "Format: KEY=VALUE. Multiple environment variables can be specified with multiple --env flags.",
+            required: false,
+            multiple: true,
+            char: "e",
+        }),
+        "env-file": Flags.string({
+            summary: "read environment variables from a file",
+            description: "The file should contain lines in the format KEY=VALUE. Multiple files can be specified with multiple --env-file flags.",
+            multiple: true,
+            required: false,
+        }),
+        description: Flags.string({
+            summary: "update the descriptive label of the container",
+            description: "This helps identify the container's purpose or contents.",
+            required: false,
+        }),
+        entrypoint: Flags.string({
+            summary: "override the entrypoint of the container",
+            description: "The entrypoint is the command that will be executed when the container starts.",
+            required: false,
+        }),
+        command: Flags.string({
+            summary: "update the command to run in the container",
+            description: "This overrides the default command specified in the container image.",
+            required: false,
+        }),
+        publish: Flags.string({
+            summary: "update the container's port mappings",
+            description: "Map a container's port to a port on the host system. " +
+                "Format: <host-port>:<container-port> or just <container-port> (in which case the host port will be automatically assigned). " +
+                "Use multiple -p flags to publish multiple ports.",
+            required: false,
+            multiple: true,
+            char: "p",
+        }),
+        "publish-all": Flags.boolean({
+            summary: "publish all ports that are defined in the image",
+            description: "Automatically publish all ports that are exposed by the container image to random ports on the host.",
+            required: false,
+            char: "P",
+        }),
+        volume: Flags.string({
+            summary: "update volume mounts for the container",
+            description: "This flag can be used to add volume mounts to the container. It can be used multiple times to mount multiple volumes." +
+                "" +
+                "Needs to be in the format <host-path>:<container-path>. " +
+                "" +
+                "If you specify a file path as volume, this will mount a path from your hosting environment's file system (NOT your local file system) into the container. " +
+                "You can also specify a named volume, which needs to be created beforehand.",
+            required: false,
+            char: "v",
+            multiple: true,
+        }),
+        recreate: Flags.boolean({
+            summary: "recreate the container after updating",
+            description: "If set, the container will be automatically recreated after updating its configuration.",
+            required: false,
+            default: false,
+        }),
+    };
+    static args = {
+        "container-id": Args.string({
+            description: "ID or short ID of the container to update",
+            required: true,
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Updating container");
+        const [serviceId, stackId] = await withContainerAndStackId(this.apiClient, Update, this.flags, this.args, this.config);
+        const service = await p.runStep("getting container configuration", async () => {
+            const r = await this.apiClient.container.getService({
+                serviceId,
+                stackId,
+            });
+            assertStatus(r, 200);
+            return r.data;
+        });
+        const updatePayload = await p.runStep("preparing update request", this.buildUpdateRequest());
+        if (Object.keys(updatePayload).length === 0) {
+            await p.complete(_jsx(Success, { children: "Nothing to change. Have a good day!" }));
+            return { serviceId };
+        }
+        await p.runStep("updating container configuration", async () => {
+            const r = await this.apiClient.container.updateStack({
+                stackId,
+                data: {
+                    services: {
+                        [service.serviceName]: updatePayload,
+                    },
+                },
+            });
+            assertStatus(r, 200);
+        });
+        // Recreate the container if requested
+        if (this.flags.recreate) {
+            await p.runStep("recreating container", async () => {
+                const r = await this.apiClient.container.recreateService({
+                    serviceId,
+                    stackId,
+                });
+                assertSuccess(r);
+            });
+        }
+        await p.complete(_jsxs(Success, { children: ["Container ", _jsx(Value, { children: serviceId }), " was successfully updated.", this.flags.recreate &&
+                    " The container was recreated with the new configuration."] }));
+        return { serviceId };
+    }
+    /**
+     * Builds a container service update request from command line flags
+     *
+     * @returns A properly formatted container service request with only the
+     *   fields to update
+     */
+    async buildUpdateRequest() {
+        const updateRequest = {};
+        if (this.flags.image) {
+            updateRequest.image = this.flags.image;
+            // Get image metadata for port mappings if publish-all is specified
+            if (this.flags["publish-all"]) {
+                const projectId = await this.withProjectId(Update);
+                const imageMeta = await getImageMeta(this.apiClient, this.flags.image, projectId);
+                updateRequest.ports = getPortMappings(imageMeta, true);
+            }
+        }
+        if (this.flags.command) {
+            updateRequest.command = [this.flags.command];
+        }
+        if (this.flags.entrypoint) {
+            updateRequest.entrypoint = [this.flags.entrypoint];
+        }
+        if (this.flags.description) {
+            updateRequest.description = this.flags.description;
+        }
+        if (this.flags.env || this.flags["env-file"]) {
+            updateRequest.envs = await parseEnvironmentVariables(this.flags.env, this.flags["env-file"]);
+        }
+        if (this.flags.publish) {
+            updateRequest.ports = this.flags.publish;
+        }
+        if (this.flags.volume) {
+            updateRequest.volumes = this.flags.volume;
+        }
+        return updateRequest;
+    }
+    render({ serviceId }) {
+        if (this.flags.quiet) {
+            return serviceId;
+        }
+    }
+}

package/dist/commands/mail/address/create.d.ts

@@ -3,6 +3,7 @@ import { ReactNode } from "react";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
 import { FlagInput, OutputFlags } from "@oclif/core/interfaces";
 import ByteQuantity from "../../../lib/units/ByteQuantity.js";
+import { CommandFlags } from "../../../lib/basecommands/CommandFlags.js";
 type CreateResult = {
     addressId: string;
     generatedPassword: string | null;
@@ -27,7 +28,7 @@ export default class Create extends ExecRenderBaseCommand<typeof Create, CreateR
     }[];
     protected getPassword(process: ProcessRenderer): Promise<[string, boolean]>;
     protected createForwardAddress(projectId: string, process: ProcessRenderer, flags: OutputFlags<FlagInput<typeof Create.flags>>): Promise<CreateResult>;
-    protected createMailAddress(projectId: string, process: ProcessRenderer, flags: OutputFlags<FlagInput<typeof Create.flags>>): Promise<CreateResult>;
+    protected createMailAddress(projectId: string, process: ProcessRenderer, flags: CommandFlags<typeof Create>): Promise<CreateResult>;
     protected exec(): Promise<CreateResult>;
     protected render(executionResult: CreateResult): ReactNode;
 }

package/dist/commands/mail/address/create.js

@@ -116,6 +116,7 @@ export default class Create extends ExecRenderBaseCommand {
     }
     async createMailAddress(projectId, process, flags) {
         const [password, passwordGenerated] = await this.getPassword(process);
+        const { quota } = flags;
         const response = await process.runStep("creating mail address", async () => {
             const response = await this.apiClient.mail.createMailAddress({
                 projectId,
@@ -124,7 +125,7 @@ export default class Create extends ExecRenderBaseCommand {
                     isCatchAll: flags["catch-all"],
                     mailbox: {
                         password,
-                        quotaInBytes: flags.quota * 1024 * 1024,
+                        quotaInBytes: quota.bytes,
                         enableSpamProtection: flags["enable-spam-protection"],
                     },
                 },

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

@@ -45,11 +45,14 @@ export declare class ListOwn extends ListBaseCommand<typeof ListOwn, ResponseIte
             vatId?: string | undefined;
             vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
         };
+        avatarRef?: string;
         customerId: string;
         email: string;
         expiresAt?: string;
+        firstName: string;
         id: string;
         inviteId?: string;
+        lastName: string;
         memberSince?: string;
         mfa: boolean;
         role: MittwaldAPIV2.Components.Schemas.MembershipCustomerRoles;

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

@@ -48,11 +48,14 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
             registeredAt?: string | undefined;
             userId: string;
         };
+        avatarRef?: string;
         customerId: string;
         email: string;
         expiresAt?: string;
+        firstName: string;
         id: string;
         inviteId?: string;
+        lastName: string;
         memberSince?: string;
         mfa: boolean;
         role: MittwaldAPIV2.Components.Schemas.MembershipCustomerRoles;

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

@@ -0,0 +1,43 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+type ContainerContainerImageConfig = MittwaldAPIV2.Components.Schemas.ContainerContainerImageConfig;
+/**
+ * Parses environment variables from command line flags and env files
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariables(envFlags?: string[], envFiles?: string[]): Promise<Record<string, string>>;
+/**
+ * Parses environment variables from env files
+ *
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromFile(envFiles?: string[]): Promise<Record<string, string>>;
+/**
+ * Parses environment variables from command line flags
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromEnvFlags(envFlags?: string[]): Record<string, string>;
+/**
+ * Determines which ports to expose based on image metadata
+ *
+ * @param imageMeta Metadata about the container image
+ * @param publishAll Whether to publish all ports defined in the image
+ * @param publishPorts Array of port mappings specified by the user
+ * @returns An array of port mappings
+ */
+export declare function getPortMappings(imageMeta: ContainerContainerImageConfig, publishAll?: boolean, publishPorts?: string[]): string[];
+/**
+ * Retrieves metadata for a container image
+ *
+ * @param apiClient The API client instance
+ * @param image The container image reference
+ * @param projectId The project ID for credentials
+ * @returns Metadata about the container image
+ */
+export declare function getImageMeta(apiClient: MittwaldAPIV2Client, image: string, projectId: string): Promise<ContainerContainerImageConfig>;
+export {};

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

@@ -0,0 +1,82 @@
+import { assertStatus, } from "@mittwald/api-client";
+import * as fs from "fs/promises";
+import { parse } from "envfile";
+import { pathExists } from "../../util/fs/pathExists.js";
+/**
+ * Parses environment variables from command line flags and env files
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export async function parseEnvironmentVariables(envFlags = [], envFiles = []) {
+    return {
+        ...parseEnvironmentVariablesFromEnvFlags(envFlags),
+        ...(await parseEnvironmentVariablesFromFile(envFiles)),
+    };
+}
+/**
+ * Parses environment variables from env files
+ *
+ * @param envFiles Array of paths to env files
+ * @returns An object containing environment variable key-value pairs
+ */
+export async function parseEnvironmentVariablesFromFile(envFiles = []) {
+    const result = {};
+    for (const envFile of envFiles) {
+        if (!(await pathExists(envFile))) {
+            throw new Error(`Env file not found: ${envFile}`);
+        }
+        const fileContent = await fs.readFile(envFile, { encoding: "utf-8" });
+        const parsed = parse(fileContent);
+        Object.assign(result, parsed);
+    }
+    return result;
+}
+/**
+ * Parses environment variables from command line flags
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export function parseEnvironmentVariablesFromEnvFlags(envFlags = []) {
+    const splitIntoKeyAndValue = (e) => e.split("=", 2);
+    return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
+}
+/**
+ * Determines which ports to expose based on image metadata
+ *
+ * @param imageMeta Metadata about the container image
+ * @param publishAll Whether to publish all ports defined in the image
+ * @param publishPorts Array of port mappings specified by the user
+ * @returns An array of port mappings
+ */
+export function getPortMappings(imageMeta, publishAll = false, publishPorts = []) {
+    if (publishAll) {
+        const definedPorts = imageMeta.exposedPorts ?? [];
+        const concatPort = (p) => {
+            const [port, protocol = "tcp"] = p.port.split("/", 2);
+            return `${port}:${port}/${protocol}`;
+        };
+        return definedPorts.map(concatPort);
+    }
+    return publishPorts;
+}
+/**
+ * Retrieves metadata for a container image
+ *
+ * @param apiClient The API client instance
+ * @param image The container image reference
+ * @param projectId The project ID for credentials
+ * @returns Metadata about the container image
+ */
+export async function getImageMeta(apiClient, image, projectId) {
+    const resp = await apiClient.container.getContainerImageConfig({
+        queryParameters: {
+            imageReference: image,
+            useCredentialsForProjectId: projectId,
+        },
+    });
+    assertStatus(resp, 200);
+    return resp.data;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {