@mittwald/cli 1.9.1 → 1.11.0

package/dist/lib/resources/app/Installer.js

@@ -6,6 +6,7 @@ import { normalizeToAppVersionUuid } from "./versions.js";
 import { triggerAppInstallation } from "./install.js";
 import { waitUntilAppStateHasNormalized } from "./wait.js";
 import { Success } from "../../../rendering/react/components/Success.js";
+import AppUsageHints from "../../../rendering/react/components/AppInstallation/AppUsageHints.js";
 export class AppInstaller {
     appId;
     appName;
@@ -35,22 +36,28 @@ export class AppInstaller {
         const projectId = await withProjectId(apiClient, "flag", flags, args, config);
         await autofillFlags(apiClient, process, this.appSupportedFlags, flags, projectId, this.appName, this.defaultFlagValues);
         const appVersion = await normalizeToAppVersionUuid(apiClient, "version" in flags ? flags.version : "latest", process, this.appId);
-        const appInstallationId = await triggerAppInstallation(apiClient, process, projectId, flags, appVersion);
+        const appInstallation = await triggerAppInstallation(apiClient, process, projectId, flags, appVersion);
         let successText;
         if (flags.wait) {
-            await waitUntilAppStateHasNormalized(apiClient, process, appInstallationId, "waiting for app installation to be ready", flags["wait-timeout"]);
+            await waitUntilAppStateHasNormalized(apiClient, process, appInstallation.id, "waiting for app installation to be ready", flags["wait-timeout"]);
             successText = `Your ${this.appName} installation is now complete. Have fun! 🎉`;
         }
         else {
             successText = `Your ${this.appName} installation has started. Have fun when it's ready! 🎉`;
         }
-        process.complete(_jsx(Success, { children: successText }));
-        return { appInstallationId };
+        await process.complete(_jsx(Success, { children: successText }));
+        return {
+            appInstallation,
+            appVersion,
+            host: "host" in flags && typeof flags.host === "string"
+                ? flags.host
+                : undefined,
+        };
     }
     render(result, flags) {
         if (flags.quiet) {
-            return result.appInstallationId;
+            return result.appInstallation.id;
         }
-        return undefined;
+        return (_jsx(AppUsageHints, { appInstallation: result.appInstallation, appVersion: result.appVersion, appName: this.appName, appHost: result.host }));
     }
 }

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

@@ -1,8 +1,5 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { getDefaultIngressForProject } from "../project/ingress.js";
-import { Value } from "../../../rendering/react/components/Value.js";
 import { getProjectShortIdFromUuid } from "../project/shortId.js";
-import { Text } from "ink";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { projectFlags } from "../project/flags.js";
 import { processFlags, } from "../../../rendering/process/process_flags.js";
