@mittwald/cli 1.10.0 → 1.11.0

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

package/dist/rendering/react/components/AppInstallation/AppBackendAccessHints.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { Value } from "../Value.js";
+const infoColor = "blueBright";
+/**
+ * AppBackendAccessHints displays backend/admin access information when a
+ * backendPathTemplate is available in the app version.
+ */
+export const AppBackendAccessHints = ({ backendPathTemplate, appName, appHost, }) => {
+    return (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: infoColor, children: "\uD83D\uDD27 Backend Access:" }), _jsx(Text, { color: "gray", children: appHost
+                    ? `Your ${appName} backend is available at:`
+                    : `Once you connect a domain, your ${appName} backend will be available at:` }), _jsx(Text, { color: "gray", children: _jsx(Value, { children: backendPathTemplate.replace("{domain}", appHost ?? "<your-domain>") }) })] }));
+};

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

@@ -0,0 +1,12 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+interface AppDomainConnectionHintsProps {
+    appInstallation: AppInstallation;
+}
+/**
+ * AppDomainConnectionHints displays instructions for connecting a domain to an
+ * app installation via virtualhost creation.
+ */
+export declare const AppDomainConnectionHints: FC<AppDomainConnectionHintsProps>;
+export {};

package/dist/rendering/react/components/AppInstallation/AppDomainConnectionHints.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { Value } from "../Value.js";
+import { CommandHint } from "../Container/CommandHint.js";
+const infoColor = "blueBright";
+/**
+ * AppDomainConnectionHints displays instructions for connecting a domain to an
+ * app installation via virtualhost creation.
+ */
+export const AppDomainConnectionHints = ({ appInstallation, }) => {
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: infoColor, children: "\uD83C\uDF10 Connect via Domain:" }), _jsx(CommandHint, { command: [
+                    "mw",
+                    "domain",
+                    "virtualhost",
+                    "create",
+                    "--hostname",
+                    "<your-domain.com>",
+                    "--path-to-installation",
+                    `/:${appInstallation.id}`,
+                ], description: _jsxs(_Fragment, { children: ["Connect ", _jsx(Value, { children: "<your-domain.com>" }), " to your app installation, making it accessible via HTTPS. This is required for external access to your application."] }) })] }));
+};

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

@@ -0,0 +1,12 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+interface AppManagementCommandsProps {
+    appInstallation: AppInstallation;
+}
+/**
+ * AppManagementCommands displays management commands for app installations
+ * including SSH access, file operations, and maintenance tasks.
+ */
+export declare const AppManagementCommands: FC<AppManagementCommandsProps>;
+export {};

package/dist/rendering/react/components/AppInstallation/AppManagementCommands.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { CommandHint } from "../Container/CommandHint.js";
+const infoColor = "blueBright";
+/**
+ * AppManagementCommands displays management commands for app installations
+ * including SSH access, file operations, and maintenance tasks.
+ */
+export const AppManagementCommands = ({ appInstallation, }) => {
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: infoColor, children: "\uD83D\uDD27 Manage your application:" }), _jsx(CommandHint, { command: ["mw", "app", "ssh", appInstallation.shortId], description: "Open SSH session to your app installation" }), _jsx(CommandHint, { command: ["mw", "app", "download", appInstallation.shortId], description: "Download app files to your local machine" }), _jsx(CommandHint, { command: [
+                    "mw",
+                    "app",
+                    "upload",
+                    appInstallation.shortId,
+                    "<local-file>",
+                ], description: "Upload files from your local machine to the app" }), _jsx(CommandHint, { command: ["mw", "app", "get", appInstallation.shortId], description: "Show detailed information about your app installation" })] }));
+};

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

@@ -0,0 +1,17 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
+type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+interface AppUsageHintsProps {
+    appInstallation: AppInstallation;
+    appVersion: AppVersion;
+    appName: string;
+    appHost?: string;
+}
+/**
+ * AppUsageHints displays comprehensive usage instructions for app
+ * installations, including domain connection setup and backend access
+ * information.
+ */
+declare const AppUsageHints: FC<AppUsageHintsProps>;
+export default AppUsageHints;

