@mittwald/cli 1.13.1 → 1.13.3

package/dist/commands/container/update.js

@@ -65,7 +65,7 @@ export class Update extends ExecRenderBaseCommand {
         }),
         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." +
+            description: "This flag can be used to replace volume mounts of the container. It can be used multiple times to mount multiple volumes." +
                 "" +
                 "Needs to be in the format <host-path>:<container-path>. " +
                 "" +

package/dist/commands/cronjob/create.d.ts

@@ -15,6 +15,7 @@ export declare class Create extends ExecRenderBaseCommand<typeof Create, Result>
         interpreter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         disable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         timeout: import("@oclif/core/interfaces").OptionFlag<Duration, import("@oclif/core/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         "installation-id": import("@oclif/core/interfaces").OptionFlag<string>;
     };

package/dist/commands/cronjob/create.js

@@ -41,11 +41,12 @@ export class Create extends ExecRenderBaseCommand {
             default: Duration.fromString("1h"),
             required: false,
         }),
+        timezone: cronjobFlagDefinitions.timezone(),
     };
     async exec() {
         const p = makeProcessRenderer(this.flags, "Creating a new cron job");
         const appInstallationId = await this.withAppInstallationId(Create);
-        const { description, interval, disable, email, url, interpreter, command, timeout, } = this.flags;
+        const { description, interval, disable, email, url, interpreter, command, timeout, timezone, } = this.flags;
         const { projectId } = await p.runStep("fetching project", async () => {
             const r = await this.apiClient.app.getAppinstallation({
                 appInstallationId,
@@ -67,6 +68,7 @@ export class Create extends ExecRenderBaseCommand {
                     email,
                     destination: buildCronjobDestination(url, command, interpreter),
                     timeout: timeout.seconds,
+                    timeZone: timezone,
                 },
             });
             assertStatus(r, 201);

package/dist/commands/cronjob/list.js

@@ -21,6 +21,10 @@ export class List extends ListBaseCommand {
             shortId,
             interval: {},
             description: {},
+            timezone: {
+                header: "Timezone",
+                get: (r) => r.timeZone || "UTC",
+            },
             lastExecution: {
                 header: "Last execution",
                 get: (r) => {

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

@@ -17,6 +17,7 @@ export default class Update extends ExecRenderBaseCommand<typeof Update, UpdateR
         enable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         disable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         timeout: import("@oclif/core/interfaces").OptionFlag<Duration | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     protected exec(): Promise<void>;

package/dist/commands/cronjob/update.js

@@ -47,6 +47,7 @@ export default class Update extends ExecRenderBaseCommand {
                 "If an email address is defined, an error message will be sent.",
             required: false,
         }),
+        timezone: cronjobFlagDefinitions.timezone(),
     };
     async exec() {
         const process = makeProcessRenderer(this.flags, "Updating cron job");
@@ -55,7 +56,7 @@ export default class Update extends ExecRenderBaseCommand {
             cronjobId,
         });
         assertSuccess(currentCronjob);
-        const { description, interval, email, timeout, url, interpreter, command, enable, disable, } = this.flags;
+        const { description, interval, email, timeout, url, interpreter, command, enable, disable, timezone, } = this.flags;
         if (Object.keys(this.flags).length == 0) {
             await process.complete(_jsx(Success, { children: "Nothing to change. Have a good day!" }));
             return;
@@ -72,6 +73,7 @@ export default class Update extends ExecRenderBaseCommand {
                     timeout: timeout?.seconds,
                     email,
                     interval,
+                    timeZone: timezone,
                 },
             });
             assertSuccess(response);

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

@@ -39,6 +39,7 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
             isAllowedToPlaceOrders?: boolean | undefined;
             isBanned?: boolean | undefined;
             isInDefaultOfPayment?: boolean | undefined;
+            isMailAddressInvalid?: boolean | undefined;
             levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
             memberCount: number;
             name: string;

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

@@ -39,6 +39,7 @@ export declare class ListOwn extends ListBaseCommand<typeof ListOwn, ResponseIte
             isAllowedToPlaceOrders?: boolean | undefined;
             isBanned?: boolean | undefined;
             isInDefaultOfPayment?: boolean | undefined;
+            isMailAddressInvalid?: boolean | undefined;
             levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
             memberCount: number;
             name: string;

package/dist/commands/stack/deploy.js

@@ -12,7 +12,7 @@ import { enrichStackDefinition } from "../../lib/resources/stack/enrich.js";
 import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
 import { loadStackFromTemplate } from "../../lib/resources/stack/template-loader.js";
-import { parse } from "envfile";
+import { parseEnvironmentVariablesFromStr } from "../../lib/util/parser.js";
 export class Deploy extends ExecRenderBaseCommand {
     static description = "Deploys a docker-compose compatible file to a mittwald container stack";
     static aliases = ["stack:up"];
@@ -56,7 +56,7 @@ This flag is mutually exclusive with --compose-file.`,
             // Load from GitHub template
             const { composeYaml, envContent } = await renderer.runStep("fetching template from GitHub", () => loadStackFromTemplate(source.template));
             if (envContent) {
-                const templateEnv = parse(envContent);
+                const templateEnv = parseEnvironmentVariablesFromStr(envContent);
                 env = { ...env, ...templateEnv };
             }
             env = await collectEnvironment(env, envFile);

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

@@ -15,13 +15,6 @@ export declare function parseEnvironmentVariables(envFlags?: string[], envFiles?
  * @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
  *

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

@@ -1,7 +1,7 @@
 import { assertStatus, } from "@mittwald/api-client";
 import * as fs from "fs/promises";
-import { parse } from "envfile";
 import { pathExists } from "../../util/fs/pathExists.js";
+import { parseEnvironmentVariablesFromArray, parseEnvironmentVariablesFromStr, } from "../../util/parser.js";
 /**
  * Parses environment variables from command line flags and env files
  *
@@ -11,7 +11,7 @@ import { pathExists } from "../../util/fs/pathExists.js";
  */
 export async function parseEnvironmentVariables(envFlags = [], envFiles = []) {
     return {
-        ...parseEnvironmentVariablesFromEnvFlags(envFlags),
+        ...parseEnvironmentVariablesFromArray(envFlags),
         ...(await parseEnvironmentVariablesFromFile(envFiles)),
     };
 }
@@ -28,27 +28,11 @@ export async function parseEnvironmentVariablesFromFile(envFiles = []) {
             throw new Error(`Env file not found: ${envFile}`);
         }
         const fileContent = await fs.readFile(envFile, { encoding: "utf-8" });
-        const parsed = parse(fileContent);
+        const parsed = parseEnvironmentVariablesFromStr(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) => {
-        const index = e.indexOf("=");
-        if (index < 0) {
-            throw new Error(`Invalid environment variable format: ${e}`);
-        }
-        return [e.slice(0, index), e.slice(index + 1)];
-    };
-    return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
-}
 /**
  * Determines which ports to expose based on image metadata
  *

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

@@ -23,4 +23,8 @@ export declare const cronjobFlagDefinitions: {
         multiple: false;
         requiredOrDefaulted: false;
     }>;
+    timezone: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+        multiple: false;
+        requiredOrDefaulted: false;
+    }>;
 };

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

@@ -25,4 +25,8 @@ export const cronjobFlagDefinitions = {
         summary: "Set the interpreter to be used for execution.",
         description: "Must be either 'bash' or 'php'. Define the interpreter to be used to execute the previously defined command. The interpreter should match the corresponding command or script.",
     }),
+    timezone: Flags.custom({
+        summary: "Set the timezone for the cron job.",
+        description: "Specify the timezone in which the cron job should be executed. Use standard timezone identifiers (e.g., 'Europe/Berlin', 'America/New_York'). Defaults to UTC if not specified.",
+    }),
 };

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

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

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

@@ -1,9 +1,13 @@
 import { readFile } from "fs/promises";
-import { parse } from "envfile";
+import { parseEnvironmentVariablesFromArray, parseEnvironmentVariablesFromStr, } from "../../util/parser.js";
 export async function enrichStackDefinition(input) {
     const enriched = structuredClone(input);
     for (const serviceName of Object.keys(input.services ?? {})) {
         let service = enriched.services[serviceName];
+        // resolve array into object before enriching
+        if (service.envs && Array.isArray(service.envs)) {
+            service.envs = parseEnvironmentVariablesFromArray(service.envs);
+        }
         service = await setEnvironmentFromEnvFile(service);
         enriched.services[serviceName] = service;
     }
@@ -20,7 +24,7 @@ async function setEnvironmentFromEnvFile(service) {
     let envVars = {};
     for (const envFile of envFiles) {
         const envFileContent = await readFile(envFile, "utf-8");
-        const fileEnvVars = parse(envFileContent);
+        const fileEnvVars = parseEnvironmentVariablesFromStr(envFileContent);
         envVars = { ...envVars, ...fileEnvVars };
     }
     delete enriched.env_file;

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

@@ -4,10 +4,36 @@ jest.unstable_mockModule("fs/promises", () => ({
     readFile: mockReadFile,
 }));
 const { enrichStackDefinition } = await import("./enrich.js");
+const { loadStackFromStr } = await import("./loader.js");
+const { sanitizeStackDefinition } = await import("./sanitize.js");
 describe("enrichStackDefinition", () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
+    it("should resolve environment lists to objects", async () => {
+        const input = {
+            services: {
+                webapp: {
+                    image: "postgres:latest",
+                    envs: ["something=little", 'bit="of love"'],
+                },
+            },
+        };
+        const expected = {
+            services: {
+                webapp: {
+                    image: "postgres:latest",
+                    envs: {
+                        something: "little",
+                        bit: "of love",
+                    },
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(result).toEqual(expected);
+        expect(mockReadFile).not.toHaveBeenCalled();
+    });
     it("should handle service without env_file", async () => {
         const input = {
             services: {
@@ -165,3 +191,161 @@ describe("enrichStackDefinition", () => {
         });
     });
 });
+describe("Integration Test: Docker Compose to Mittwald API Request transformation", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should transform Docker Compose file, environment variables, and CLI args into a valid API request", async () => {
+        // Sample Docker Compose file content
+        const dockerComposeFile = `
+      version: '3'
+      services:
+        nginx:
+          image: 'nginx:latest'
+          ports:
+            - "80:80"
+          environment:
+            APP_ENV: "development"
+            API_URL: "\${CUSTOM_API_URL:-https://default.api}"
+          env_file:
+            - ".env"
+            - ".env.local"
+    `;
+        // Mocking environment variables (process.env)
+        const cliEnv = {
+            CUSTOM_API_URL: "https://cli.api",
+        };
+        // Mocking .env files using fs/promises
+        mockReadFile
+            .mockResolvedValueOnce("DB_HOST=db.local\nDB_PORT=5432") // Content of .env
+            .mockResolvedValueOnce("DB_HOST=db.override.local\nDB_USER=user123"); // Content of .env.local
+        // Step 1: Load and parse Docker Compose file
+        const parsedStack = await loadStackFromStr(dockerComposeFile, cliEnv);
+        // Step 2: Sanitize stack definition ( compat layer )
+        const sanitizedStack = sanitizeStackDefinition(parsedStack);
+        // Step 3: Enrich stack definition (process environment variables)
+        const enrichedStack = await enrichStackDefinition(sanitizedStack);
+        // Expected API request format after the transformation
+        const expectedApiRequest = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    ports: ["80:80"],
+                    envs: {
+                        APP_ENV: "development", // From compose file
+                        API_URL: "https://cli.api", // Default value overridden by CLI env
+                        DB_HOST: "db.override.local", // Overridden by .env.local
+                        DB_PORT: "5432", // Value from first .env file
+                        DB_USER: "user123", // Value from .env.local
+                    },
+                },
+            },
+        };
+        // Assertions
+        expect(enrichedStack).toMatchObject(expectedApiRequest);
+        // Type Assertions
+        const typeCheck = enrichedStack;
+        expect(typeCheck).toBeTruthy();
+        // Ensure env files are read in order
+        expect(mockReadFile).toHaveBeenCalledWith(".env", "utf-8");
+        expect(mockReadFile).toHaveBeenCalledWith(".env.local", "utf-8");
+    });
+    it("should transform Docker Compose file with list environment, environment variables, and CLI args into a valid API request", async () => {
+        // Sample Docker Compose file content
+        const dockerComposeFile = `
+      version: '3'
+      services:
+        nginx:
+          image: 'nginx:latest'
+          ports:
+            - "80:80"
+          environment:
+            - APP_ENV=development
+            - API_URL=\${CUSTOM_API_URL:-https://default.api}
+          env_file:
+            - ".env"
+            - ".env.local"
+    `;
+        // Mocking environment variables (process.env)
+        const cliEnv = {
+            CUSTOM_API_URL: "https://cli.api",
+        };
+        // Mocking .env files using fs/promises
+        mockReadFile
+            .mockResolvedValueOnce("DB_HOST=db.local\nDB_PORT=5432") // Content of .env
+            .mockResolvedValueOnce("DB_HOST=db.override.local\nDB_USER=user123"); // Content of .env.local
+        // Step 1: Load and parse Docker Compose file
+        const parsedStack = await loadStackFromStr(dockerComposeFile, cliEnv);
+        // Step 2: Sanitize stack definition ( compat layer )
+        const sanitizedStack = sanitizeStackDefinition(parsedStack);
+        // Step 3: Enrich stack definition (process environment variables)
+        const enrichedStack = await enrichStackDefinition(sanitizedStack);
+        // Expected API request format after the transformation
+        const expectedApiRequest = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    ports: ["80:80"],
+                    envs: {
+                        APP_ENV: "development", // From compose file
+                        API_URL: "https://cli.api", // Default value overridden by CLI env
+                        DB_HOST: "db.override.local", // Overridden by .env.local
+                        DB_PORT: "5432", // Value from first .env file
+                        DB_USER: "user123", // Value from .env.local
+                    },
+                },
+            },
+        };
+        // Assertions
+        expect(enrichedStack).toMatchObject(expectedApiRequest);
+        // Type Assertions
+        const typeCheck = enrichedStack;
+        expect(typeCheck).toBeTruthy();
+        // Ensure env files are read in order
+        expect(mockReadFile).toHaveBeenCalledWith(".env", "utf-8");
+        expect(mockReadFile).toHaveBeenCalledWith(".env.local", "utf-8");
+    });
+    it("Issue # 1589: Invalid JSON from env file", async () => {
+        // Sample Docker Compose file content
+        const dockerComposeFile = `
+      version: '3'
+      services:
+        nginx:
+          image: 'nginx:latest'
+          ports:
+            - "80:80"
+          environment:
+            EXCLUDES: \${CUSTOM_EXCLUDES:-failed}
+    `;
+        // simulate env file input, mimes "collectEnvironment" output
+        const env = {
+            CUSTOM_EXCLUDES: JSON.stringify(["foo", "bar"]),
+        };
+        // Step 1: Load and parse Docker Compose file
+        // stuff from --env-file and/or process environment
+        // is already injected here!
+        const parsedStack = await loadStackFromStr(dockerComposeFile, env);
+        // Step 2: Sanitize stack definition ( compat layer )
+        const sanitizedStack = sanitizeStackDefinition(parsedStack);
+        // Step 3: Enrich stack definition (process environment variables)
+        // this one deals with additional env files *per service*
+        const enrichedStack = await enrichStackDefinition(sanitizedStack);
+        // Expected API request format after the transformation
+        const expectedApiRequest = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    ports: ["80:80"],
+                    envs: {
+                        EXCLUDES: JSON.stringify(["foo", "bar"]),
+                    },
+                },
+            },
+        };
+        // Assertions
+        expect(enrichedStack).toMatchObject(expectedApiRequest);
+        // Type Assertions
+        const typeCheck = enrichedStack;
+        expect(typeCheck).toBeTruthy();
+    });
+});

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

@@ -1,13 +1,13 @@
 import * as fs from "fs/promises";
-import { parse } from "envfile";
 import { pathExists } from "../../util/fs/pathExists.js";
 import { getRandomValues } from "node:crypto";
+import { parseEnvironmentVariablesFromStr } from "../../util/parser.js";
 export async function collectEnvironment(base, envFile) {
     if (!(await pathExists(envFile))) {
         return base;
     }
     const defs = await fs.readFile(envFile, { encoding: "utf-8" });
-    const parsed = parse(defs);
+    const parsed = parseEnvironmentVariablesFromStr(defs);
     return { ...base, ...parsed };
 }
 /**

package/dist/lib/resources/stack/env.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect, beforeEach, jest } from "@jest/globals";
+import { collectEnvironment } from "./env.js";
+import * as path from "path";
+describe("collectEnvironment", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should preserve JSON array strings from env file", async () => {
+        // Simulate base environment variables
+        const baseEnv = {
+            NODE_ENV: "production",
+        };
+        // Mock .env file path and its content
+        const envFilePath = path.join(import.meta.dirname, "test_assets", "test.env");
+        // Call `collectEnvironment` with the mocks in effect
+        const result = await collectEnvironment(baseEnv, envFilePath);
+        // Assertions
+        expect(result).toEqual({
+            NODE_ENV: "production",
+            NODES_EXCLUDE: '["node1","node2","node3"]', // JSON array must remain a string
+            MY_ENV: "8.8.8.8",
+        });
+    });
+});

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

@@ -1,5 +1,3 @@
-import type { MittwaldAPIV2 } from "@mittwald/api-client";
-type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
-export declare function loadStackFromFile(file: string, environment: Record<string, string | undefined>): Promise<StackRequest>;
-export declare function loadStackFromStr(input: string, environment: Record<string, string | undefined>): Promise<StackRequest>;
-export {};
+import { RawStackInput } from "./types.js";
+export declare function loadStackFromFile(file: string, environment: Record<string, string | undefined>): Promise<RawStackInput>;
+export declare function loadStackFromStr(input: string, environment: Record<string, string | undefined>): Promise<RawStackInput>;

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

@@ -1,10 +1,8 @@
-import type { MittwaldAPIV2 } from "@mittwald/api-client";
-type StackRequest = MittwaldAPIV2.Paths.V2StacksStackId.Put.Parameters.RequestBody;
+import { RawStackInput } from "./types.js";
 /**
  * This function is needed to work around the mStudios supposedly docker-compose
  * compatible container stack API.
  *
  * @param stack
  */
-export declare function sanitizeStackDefinition(stack: StackRequest): StackRequest;
-export {};
+export declare function sanitizeStackDefinition(stack: RawStackInput): RawStackInput;

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

@@ -9,4 +9,26 @@ export type ContainerServiceInput = ContainerServiceDeclareRequest & {
     };
     ports?: string[];
 };
+export type RawStackInput = {
+    services?: {
+        [serviceName: string]: {
+            environment?: string[] | {
+                [k: string]: string;
+            };
+            env_file?: string | string[];
+            image: string;
+            ports?: string[];
+            command?: string[];
+            description?: string;
+            envs?: string[] | {
+                [k: string]: string;
+            };
+        };
+    };
+    volumes?: {
+        [key: string]: {
+            name: string;
+        };
+    };
+};
 export {};

package/dist/lib/util/parser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parses environment variables from array and strips unnecessary quotes from
+ * values.
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromArray(envFlags?: string[]): Record<string, string>;
+/**
+ * Parses environment variables from string. Called with .env file content.
+ *
+ * @param src String describing environment, .env file notation
+ * @returns An object containing environment variable key-value pairs
+ */
+export declare function parseEnvironmentVariablesFromStr(src: string): Record<string, string>;

package/dist/lib/util/parser.js

@@ -0,0 +1,41 @@
+/**
+ * Parses environment variables from array and strips unnecessary quotes from
+ * values.
+ *
+ * @param envFlags Array of environment variable strings in KEY=VALUE format
+ * @returns An object containing environment variable key-value pairs
+ */
+export function parseEnvironmentVariablesFromArray(envFlags = []) {
+    const splitIntoKeyAndValue = (e) => {
+        const index = e.indexOf("=");
+        if (index < 0) {
+            throw new Error(`Invalid environment variable format: ${e}`);
+        }
+        const key = e.slice(0, index);
+        const rawValue = e.slice(index + 1);
+        // Remove enclosing quotes (if they exist)
+        const isQuoted = rawValue.startsWith('"') && rawValue.endsWith('"');
+        const value = isQuoted ? rawValue.slice(1, -1) : rawValue;
+        return [key, value];
+    };
+    return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
+}
+/**
+ * Parses environment variables from string. Called with .env file content.
+ *
+ * @param src String describing environment, .env file notation
+ * @returns An object containing environment variable key-value pairs
+ */
+export function parseEnvironmentVariablesFromStr(src) {
+    const result = {};
+    const lines = src.toString().split("\n");
+    for (const line of lines) {
+        const match = line.match(/^([^=:#]+?)[=:](.*)/);
+        if (match) {
+            const key = match[1].trim();
+            const value = match[2].trim();
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/lib/util/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/util/parser.test.js

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "@jest/globals";
+import { parseEnvironmentVariablesFromArray, parseEnvironmentVariablesFromStr, } from "./parser.js";
+describe("Containerconfig handling", () => {
+    describe("Config parsing", () => {
+        test("call parser with simple flags", () => {
+            const args = ["foo=bar", "ham=eggs"];
+            const res = parseEnvironmentVariablesFromArray(args);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("call parser with flag containing another '='", () => {
+            const args = ["extra_args=first=1 second=2 third=littlebitoflove"];
+            const res = parseEnvironmentVariablesFromArray(args);
+            expect(res).toStrictEqual({
+                extra_args: "first=1 second=2 third=littlebitoflove",
+            });
+        });
+        test("throw error for invalid flag format", () => {
+            const args = ["invalidFlagWithoutEqualsSign"];
+            expect(() => parseEnvironmentVariablesFromArray(args)).toThrow("Invalid environment variable format: invalidFlagWithoutEqualsSign");
+        });
+        test("remove enclosing quotes from values", () => {
+            const args = ['foo="bar"', 'ham="eggs and bacon"'];
+            const res = parseEnvironmentVariablesFromArray(args);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs and bacon",
+            });
+        });
+        test("preserve values with quotes in the middle", () => {
+            const args = ['foo=bar"baz', 'ham=eggs"and"bacon'];
+            const res = parseEnvironmentVariablesFromArray(args);
+            expect(res).toStrictEqual({
+                foo: 'bar"baz',
+                ham: 'eggs"and"bacon',
+            });
+        });
+    });
+    describe("parseEnvironmentVariablesFromStr", () => {
+        test("parse simple .env format", () => {
+            const src = "foo=bar\nham=eggs";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("parse .env format with colon separator", () => {
+            const src = "foo:bar\nham:eggs";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("parse .env format with empty lines", () => {
+            const src = "foo=bar\n\nham=eggs\n";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("parse .env format with comments", () => {
+            const src = "foo=bar\n# comment line\nham=eggs";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("parse .env format with values containing equals signs", () => {
+            const src = "extra_args=first=1 second=2 third=littlebitoflove";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                extra_args: "first=1 second=2 third=littlebitoflove",
+            });
+        });
+        test("trim whitespace from keys and values", () => {
+            const src = "  foo  =  bar  \n  ham  :  eggs  ";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("handle empty string input", () => {
+            const src = "";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({});
+        });
+        test("ignore lines without key-value pairs", () => {
+            const src = "foo=bar\ninvalid line\nham=eggs";
+            const res = parseEnvironmentVariablesFromStr(src);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+    });
+});

package/dist/rendering/react/components/CronJob/CronJobDetails.js

@@ -34,6 +34,7 @@ export const CronJobDetails = ({ cronjob }) => {
         Project: project ? _jsx(IDAndShortID, { object: project }) : _jsx(Value, { notSet: true }),
         App: _jsx(IDAndShortID, { object: app }),
         Schedule: (_jsxs(Text, { children: [_jsx(Value, { children: cronjob.interval }), " (next execution:", " ", _jsx(CronJobNextExecution, { cronjob: cronjob }), ")"] })),
+        Timezone: _jsx(Value, { children: cronjob.timeZone || "UTC" }),
     };
     const sections = [
         _jsx(SingleResult, { title: _jsxs(_Fragment, { children: ["CRON JOB DETAILS: ", _jsx(Value, { children: cronjob.description })] }), rows: rows }, "primary"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.13.1",
+  "version": "1.13.3",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "repository": {
@@ -57,7 +57,6 @@
     "chalk": "^5.3.0",
     "date-fns": "^4.0.0",
     "docker-names": "^1.2.1",
-    "envfile": "^7.1.0",
     "fast-xml-parser": "^5.2.5",
     "ink": "^6.2.3",
     "ink-link": "^5.0.0",
@@ -72,7 +71,7 @@
     "semver": "^7.5.4",
     "semver-parser": "^4.1.6",
     "shell-escape": "^0.2.0",
-    "slice-ansi": "^7.1.0",
+    "slice-ansi": "^8.0.0",
     "string-width": "^8.0.0",
     "tempfile": "^6.0.1",
     "uuid": "^13.0.0"
@@ -97,11 +96,11 @@
     "license-checker-rseidelsohn": "^4.2.6",
     "nock": "^14.0.0",
     "oclif": "^4.14.31",
-    "prettier": "~3.6.2",
+    "prettier": "~3.8.1",
     "prettier-plugin-jsdoc": "^1.3.2",
     "prettier-plugin-package": "^2.0.0",
     "prettier-plugin-sort-json": "^4.1.1",
-    "rimraf": "^5.0.1",
+    "rimraf": "^6.1.3",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "tsx": "^4.7.1",

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

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "@jest/globals";
-import { parseEnvironmentVariablesFromEnvFlags } from "./containerconfig.js";
-describe("Containerconfig handling", () => {
-    describe("Config parsing", () => {
-        test("call parser with simple flags", () => {
-            const args = ["foo=bar", "ham=eggs"];
-            const res = parseEnvironmentVariablesFromEnvFlags(args);
-            expect(res).toStrictEqual({
-                foo: "bar",
-                ham: "eggs",
-            });
-        });
-        test("call parser with flag containing another '='", () => {
-            const args = ["extra_args=first=1 second=2 third=littlebitoflove"];
-            const res = parseEnvironmentVariablesFromEnvFlags(args);
-            expect(res).toStrictEqual({
-                extra_args: "first=1 second=2 third=littlebitoflove",
-            });
-        });
-        test("throw error for invalid flag format", () => {
-            const args = ["invalidFlagWithoutEqualsSign"];
-            expect(() => parseEnvironmentVariablesFromEnvFlags(args)).toThrow("Invalid environment variable format: invalidFlagWithoutEqualsSign");
-        });
-    });
-});