@@ -169,7 +166,7 @@ export async function autofillFlags(apiClient, process, necessaryFlags, flags, p
     if (necessaryFlags.includes("host") && !flags.host) {
         flags.host =
             "https://" + (await getDefaultIngressForProject(apiClient, projectId));
-        process.addInfo(_jsxs(Text, { children: ["Using default Host ", _jsx(Value, { children: flags["host"] })] }));
+        process.addInfo(`Using default Host ${flags["host"]}`);
     }
     // Title
     if (necessaryFlags.includes("site-title") && !flags["site-title"]) {
@@ -186,12 +183,12 @@ export async function autofillFlags(apiClient, process, necessaryFlags, flags, p
         else {
             flags["admin-user"] = await getProjectShortIdFromUuid(apiClient, projectId);
         }
-        process.addInfo(_jsxs(Text, { children: ["Using generated Admin User: ", _jsx(Value, { children: flags["admin-user"] })] }));
+        process.addInfo(`Using generated Admin User: ${flags["admin-user"]}`);
     }
     // Admin Pass
     if (necessaryFlags.includes("admin-pass") && !flags["admin-pass"]) {
         flags["admin-pass"] = generatePasswordWithSpecialChars();
-        process.addInfo(_jsxs(Text, { children: ["Using generated random Admin Pass: ", _jsx(Value, { children: flags["admin-pass"] })] }));
+        process.addInfo(`Using generated random Admin Pass: ${flags["admin-pass"]}`);
     }
     // Admin Firstname
     if (necessaryFlags.includes("admin-firstname") && !flags["admin-firstname"]) {
@@ -201,7 +198,7 @@ export async function autofillFlags(apiClient, process, necessaryFlags, flags, p
         else {
             flags["admin-firstname"] = "Max";
         }
-        process.addInfo(_jsxs(Text, { children: ["Using mStudio firstname as Admin firstname (", _jsx(Value, { children: flags["admin-firstname"] }), ")"] }));
+        process.addInfo(`Using mStudio firstname as Admin firstname (${flags["admin-firstname"]})`);
     }
     // Admin Lastname
     if (necessaryFlags.includes("admin-lastname") && !flags["admin-lastname"]) {
@@ -211,26 +208,26 @@ export async function autofillFlags(apiClient, process, necessaryFlags, flags, p
         else {
             flags["admin-lastname"] = "Mustermann";
         }
-        process.addInfo(_jsxs(Text, { children: ["Using mStudio lastname as Admin lastname (", _jsx(Value, { children: flags["admin-lastname"] }), ")"] }));
+        process.addInfo(`Using mStudio lastname as Admin lastname (${flags["admin-lastname"]})`);
     }
     // Admin E-Mail
     if (necessaryFlags.includes("admin-email") && !flags["admin-email"]) {
         flags["admin-email"] = ownUser.data.email;
-        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Admin email (", _jsx(Value, { children: flags["admin-email"] }), ")"] }));
+        process.addInfo(`Using mStudio email as Admin email (${flags["admin-email"]})`);
     }
     // Shop E-Mail
     if (necessaryFlags.includes("shop-email") && !flags["shop-email"]) {
         flags["shop-email"] = ownUser.data.email;
-        process.addInfo(_jsxs(Text, { children: ["Using mStudio email as Shop email (", _jsx(Value, { children: flags["shop-email"] }), ")"] }));
+        process.addInfo(`Using mStudio email as Shop email (${flags["shop-email"]})`);
     }
     // Shop Language Code
     if (necessaryFlags.includes("shop-lang") && !flags["shop-lang"]) {
         flags["shop-lang"] = defaults["shop-lang"] ?? "de-DE";
-        process.addInfo(_jsxs(Text, { children: ["Using default shop language '", flags["shop-lang"], "'."] }));
+        process.addInfo(`Using default shop language '${flags["shop-lang"]}'.`);
     }
     // Shop Currency
     if (necessaryFlags.includes("shop-currency") && !flags["shop-currency"]) {
         flags["shop-currency"] = "EUR";
-        process.addInfo(_jsx(Text, { children: "Using default shop currency '\u20AC'." }));
+        process.addInfo("Using default shop currency '€'.");
     }
 }

package/dist/lib/resources/app/install.d.ts

@@ -1,10 +1,11 @@
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
+type AppAppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
 type AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
 export declare function triggerAppInstallation(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, projectId: string, flags: {
     "site-title": string;
     "document-root"?: string;
 } & {
     [k: string]: unknown;
-}, appVersion: AppAppVersion): Promise<string>;
+}, appVersion: AppAppVersion): Promise<AppAppInstallation>;
 export {};

package/dist/lib/resources/app/install.js

@@ -38,5 +38,7 @@ export async function triggerAppInstallation(apiClient, process, projectId, flag
             assertStatus(result, 204);
         });
     }
-    return appInstallationId;
+    const result = await apiClient.app.getAppinstallation({ appInstallationId });
+    assertStatus(result, 200);
+    return result.data;
 }

package/dist/lib/resources/app/versions.js

