@mittwald/cli 1.10.0 → 1.11.0

package/dist/lib/intellij/config.test.js

@@ -0,0 +1,262 @@
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { XMLParser } from "fast-xml-parser";
+import { generateIntellijConfigs } from "./config.js";
+describe("IntelliJ Config Generator", () => {
+    let tempDir;
+    let testData;
+    const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "intellij-test-"));
+        testData = {
+            host: "ssh.test.example.com",
+            user: "testuser@app123",
+            directory: "/var/www/html/app123",
+            appShortId: "app123",
+        };
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    describe("generateIntellijConfigs", () => {
+        test("should create .idea directory if it doesn't exist", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const ideaDir = path.join(tempDir, ".idea");
+            expect(fs.existsSync(ideaDir)).toBe(true);
+            expect(fs.statSync(ideaDir).isDirectory()).toBe(true);
+        });
+        test("should generate all three configuration files", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const ideaDir = path.join(tempDir, ".idea");
+            expect(fs.existsSync(path.join(ideaDir, "sshConfigs.xml"))).toBe(true);
+            expect(fs.existsSync(path.join(ideaDir, "webServers.xml"))).toBe(true);
+            expect(fs.existsSync(path.join(ideaDir, "deployment.xml"))).toBe(true);
+        });
+        test("should generate valid XML files", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const ideaDir = path.join(tempDir, ".idea");
+            // Test that each file can be parsed without errors
+            const sshContent = fs.readFileSync(path.join(ideaDir, "sshConfigs.xml"), "utf8");
+            expect(() => parser.parse(sshContent)).not.toThrow();
+            const webContent = fs.readFileSync(path.join(ideaDir, "webServers.xml"), "utf8");
+            expect(() => parser.parse(webContent)).not.toThrow();
+            const deployContent = fs.readFileSync(path.join(ideaDir, "deployment.xml"), "utf8");
+            expect(() => parser.parse(deployContent)).not.toThrow();
+        });
+    });
+    describe("SSH Configs XML", () => {
+        test("should create SSH config with correct attributes", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            expect(xmlDoc.project["@_version"]).toBe("4");
+            expect(xmlDoc.project.component["@_name"]).toBe("SshConfigs");
+            const sshConfig = xmlDoc.project.component.configs.sshConfig;
+            expect(sshConfig["@_authType"]).toBe("OPEN_SSH");
+            expect(sshConfig["@_host"]).toBe("ssh.test.example.com");
+            expect(sshConfig["@_port"]).toBe("22");
+            expect(sshConfig["@_username"]).toBe("testuser@app123");
+            expect(sshConfig["@_useOpenSSHConfig"]).toBe("true");
+            expect(sshConfig["@_nameFormat"]).toBe("DESCRIPTIVE");
+            expect(sshConfig["@_id"]).toBeDefined();
+        });
+        test("should not add duplicate SSH configs for same host", () => {
+            generateIntellijConfigs(testData, tempDir);
+            generateIntellijConfigs(testData, tempDir); // Run twice
+            const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const sshConfig = xmlDoc.project.component.configs.sshConfig;
+            expect(Array.isArray(sshConfig)).toBe(false); // Should still be single config
+        });
+        test("should add multiple SSH configs for different hosts", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const differentHostData = { ...testData, host: "ssh.other.example.com", appShortId: "app456" };
+            generateIntellijConfigs(differentHostData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const sshConfigs = xmlDoc.project.component.configs.sshConfig;
+            expect(Array.isArray(sshConfigs)).toBe(true);
+            expect(sshConfigs).toHaveLength(2);
+            expect(sshConfigs[0]["@_host"]).toBe("ssh.test.example.com");
+            expect(sshConfigs[1]["@_host"]).toBe("ssh.other.example.com");
+        });
+        test("should handle existing SSH config file correctly", () => {
+            const ideaDir = path.join(tempDir, ".idea");
+            fs.mkdirSync(ideaDir, { recursive: true });
+            const existingConfig = `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="SshConfigs">
+    <configs>
+      <sshConfig authType="OPEN_SSH" host="existing.example.com" id="existing-id" port="22" nameFormat="DESCRIPTIVE" username="existing" useOpenSSHConfig="true" />
+    </configs>
+  </component>
+</project>`;
+            fs.writeFileSync(path.join(ideaDir, "sshConfigs.xml"), existingConfig);
+            generateIntellijConfigs(testData, tempDir);
+            const configPath = path.join(ideaDir, "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const sshConfigs = xmlDoc.project.component.configs.sshConfig;
+            expect(Array.isArray(sshConfigs)).toBe(true);
+            expect(sshConfigs).toHaveLength(2);
+        });
+        test("should reuse existing SSH config ID in web server configuration", () => {
+            const ideaDir = path.join(tempDir, ".idea");
+            fs.mkdirSync(ideaDir, { recursive: true });
+            // Create existing SSH config with the same host as testData
+            const existingConfig = `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="SshConfigs">
+    <configs>
+      <sshConfig authType="OPEN_SSH" host="ssh.test.example.com" id="existing-ssh-id" port="22" nameFormat="DESCRIPTIVE" username="testuser@app123" useOpenSSHConfig="true" />
+    </configs>
+  </component>
+</project>`;
+            fs.writeFileSync(path.join(ideaDir, "sshConfigs.xml"), existingConfig);
+            generateIntellijConfigs(testData, tempDir);
+            // Verify SSH config wasn't duplicated
+            const sshConfigPath = path.join(ideaDir, "sshConfigs.xml");
+            const sshContent = fs.readFileSync(sshConfigPath, "utf8");
+            const sshXmlDoc = parser.parse(sshContent);
+            const sshConfig = sshXmlDoc.project.component.configs.sshConfig;
+            expect(Array.isArray(sshConfig)).toBe(false); // Should still be single config
+            expect(sshConfig["@_id"]).toBe("existing-ssh-id");
+            // Verify web server config uses the existing SSH config ID
+            const webConfigPath = path.join(ideaDir, "webServers.xml");
+            const webContent = fs.readFileSync(webConfigPath, "utf8");
+            const webXmlDoc = parser.parse(webContent);
+            const webServer = webXmlDoc.project.component.option.webServer;
+            expect(webServer.fileTransfer["@_sshConfigId"]).toBe("existing-ssh-id");
+        });
+    });
+    describe("Web Servers XML", () => {
+        test("should create web server config with correct structure", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "webServers.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            expect(xmlDoc.project["@_version"]).toBe("4");
+            expect(xmlDoc.project.component["@_name"]).toBe("WebServers");
+            expect(xmlDoc.project.component.option["@_name"]).toBe("servers");
+            const webServer = xmlDoc.project.component.option.webServer;
+            expect(webServer["@_name"]).toBe("app123");
+            expect(webServer["@_id"]).toBeDefined();
+            const fileTransfer = webServer.fileTransfer;
+            expect(fileTransfer["@_accessType"]).toBe("SFTP");
+            expect(fileTransfer["@_host"]).toBe("ssh.test.example.com");
+            expect(fileTransfer["@_port"]).toBe("22");
+            expect(fileTransfer["@_authAgent"]).toBe("true");
+            expect(fileTransfer["@_sshConfig"]).toBe("testuser@app123@ssh.test.example.com:22 agent");
+            const advancedOptions = fileTransfer.advancedOptions.advancedOptions;
+            expect(advancedOptions["@_dataProtectionLevel"]).toBe("Private");
+            expect(advancedOptions["@_keepAliveTimeout"]).toBe("0");
+            expect(advancedOptions["@_passiveMode"]).toBe("true");
+            expect(advancedOptions["@_shareSSLContext"]).toBe("true");
+        });
+        test("should not add duplicate web servers for same app", () => {
+            generateIntellijConfigs(testData, tempDir);
+            generateIntellijConfigs(testData, tempDir); // Run twice
+            const configPath = path.join(tempDir, ".idea", "webServers.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const webServer = xmlDoc.project.component.option.webServer;
+            expect(Array.isArray(webServer)).toBe(false); // Should still be single server
+        });
+    });
+    describe("Deployment XML", () => {
+        test("should create deployment config with correct mapping", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "deployment.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            expect(xmlDoc.project["@_version"]).toBe("4");
+            expect(xmlDoc.project.component["@_name"]).toBe("PublishConfigData");
+            expect(xmlDoc.project.component["@_serverName"]).toBe("app123");
+            expect(xmlDoc.project.component["@_remoteFilesAllowedToDisappearOnAutoupload"]).toBe("false");
+            const paths = xmlDoc.project.component.serverData.paths;
+            expect(paths["@_name"]).toBe("app123");
+            const mapping = paths.serverdata.mappings.mapping;
+            expect(mapping["@_deploy"]).toBe("/var/www/html/app123");
+            expect(mapping["@_local"]).toBe("$PROJECT_DIR$");
+            expect(mapping["@_web"]).toBe("/");
+        });
+        test("should not add duplicate deployment configs for same app", () => {
+            generateIntellijConfigs(testData, tempDir);
+            generateIntellijConfigs(testData, tempDir); // Run twice
+            const configPath = path.join(tempDir, ".idea", "deployment.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const paths = xmlDoc.project.component.serverData.paths;
+            expect(Array.isArray(paths)).toBe(false); // Should still be single path
+        });
+    });
+    describe("SSH username handling", () => {
+        test("should use complete user string as SSH username", () => {
+            const userData = { ...testData, user: "m.helmich@mittwald.de@a-ce3rzc" };
+            generateIntellijConfigs(userData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const sshConfig = xmlDoc.project.component.configs.sshConfig;
+            expect(sshConfig["@_username"]).toBe("m.helmich@mittwald.de@a-ce3rzc");
+            // Also check web server config uses the same username
+            const webConfigPath = path.join(tempDir, ".idea", "webServers.xml");
+            const webContent = fs.readFileSync(webConfigPath, "utf8");
+            const webXmlDoc = parser.parse(webContent);
+            const webServer = webXmlDoc.project.component.option.webServer;
+            expect(webServer.fileTransfer["@_sshConfig"]).toBe("m.helmich@mittwald.de@a-ce3rzc@ssh.test.example.com:22 agent");
+        });
+        test("should handle simple usernames as-is", () => {
+            const userData = { ...testData, user: "plainuser" };
+            generateIntellijConfigs(userData, tempDir);
+            const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
+            const content = fs.readFileSync(configPath, "utf8");
+            const xmlDoc = parser.parse(content);
+            const sshConfig = xmlDoc.project.component.configs.sshConfig;
+            expect(sshConfig["@_username"]).toBe("plainuser");
+        });
+    });
+    describe("Error handling", () => {
+        test("should handle invalid directory gracefully", () => {
+            const invalidDir = "/root/nonexistent/readonly";
+            // This should throw an error for invalid directory
+            expect(() => {
+                generateIntellijConfigs(testData, invalidDir);
+            }).toThrow("Cannot create .idea directory");
+        });
+        test("should throw error for malformed existing XML files", () => {
+            const ideaDir = path.join(tempDir, ".idea");
+            fs.mkdirSync(ideaDir, { recursive: true });
+            // Create malformed XML
+            const malformedXml = "<?xml version='1.0'?><project><unclosed>";
+            fs.writeFileSync(path.join(ideaDir, "sshConfigs.xml"), malformedXml);
+            // Should throw an error for malformed XML
+            expect(() => {
+                generateIntellijConfigs(testData, tempDir);
+            }).toThrow();
+        });
+    });
+    describe("XML structure validation", () => {
+        test("should generate properly formatted XML with correct declarations", () => {
+            generateIntellijConfigs(testData, tempDir);
+            const ideaDir = path.join(tempDir, ".idea");
+            // Check SSH config
+            const sshContent = fs.readFileSync(path.join(ideaDir, "sshConfigs.xml"), "utf8");
+            expect(sshContent).toMatch(/^<\?xml version="1\.0" encoding="UTF-8"\?>/);
+            expect(sshContent).toContain('<project version="4">');
+            // Check web servers
+            const webContent = fs.readFileSync(path.join(ideaDir, "webServers.xml"), "utf8");
+            expect(webContent).toMatch(/^<\?xml version="1\.0" encoding="UTF-8"\?>/);
+            expect(webContent).toContain('<project version="4">');
+            // Check deployment
+            const deployContent = fs.readFileSync(path.join(ideaDir, "deployment.xml"), "utf8");
+            expect(deployContent).toMatch(/^<\?xml version="1\.0" encoding="UTF-8"\?>/);
+            expect(deployContent).toContain('<project version="4">');
+        });
+    });
+});

