@mittwald/cli 1.10.0 → 1.11.1

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

@@ -0,0 +1,167 @@
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+const mockReadFile = jest.fn();
+jest.unstable_mockModule("fs/promises", () => ({
+    readFile: mockReadFile,
+}));
+const { enrichStackDefinition } = await import("./enrich.js");
+describe("enrichStackDefinition", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should handle service without env_file", async () => {
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    ports: ["80:80"],
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(result).toEqual(input);
+        expect(mockReadFile).not.toHaveBeenCalled();
+    });
+    it("should handle single env_file as string", async () => {
+        mockReadFile.mockResolvedValueOnce("FOO=bar\nBAZ=qux");
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    env_file: ".env",
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(mockReadFile).toHaveBeenCalledWith(".env", "utf-8");
+        expect(result).toEqual({
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    envs: {
+                        FOO: "bar",
+                        BAZ: "qux",
+                    },
+                },
+            },
+        });
+    });
+    it("should handle env_file as array", async () => {
+        mockReadFile
+            .mockResolvedValueOnce("FOO=bar\nBAZ=qux")
+            .mockResolvedValueOnce("FOO=overridden\nNEW=value");
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    env_file: [".env", ".env.local"],
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(mockReadFile).toHaveBeenCalledWith(".env", "utf-8");
+        expect(mockReadFile).toHaveBeenCalledWith(".env.local", "utf-8");
+        expect(result).toEqual({
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    envs: {
+                        FOO: "overridden", // Later file should override
+                        BAZ: "qux",
+                        NEW: "value",
+                    },
+                },
+            },
+        });
+    });
+    it("should merge env_file variables with existing envs", async () => {
+        mockReadFile.mockResolvedValueOnce("FOO=from_file\nFILE_VAR=file_value");
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    env_file: ".env",
+                    envs: {
+                        FOO: "existing", // Should override env_file
+                        EXISTING_VAR: "existing_value",
+                    },
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(result).toEqual({
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    envs: {
+                        FOO: "existing", // Existing envs take precedence
+                        FILE_VAR: "file_value",
+                        EXISTING_VAR: "existing_value",
+                    },
+                },
+            },
+        });
+    });
+    it("should handle multiple services with different env_file configurations", async () => {
+        mockReadFile
+            .mockResolvedValueOnce("NGINX_VAR=nginx_value")
+            .mockResolvedValueOnce("APP_VAR=app_value1")
+            .mockResolvedValueOnce("APP_VAR=app_value2\nOTHER=other");
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    env_file: ".env.nginx",
+                },
+                app: {
+                    image: "app:latest",
+                    env_file: [".env.app", ".env.app.local"],
+                },
+                db: {
+                    image: "postgres:latest",
+                    // No env_file
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(result).toEqual({
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    envs: {
+                        NGINX_VAR: "nginx_value",
+                    },
+                },
+                app: {
+                    image: "app:latest",
+                    envs: {
+                        APP_VAR: "app_value2", // Later file overrides
+                        OTHER: "other",
+                    },
+                },
+                db: {
+                    image: "postgres:latest",
+                },
+            },
+        });
+    });
+    it("should handle empty env files", async () => {
+        mockReadFile.mockResolvedValueOnce("");
+        const input = {
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    env_file: ".env",
+                },
+            },
+        };
+        const result = await enrichStackDefinition(input);
+        expect(result).toEqual({
+            services: {
+                nginx: {
+                    image: "nginx:latest",
+                    envs: {},
+                },
+            },
+        });
+    });
+});

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