package/dist/rendering/react/components/AppInstallation/AppUsageHints.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { Value } from "../Value.js";
+import useDefaultBoxStyles from "../../styles/useDefaultBoxStyles.js";
+import { AppDomainConnectionHints } from "./AppDomainConnectionHints.js";
+import { AppBackendAccessHints } from "./AppBackendAccessHints.js";
+import { AppManagementCommands } from "./AppManagementCommands.js";
+const infoColor = "blueBright";
+/**
+ * AppUsageHints displays comprehensive usage instructions for app
+ * installations, including domain connection setup and backend access
+ * information.
+ */
+const AppUsageHints = ({ appInstallation, appVersion, appName, appHost, }) => {
+    const defaultBoxStyles = useDefaultBoxStyles();
+    const boxProps = {
+        ...defaultBoxStyles,
+        borderColor: infoColor,
+        marginLeft: 2,
+    };
+    return (_jsxs(Box, { ...boxProps, flexDirection: "column", children: [_jsx(Text, { bold: true, underline: true, color: infoColor, children: "USAGE HINTS" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Connect to your application using these methods:" }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(AppDomainConnectionHints, { appInstallation: appInstallation }), appVersion.backendPathTemplate && (_jsx(AppBackendAccessHints, { appInstallation: appInstallation, backendPathTemplate: appVersion.backendPathTemplate, appName: appName, appHost: appHost })), _jsx(AppManagementCommands, { appInstallation: appInstallation }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: infoColor, children: ["\uD83D\uDCA1 Tip: Use ", _jsx(Value, { children: "mw app list" }), " to see all your app installations and their current status."] }) })] })] }));
+};
+export default AppUsageHints;

package/dist/rendering/react/components/Container/CommandHint.d.ts

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from "react";
+export interface CommandHintProps {
+    command: string[];
+    description: ReactNode;
+}
+/**
+ * CommandHint is a functional React component that renders a command hint
+ * display. It presents a styled command and its corresponding description.
+ *
+ * @param command An array of strings representing the command to be displayed.
+ * @param description A textual description of the command.
+ * @returns A JSX element displaying the command and description.
+ */
+export declare const CommandHint: FC<CommandHintProps>;

package/dist/rendering/react/components/Container/CommandHint.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/**
+ * CommandHint is a functional React component that renders a command hint
+ * display. It presents a styled command and its corresponding description.
+ *
+ * @param command An array of strings representing the command to be displayed.
+ * @param description A textual description of the command.
+ * @returns A JSX element displaying the command and description.
+ */
+export const CommandHint = ({ command, description }) => {
+    return (_jsxs(_Fragment, { children: [_jsx(Box, { children: _jsx(Text, { color: "yellow", children: command.join(" ") }) }), _jsx(Box, { marginLeft: 2, marginBottom: 1, children: _jsx(Text, { wrap: "wrap", children: description }) })] }));
+};

package/dist/rendering/react/components/Container/ContainerManagementCommands.d.ts

@@ -0,0 +1,22 @@
+import { FC } from "react";
+interface ContainerManagementCommandsProps {
+    containerIdentifier: string;
+}
+/**
+ * ContainerManagementCommands is a React functional component that provides
+ * commands and instructions for interacting with a specific container.
+ *
+ * This component displays a set of command hints, allowing users to:
+ *
+ * - Connect to a container via SSH.
+ * - View logs generated by the container.
+ * - Execute specific commands within the container.
+ *
+ * The displayed commands are dynamically generated based on the
+ * `containerIdentifier` prop, which identifies the container to manage.
+ *
+ * @property string ContainerIdentifier - The unique identifier of the container
+ *   to manage. This is included in the commands displayed by the component.
+ */
+export declare const ContainerManagementCommands: FC<ContainerManagementCommandsProps>;
+export {};

package/dist/rendering/react/components/Container/ContainerManagementCommands.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { CommandHint } from "./CommandHint.js";
+const infoColor = "blueBright";
+/**
+ * ContainerManagementCommands is a React functional component that provides
+ * commands and instructions for interacting with a specific container.
+ *
+ * This component displays a set of command hints, allowing users to:
+ *
+ * - Connect to a container via SSH.
+ * - View logs generated by the container.
+ * - Execute specific commands within the container.
+ *
+ * The displayed commands are dynamically generated based on the
+ * `containerIdentifier` prop, which identifies the container to manage.
+ *
+ * @property string ContainerIdentifier - The unique identifier of the container
+ *   to manage. This is included in the commands displayed by the component.
+ */
+export const ContainerManagementCommands = ({ containerIdentifier }) => {
+    return (_jsxs(_Fragment, { children: [_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: infoColor, children: "\uD83D\uDD27 Manage Your Container:" }) }), _jsx(CommandHint, { command: ["mw", "container", "ssh", containerIdentifier], description: "Connect to the container via SSH to run commands interactively" }), _jsx(CommandHint, { command: ["mw", "container", "logs", containerIdentifier], description: "View the container's log output and monitor its activity" }), _jsx(CommandHint, { command: ["mw", "container", "exec", containerIdentifier, "<command>"], description: "Execute a specific command inside the running container" })] }));
+};

package/dist/rendering/react/components/Container/ContainerUsageHints.d.ts

@@ -0,0 +1,12 @@
+import { FC } from "react";
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+type ContainerServiceResponse = MittwaldAPIV2.Components.Schemas.ContainerServiceResponse;
+interface ContainerUsageHintsProps {
+    service: ContainerServiceResponse;
+}
+/**
+ * ContainerUsageHints displays comprehensive usage instructions for containers,
+ * adapting the content based on whether the container exposes ports or not.
+ */
+declare const ContainerUsageHints: FC<ContainerUsageHintsProps>;
+export default ContainerUsageHints;