package/dist/lib/intellij/config_xml_types.d.ts

@@ -0,0 +1,72 @@
+export interface XmlDocument {
+    "?xml": {
+        "@_version": string;
+        "@_encoding": string;
+    };
+    project: XmlProject;
+}
+export interface XmlProject {
+    "@_version": string;
+    component: XmlComponent;
+}
+export interface XmlComponent {
+    "@_name": string;
+    configs?: XmlConfigs;
+    option?: XmlOption;
+    serverData?: XmlServerData;
+    "@_serverName"?: string;
+    "@_remoteFilesAllowedToDisappearOnAutoupload"?: string;
+}
+export interface XmlConfigs {
+    sshConfig?: XmlSshConfig | XmlSshConfig[];
+}
+export interface XmlSshConfig {
+    "@_authType": string;
+    "@_host": string;
+    "@_id": string;
+    "@_port": string;
+    "@_nameFormat": string;
+    "@_username": string;
+    "@_useOpenSSHConfig": string;
+}
+export interface XmlOption {
+    "@_name": string;
+    webServer?: XmlWebServer | XmlWebServer[];
+}
+export interface XmlWebServer {
+    "@_id": string;
+    "@_name": string;
+    fileTransfer: XmlFileTransfer;
+}
+export interface XmlFileTransfer {
+    "@_accessType": string;
+    "@_host": string;
+    "@_port": string;
+    "@_sshConfigId": string;
+    "@_sshConfig": string;
+    "@_authAgent": string;
+    advancedOptions: XmlAdvancedOptions;
+}
+export interface XmlAdvancedOptions {
+    advancedOptions: {
+        "@_dataProtectionLevel": string;
+        "@_keepAliveTimeout": string;
+        "@_passiveMode": string;
+        "@_shareSSLContext": string;
+    };
+}
+export interface XmlServerData {
+    paths?: XmlPath | XmlPath[];
+}
+export interface XmlPath {
+    "@_name": string;
+    serverdata: {
+        mappings: {
+            mapping: {
+                "@_deploy": string;
+                "@_local": string;
+                "@_web": string;
+            };
+        };
+    };
+}

package/dist/lib/intellij/config_xml_types.js

@@ -0,0 +1,2 @@
+// XML Document Structure Types for IntelliJ IDEA configuration files
+export {};

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

@@ -1,11 +1,15 @@
 import { OutputFlags } from "@oclif/core/interfaces";
 import { AvailableFlagName, RelevantFlagInput } from "./flags.js";
 import React from "react";
-import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { Config } from "@oclif/core";
+type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
 type ImplicitDefaultFlag = "wait" | "wait-timeout" | "site-title";
 export interface AppInstallationResult {
-    appInstallationId: string;
+    appInstallation: AppInstallation;
+    appVersion: AppVersion;
+    host?: string;
 }
 export declare class AppInstaller<TFlagName extends AvailableFlagName> {
     readonly appId: string;

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/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>;