@@ -1,8 +1,5 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { gt } from "semver";
-import { Value } from "../../../rendering/react/components/Value.js";
-import { Text } from "ink";
 import { getAppInstallationFromUuid, getAppNameFromUuid } from "./uuid.js";
 import { compare } from "semver";
 export async function normalizeToAppVersionUuid(apiClient, version, process, appUuid) {
@@ -16,7 +13,7 @@ export async function normalizeToAppVersionUuid(apiClient, version, process, app
     if (!appVersion) {
         throw new Error(`${await getAppNameFromUuid(apiClient, appUuid)} version ${version} does not seem to exist for the mStudio.`);
     }
-    process.addInfo(_jsxs(Text, { children: ["installing version: ", _jsx(Value, { children: appVersion.externalVersion })] }));
+    process.addInfo(`installing version: ${appVersion.externalVersion}`);
     return appVersion;
 }
 // Get latest available Internal App Version for App UUID

package/dist/lib/resources/app/wait.js

@@ -1,8 +1,6 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 import { waitUntil } from "../../wait.js";
-import { Text } from "ink";
 export async function waitUntilAppStateHasNormalized(apiClient, process, appInstallationId, label, timeout) {
-    const stepWaiting = process.addStep(_jsx(Text, { children: label }));
+    const stepWaiting = process.addStep(label);
     await waitUntil(async () => {
         const installationResponse = await apiClient.app.getAppinstallation({
             appInstallationId,

package/dist/lib/resources/mail/commons.js

@@ -1,9 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { generatePassword } from "../../util/password/generatePassword.js";
-import { Value } from "../../../rendering/react/components/Value.js";
-import { Text } from "ink";
 export async function generateRandomPassword(process) {
     const generated = await process.runStep("generating random password", async () => generatePassword(32));
-    process.addInfo(_jsxs(Text, { children: [" ", "generated password: ", _jsx(Value, { children: generated }), " "] }));
+    process.addInfo(` generated password: ${generated} `);
     return generated;
 }

package/dist/lib/resources/ssh/appinstall.d.ts

@@ -1,3 +1,5 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 import { SSHConnectionData } from "./types.js";
-export declare function getSSHConnectionForAppInstallation(client: MittwaldAPIV2Client, appInstallationId: string, sshUser: string | undefined): Promise<SSHConnectionData>;
+export declare function getSSHConnectionForAppInstallation(client: MittwaldAPIV2Client, appInstallationId: string, sshUser: string | undefined): Promise<SSHConnectionData & {
+    appShortId: string;
+}>;

package/dist/lib/resources/ssh/appinstall.js

@@ -24,5 +24,6 @@ export async function getSSHConnectionForAppInstallation(client, appInstallation
         host,
         user,
         directory,
+        appShortId: appInstallationResponse.data.shortId,
     };
 }

package/dist/lib/resources/ssh/environment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prepare environment variables for SSH command execution
+ *
+ * @param envVars Array of environment variables in KEY=VALUE format
+ * @returns Formatted string with export commands
+ */
+export declare function prepareEnvironmentVariables(envVars: string[]): string;

package/dist/lib/resources/ssh/environment.js

@@ -0,0 +1,21 @@
+import shellEscape from "shell-escape";
+/**
+ * Prepare environment variables for SSH command execution
+ *
+ * @param envVars Array of environment variables in KEY=VALUE format
+ * @returns Formatted string with export commands
+ */
+export function prepareEnvironmentVariables(envVars) {
+    return (envVars
+        .map((env) => {
+        const eqIdx = env.indexOf("=");
+        if (eqIdx === -1) {
+            // If no '=', treat the whole string as key with empty value
+            return `export ${shellEscape([env])}=`;
+        }
+        const key = env.slice(0, eqIdx);
+        const value = env.slice(eqIdx + 1);
+        return `export ${shellEscape([key])}=${shellEscape([value])}`;
+    })
+        .join("; ") + "; ");
+}

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