@@ -3,7 +3,7 @@ type ContainerServiceDeclareRequest = MittwaldAPIV2.Components.Schemas.Container
 export type ContainerServiceInput = ContainerServiceDeclareRequest & {
     command?: string[] | string;
     entrypoint?: string[] | string;
-    env_file?: string;
+    env_file?: string | string[];
     environment?: {
         [k: string]: string;
     };

package/dist/rendering/process/components/ProcessStateIcon.js

@@ -10,7 +10,7 @@ export const ProcessStateIcon = ({ step }) => {
         return _jsx(Text, { children: "\u2753" });
     }
     else if (step.phase === "completed") {
-        return _jsx(Text, { children: "\u2705" });
+        return _jsx(Text, { children: "\u2705 " });
     }
     else if (step.phase === "aborted") {
         return _jsx(Text, { children: "\u23E9\uFE0F " });

package/dist/rendering/process/process.d.ts

@@ -1,11 +1,11 @@
-import { ReactElement, ReactNode } from "react";
+import { ReactElement } from "react";
 export type ProcessStepInfo = {
     type: "info";
-    title: ReactNode;
+    title: string;
 };
 export type ProcessStepRunnable = {
     type: "step";
-    title: ReactNode;
+    title: string;
     phase: "running" | "completed" | "failed" | "aborted";
     error?: unknown;
     progress?: string;
@@ -13,27 +13,27 @@ export type ProcessStepRunnable = {
 };
 export type ProcessStepConfirm = {
     type: "confirm";
-    title: ReactNode;
+    title: string;
     confirmed: boolean | undefined;
 };
 export type ProcessStepInput = {
     type: "input";
-    title: ReactNode;
+    title: string;
     mask?: boolean;
     value?: string;
 };
 export type ProcessStepSelect<TVal> = {
     type: "select";
-    title: ReactNode;
+    title: string;
     options: {
         value: TVal;
-        label: ReactNode;
+        label: string;
     }[];
     selected?: TVal;
 };
 export type ProcessStep = ProcessStepInfo | ProcessStepRunnable | ProcessStepConfirm | ProcessStepInput | ProcessStepSelect<unknown>;
 export type CleanupFunction = {
-    title: ReactNode;
+    title: string;
     fn: () => Promise<unknown>;
 };
 export declare class RunnableHandler {
@@ -53,16 +53,16 @@ export declare class RunnableHandler {
 }
 export interface ProcessRenderer {
     start(): void;
-    addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
-    addInfo(title: ReactNode): void;
-    addConfirmation(question: ReactNode): Promise<boolean>;
-    addInput(question: ReactNode, mask?: boolean): Promise<string>;
-    addSelect<TVal>(question: ReactNode, options: {
+    addStep(title: string): RunnableHandler;
+    runStep<TRes>(title: string, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
+    addInfo(title: string): void;
+    addConfirmation(question: string): Promise<boolean>;
+    addInput(question: string, mask?: boolean): Promise<string>;
+    addSelect<TVal>(question: string, options: {
         value: TVal;
-        label: ReactNode;
+        label: string;
     }[]): Promise<TVal>;
-    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    addCleanup(title: string, fn: () => Promise<unknown>): void;
     complete(summary: ReactElement): Promise<void>;
     error(err: unknown): Promise<void>;
 }

package/dist/rendering/process/process_exec.d.ts

@@ -1,3 +1,2 @@
 import { ProcessRenderer } from "./process.js";
-import { ReactNode } from "react";
-export declare function spawnInProcess(r: ProcessRenderer, title: ReactNode, cmd: string, args: string[]): Promise<void>;
+export declare function spawnInProcess(r: ProcessRenderer, title: string, cmd: string, args: string[]): Promise<void>;

package/dist/rendering/process/process_fancy.d.ts

@@ -1,4 +1,4 @@
-import React, { ReactElement, ReactNode } from "react";
+import { ReactElement } from "react";
 import { ProcessRenderer, RunnableHandler } from "./process.js";
 export declare class FancyProcessRenderer implements ProcessRenderer {
     private readonly title;
@@ -7,18 +7,18 @@ export declare class FancyProcessRenderer implements ProcessRenderer {
     private cleanupFns;
     constructor(title: string);
     start(): void;
-    addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(title: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
-    addInfo(title: ReactNode): void;
-    addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
-    addSelect<TVal>(question: React.ReactNode, options: {
+    addStep(title: string): RunnableHandler;
+    runStep<TRes>(title: string, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
+    addInfo(title: string): void;
+    addInput(question: string, mask?: boolean): Promise<string>;
+    addSelect<TVal>(question: string, options: {
         value: TVal;
-        label: React.ReactNode;
+        label: string;
     }[]): Promise<TVal>;
-    addConfirmation(question: ReactElement): Promise<boolean>;
+    addConfirmation(question: string): Promise<boolean>;
     complete(summary: ReactElement): Promise<void>;
     error(err: unknown): Promise<void>;
     private renderStart;
-    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    addCleanup(title: string, fn: () => Promise<unknown>): void;
     private cleanup;
 }

package/dist/rendering/process/process_flags.js

@@ -1,6 +1,7 @@
 import { FancyProcessRenderer } from "./process_fancy.js";
 import { Flags } from "@oclif/core";
 import { SilentProcessRenderer } from "./process_quiet.js";
+import { SimpleProcessRenderer } from "./process_simple.js";
 export const processFlags = {
     quiet: Flags.boolean({
         char: "q",
@@ -25,5 +26,8 @@ export const makeProcessRenderer = (flags, title) => {
     if (flags.quiet) {
         return new SilentProcessRenderer();
     }
+    if (!process.stdout.isTTY) {
+        return new SimpleProcessRenderer(title, process.stdout);
+    }
     return new FancyProcessRenderer(title);
 };

package/dist/rendering/process/process_quiet.d.ts

@@ -1,16 +1,15 @@
-import { ReactNode } from "react";
 import { ProcessRenderer, RunnableHandler } from "./process.js";
 export declare class SilentProcessRenderer implements ProcessRenderer {
     private cleanupFns;
     start(): void;
-    addStep(title: ReactNode): RunnableHandler;
-    runStep<TRes>(unusedTitle: ReactNode, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
+    addStep(title: string): RunnableHandler;
+    runStep<TRes>(unusedTitle: string, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
     addInfo(): void;
     complete(): Promise<void>;
     error(err: unknown): Promise<void>;
     addConfirmation(): Promise<boolean>;
     addInput(): Promise<string>;
     addSelect<TVal>(): Promise<TVal>;
-    addCleanup(_: ReactNode, fn: () => Promise<unknown>): void;
+    addCleanup(_: string, fn: () => Promise<unknown>): void;
     private cleanup;
 }

package/dist/rendering/process/process_simple.d.ts

@@ -0,0 +1,26 @@
+import { ReactElement } from "react";
+import { ProcessRenderer, RunnableHandler } from "./process.js";
+import { Writable } from "stream";
+export declare class SimpleProcessRenderer implements ProcessRenderer {
+    private readonly title;
+    private readonly output;
+    private started;
+    private cleanupFns;
+    private stepCounter;
+    constructor(title: string, output: Writable);
+    start(): void;
+    addStep(title: string): RunnableHandler;
+    runStep<TRes>(title: string, fn: (() => Promise<TRes>) | Promise<TRes>): Promise<TRes>;
+    addInfo(title: string): void;
+    addConfirmation(question: string): Promise<boolean>;
+    addInput(question: string, mask?: boolean): Promise<string>;
+    addSelect<TVal>(question: string, options: {
+        value: TVal;
+        label: string;
+    }[]): Promise<TVal>;
+    addCleanup(title: string, fn: () => Promise<unknown>): void;
+    complete(summary: ReactElement): Promise<void>;
+    error(err: unknown): Promise<void>;
+    private cleanup;
+    private renderElementToText;
+}

package/dist/rendering/process/process_simple.js

@@ -0,0 +1,143 @@
+import { RunnableHandler, } from "./process.js";
+export class SimpleProcessRenderer {
+    title;
+    output;
+    started = false;
+    cleanupFns = [];
+    stepCounter = 0;
+    constructor(title, output) {
+        this.title = title;
+        this.output = output;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.output.write(`Starting: ${this.title}\n\n`);
+    }
+    addStep(title) {
+        this.start();
+        this.stepCounter++;
+        const titleText = title;
+        this.output.write(`Step ${this.stepCounter}: ${titleText}... `);
+        const state = {
+            type: "step",
+            title,
+            phase: "running",
+        };
+        return new RunnableHandler(state, () => {
+            if (state.phase === "completed") {
+                this.output.write("completed\n");
+            }
+            else if (state.phase === "failed") {
+                this.output.write("FAILED\n");
+                if (state.error) {
+                    this.output.write(`  Error: ${state.error}\n`);
+                }
+            }
+            else if (state.phase === "aborted") {
+                this.output.write("aborted\n");
+            }
+            if (state.progress) {
+                this.output.write(`  Progress: ${state.progress}\n`);
+            }
+            if (state.output) {
+                const lines = state.output
+                    .split("\n")
+                    .filter((line) => line.trim());
+                this.output.write("got output:\n");
+                for (const line of lines) {
+                    this.output.write(`  ${line}\n`);
+                }
+            }
+        });
+    }
+    async runStep(title, fn) {
+        const step = this.addStep(title);
+        try {
+            const promise = typeof fn === "function" ? fn() : fn;
+            const result = await promise;
+            step.complete();
+            return result;
+        }
+        catch (err) {
+            step.error(err);
+            throw err;
+        }
+    }
+    addInfo(title) {
+        this.start();
+        const titleText = title;
+        this.output.write(`Info: ${titleText}\n`);
+    }
+    async addConfirmation(question) {
+        this.start();
+        const questionText = question;
+        this.output.write(`Confirm: ${questionText}; automatically confirmed\n`);
+        return true;
+    }
+    async addInput(question, mask) {
+        this.start();
+        const questionText = question;
+        const maskText = mask ? " (masked)" : "";
+        this.output.write(`Input: ${questionText}${maskText}; no input available\n`);
+        // For non-interactive use, throw an error
+        throw new Error("Interactive input not available in simple process renderer");
+    }
+    async addSelect(question, options) {
+        this.start();
+        const questionText = question;
+        this.output.write(`Selection: ${questionText}\n`);
+        this.output.write("Available options:\n");
+        options.forEach((option, index) => {
+            const labelText = option.label;
+            this.output.write(`  ${index + 1}. ${labelText}\n`);
+        });
+        throw new Error("Interactive selection not available in simple process renderer");
+    }
+    addCleanup(title, fn) {
+        this.cleanupFns.push(fn);
+    }
+    async complete(summary) {
+        await this.cleanup();
+        const summaryText = this.renderElementToText(summary);
+        this.output.write("Completed: Process completed successfully\n\n");
+        this.output.write(`Summary: ${summaryText}\n`);
+    }
+    async error(err) {
+        await this.cleanup();
+        this.output.write(`ERROR: Process failed: ${err?.toString()}\n`);
+    }
+    async cleanup() {
+        if (this.cleanupFns.length === 0) {
+            return;
+        }
+        this.output.write("Cleanup: Running cleanup tasks... ");
+        for (let i = 0; i < this.cleanupFns.length; i++) {
+            try {
+                await this.cleanupFns[i]();
+            }
+            catch (err) {
+                this.output.write(`task ${i + 1} failed: ${err}`);
+            }
+        }
+        this.output.write("completed\n");
+    }
+    renderElementToText(node) {
+        if (node === null || node === undefined) {
+            return "";
+        }
+        // Check if it's a React element with props.children
+        if (typeof node === "object" &&
+            "props" in node &&
+            node.props &&
+            typeof node.props === "object") {
+            const props = node.props;
+            if (props.children && typeof props.children === "string") {
+                return props.children;
+            }
+        }
+        return "[Complex content]";
+    }
+}

package/dist/rendering/process/process_simple.test.d.ts

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

package/dist/rendering/process/process_simple.test.js

@@ -0,0 +1,149 @@
+import { SimpleProcessRenderer } from "./process_simple.js";
+import { describe, expect, it, jest, beforeEach, } from "@jest/globals";
+import React from "react";
+import { Writable } from "stream";
+describe("SimpleProcessRenderer", () => {
+    let output;
+    let testStream;
+    beforeEach(() => {
+        output = "";
+        testStream = new Writable({
+            write(chunk, encoding, callback) {
+                output += chunk.toString();
+                if (callback)
+                    callback();
+                return true;
+            },
+        });
+    });
+    it("should start with a title", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.start();
+        expect(output).toContain("Starting: Test Process\n");
+    });
+    it("should display info messages", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addInfo("This is an info message");
+        expect(output).toContain("Info: This is an info message\n");
+    });
+    it("should handle string step titles", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const handler = renderer.addStep("Processing data");
+        expect(output).toContain("Step 1: Processing data... ");
+        handler.complete();
+        expect(output).toContain("completed\n");
+    });
+    it("should handle step failures", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const handler = renderer.addStep("Failing step");
+        handler.error("Something went wrong");
+        expect(output).toContain("FAILED\n");
+        expect(output).toContain("  Error: Something went wrong\n");
+    });
+    it("should handle step progress", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const handler = renderer.addStep("Long running task");
+        handler.progress("50% complete");
+        expect(output).toContain("  Progress: 50% complete\n");
+    });
+    it("should handle step output", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const handler = renderer.addStep("Task with output");
+        handler.appendOutput("Line 1\nLine 2\n");
+        expect(output).toContain("got output:\n");
+        expect(output).toContain("  Line 1\n");
+        expect(output).toContain("  Line 2\n");
+    });
+    it("should run steps successfully", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const result = await renderer.runStep("Test step", async () => {
+            return "success";
+        });
+        expect(result).toBe("success");
+        expect(output).toContain("Step 1: Test step... ");
+        expect(output).toContain("completed\n");
+    });
+    it("should handle runStep failures", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        await expect(renderer.runStep("Failing step", async () => {
+            throw new Error("Test error");
+        })).rejects.toThrow("Test error");
+        expect(output).toContain("FAILED\n");
+    });
+    it("should auto-confirm confirmations", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const result = await renderer.addConfirmation("Do you want to continue?");
+        expect(result).toBe(true);
+        expect(output).toContain("Confirm: Do you want to continue?; automatically confirmed\n");
+    });
+    it("should throw error for input requests", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        await expect(renderer.addInput("Enter your name")).rejects.toThrow("Interactive input not available in simple process renderer");
+    });
+    it("should throw error for select requests", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        await expect(renderer.addSelect("Choose option", [
+            { value: "a", label: "Option A" },
+            { value: "b", label: "Option B" },
+        ])).rejects.toThrow("Interactive selection not available in simple process renderer");
+    });
+    it("should handle string titles", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("React step");
+        expect(output).toContain("Step 1: React step... ");
+    });
+    it("should complete with summary", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const summary = React.createElement("div", null, "Process completed!");
+        await renderer.complete(summary);
+        expect(output).toContain("Completed: Process completed successfully\n\n");
+        expect(output).toContain("Summary: Process completed!\n");
+    });
+    it("should handle errors", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        await renderer.error("Something went wrong");
+        expect(output).toContain("ERROR: Process failed: Something went wrong\n");
+    });
+    it("should handle cleanup tasks", async () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        const cleanupFn = jest.fn(async () => { });
+        renderer.addCleanup("Cleanup task", cleanupFn);
+        await renderer.complete(React.createElement("div", null, "Done"));
+        expect(cleanupFn).toHaveBeenCalled();
+        expect(output).toContain("Cleanup: Running cleanup tasks... ");
+    });
+    it("should render string titles", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("Hello from Text component");
+        expect(output).toContain("Step 1: Hello from Text component... ");
+    });
+    it("should render nested string content", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("Nested content");
+        expect(output).toContain("Step 1: Nested content... ");
+    });
+    it("should handle string content", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("First Second Third");
+        expect(output).toContain("Step 1: First Second Third... ");
+    });
+    it("should handle complex string content", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("String content 42 and React element");
+        expect(output).toContain("Step 1: String content 42 and React element... ");
+    });
+    it("should handle empty string content gracefully", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("");
+        expect(output).toContain("Step 1: ... ");
+    });
+    it("should handle different string content", () => {
+        const renderer = new SimpleProcessRenderer("Test Process", testStream);
+        renderer.addStep("true");
+        renderer.addStep("false");
+        renderer.addStep("123");
+        expect(output).toContain("Step 1: true... ");
+        expect(output).toContain("Step 2: false... ");
+        expect(output).toContain("Step 3: 123... ");
+    });
+});

package/dist/rendering/react/components/AppInstallation/AppBackendAccessHints.d.ts

@@ -0,0 +1,15 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+interface AppBackendAccessHintsProps {
+    appInstallation: AppInstallation;
+    backendPathTemplate: string;
+    appName: string;
+    appHost?: string;
+}
+/**
+ * AppBackendAccessHints displays backend/admin access information when a
+ * backendPathTemplate is available in the app version.
+ */
+export declare const AppBackendAccessHints: FC<AppBackendAccessHintsProps>;
+export {};