@mittwald/cli 1.9.1 → 1.11.0

package/dist/lib/intellij/config.js

@@ -0,0 +1,295 @@
+import * as fs from "fs";
+import * as path from "path";
+import { randomUUID } from "crypto";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+// Common XML configuration
+const XML_PARSER_CONFIG = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    parseAttributeValue: false,
+};
+const XML_BUILDER_CONFIG = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    suppressBooleanAttributes: false,
+};
+// Common XML document structure
+const createXmlDocumentBase = () => ({
+    "?xml": { "@_version": "1.0", "@_encoding": "UTF-8" },
+    project: { "@_version": "4" },
+});
+export function generateIntellijConfigs(data, projectDir = ".") {
+    const ideaDir = path.join(projectDir, ".idea");
+    try {
+        if (!fs.existsSync(ideaDir)) {
+            fs.mkdirSync(ideaDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Cannot create .idea directory: ${error instanceof Error ? error.message : error}`);
+    }
+    const webServerId = randomUUID();
+    // First, ensure SSH config exists and get its ID (existing or newly created)
+    const sshConfigId = ensureSshConfigExists(data, ideaDir);
+    // Then create web server and deployment configs using the correct SSH config ID
+    generateWebServersXml(data, webServerId, sshConfigId, ideaDir);
+    generateDeploymentXml(data, ideaDir);
+}
+// Common XML manipulation utility
+function manipulateXmlFile(ideaDir, config, newItem) {
+    const configPath = path.join(ideaDir, config.filename);
+    const parser = new XMLParser(XML_PARSER_CONFIG);
+    const builder = new XMLBuilder(XML_BUILDER_CONFIG);
+    let xmlDoc = loadExistingXmlDocument(configPath, parser);
+    if (xmlDoc) {
+        const wasAdded = tryAddToExistingDocument(xmlDoc, newItem, config);
+        if (!wasAdded) {
+            return; // Item already exists
+        }
+    }
+    else {
+        xmlDoc = config.createNewDocumentFn(newItem);
+    }
+    const xmlContent = builder.build(xmlDoc);
+    fs.writeFileSync(configPath, xmlContent);
+}
+function loadExistingXmlDocument(configPath, parser) {
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(configPath, "utf8");
+    const xmlDoc = parser.parse(content);
+    if (!xmlDoc.project?.component) {
+        throw new Error("Invalid XML structure");
+    }
+    return xmlDoc;
+}
+function tryAddToExistingDocument(xmlDoc, newItem, config) {
+    // This function delegates to the specific addItemFn
+    // Return false if item already exists, true if added
+    return config.addItemFn(xmlDoc, newItem);
+}
+// Helper function to handle array/single element patterns
+function ensureArray(item) {
+    return Array.isArray(item) ? item : [item];
+}
+// Specific type-safe helper functions for each XML structure
+function addSshConfig(configs, newConfig) {
+    if (Array.isArray(configs.sshConfig)) {
+        configs.sshConfig.push(newConfig);
+    }
+    else if (configs.sshConfig) {
+        configs.sshConfig = [configs.sshConfig, newConfig];
+    }
+    else {
+        configs.sshConfig = newConfig;
+    }
+}
+function addWebServer(option, newServer) {
+    if (Array.isArray(option.webServer)) {
+        option.webServer.push(newServer);
+    }
+    else if (option.webServer) {
+        option.webServer = [option.webServer, newServer];
+    }
+    else {
+        option.webServer = newServer;
+    }
+}
+function addDeploymentPath(serverData, newPath) {
+    if (Array.isArray(serverData.paths)) {
+        serverData.paths.push(newPath);
+    }
+    else if (serverData.paths) {
+        serverData.paths = [serverData.paths, newPath];
+    }
+    else {
+        serverData.paths = newPath;
+    }
+}
+// Function to ensure SSH config exists and return its ID
+function ensureSshConfigExists(data, ideaDir) {
+    const configPath = path.join(ideaDir, "sshConfigs.xml");
+    const parser = new XMLParser(XML_PARSER_CONFIG);
+    const existingXmlDoc = loadExistingXmlDocument(configPath, parser);
+    if (existingXmlDoc) {
+        // Check if SSH config for this host already exists
+        const configs = existingXmlDoc.project.component.configs;
+        if (configs?.sshConfig) {
+            const existingConfigs = ensureArray(configs.sshConfig);
+            const existingConfig = existingConfigs.find((config) => config["@_host"] === data.host);
+            if (existingConfig) {
+                // Return existing SSH config ID
+                return existingConfig["@_id"];
+            }
+        }
+    }
+    // SSH config doesn't exist, create it with a new ID
+    const newSshConfigId = randomUUID();
+    generateSshConfigsXml(data, newSshConfigId, ideaDir);
+    return newSshConfigId;
+}
+// SSH Config specific functions
+function createSshConfigItem(host, username, configId) {
+    return {
+        "@_authType": "OPEN_SSH",
+        "@_host": host,
+        "@_id": configId,
+        "@_port": "22",
+        "@_nameFormat": "DESCRIPTIVE",
+        "@_username": username,
+        "@_useOpenSSHConfig": "true",
+    };
+}
+function generateSshConfigsXml(data, configId, ideaDir) {
+    const sshConfigItem = createSshConfigItem(data.host, data.user, configId);
+    const config = {
+        filename: "sshConfigs.xml",
+        componentName: "SshConfigs",
+        checkDuplicateFn: (existing, newItem) => existing.some((config) => config["@_host"] === newItem["@_host"]),
+        addItemFn: (xmlDoc, newItem) => {
+            const configs = xmlDoc.project.component.configs;
+            if (configs?.sshConfig) {
+                const existingConfigs = ensureArray(configs.sshConfig);
+                if (existingConfigs.some((config) => config["@_host"] === newItem["@_host"])) {
+                    return false; // Already exists
+                }
+                addSshConfig(configs, newItem);
+            }
+            else {
+                if (!xmlDoc.project.component.configs) {
+                    xmlDoc.project.component.configs = {};
+                }
+                xmlDoc.project.component.configs.sshConfig = newItem;
+            }
+            return true;
+        },
+        createNewDocumentFn: (newItem) => ({
+            ...createXmlDocumentBase(),
+            project: {
+                "@_version": "4",
+                component: {
+                    "@_name": "SshConfigs",
+                    configs: { sshConfig: newItem },
+                },
+            },
+        }),
+    };
+    manipulateXmlFile(ideaDir, config, sshConfigItem);
+}
+// Web Server specific functions
+function createWebServerItem(serverId, appShortId, host, username, sshConfigId) {
+    return {
+        "@_id": serverId,
+        "@_name": appShortId,
+        fileTransfer: {
+            "@_accessType": "SFTP",
+            "@_host": host,
+            "@_port": "22",
+            "@_sshConfigId": sshConfigId,
+            "@_sshConfig": `${username}@${host}:22 agent`,
+            "@_authAgent": "true",
+            advancedOptions: {
+                advancedOptions: {
+                    "@_dataProtectionLevel": "Private",
+                    "@_keepAliveTimeout": "0",
+                    "@_passiveMode": "true",
+                    "@_shareSSLContext": "true",
+                },
+            },
+        },
+    };
+}
+function generateWebServersXml(data, serverId, sshConfigId, ideaDir) {
+    const webServerItem = createWebServerItem(serverId, data.appShortId, data.host, data.user, sshConfigId);
+    const config = {
+        filename: "webServers.xml",
+        componentName: "WebServers",
+        checkDuplicateFn: (existing, newItem) => existing.some((server) => server["@_name"] === newItem["@_name"]),
+        addItemFn: (xmlDoc, newItem) => {
+            const servers = xmlDoc.project.component.option;
+            if (servers?.webServer) {
+                const existingServers = ensureArray(servers.webServer);
+                if (existingServers.some((server) => server["@_name"] === newItem["@_name"])) {
+                    return false; // Already exists
+                }
+                addWebServer(servers, newItem);
+            }
+            else {
+                if (!xmlDoc.project.component.option) {
+                    xmlDoc.project.component.option = { "@_name": "servers" };
+                }
+                xmlDoc.project.component.option.webServer = newItem;
+            }
+            return true;
+        },
+        createNewDocumentFn: (newItem) => ({
+            ...createXmlDocumentBase(),
+            project: {
+                "@_version": "4",
+                component: {
+                    "@_name": "WebServers",
+                    option: {
+                        "@_name": "servers",
+                        webServer: newItem,
+                    },
+                },
+            },
+        }),
+    };
+    manipulateXmlFile(ideaDir, config, webServerItem);
+}
+// Deployment specific functions
+function createDeploymentPathItem(appShortId, directory) {
+    return {
+        "@_name": appShortId,
+        serverdata: {
+            mappings: {
+                mapping: {
+                    "@_deploy": directory,
+                    "@_local": "$PROJECT_DIR$",
+                    "@_web": "/",
+                },
+            },
+        },
+    };
+}
+function generateDeploymentXml(data, ideaDir) {
+    const deploymentPathItem = createDeploymentPathItem(data.appShortId, data.directory);
+    const config = {
+        filename: "deployment.xml",
+        componentName: "PublishConfigData",
+        checkDuplicateFn: (existing, newItem) => existing.some((path) => path["@_name"] === newItem["@_name"]),
+        addItemFn: (xmlDoc, newItem) => {
+            const serverData = xmlDoc.project.component.serverData;
+            if (serverData?.paths) {
+                const existingPaths = ensureArray(serverData.paths);
+                if (existingPaths.some((path) => path["@_name"] === newItem["@_name"])) {
+                    return false; // Already exists
+                }
+                addDeploymentPath(serverData, newItem);
+            }
+            else {
+                if (!xmlDoc.project.component.serverData) {
+                    xmlDoc.project.component.serverData = {};
+                }
+                xmlDoc.project.component.serverData.paths = newItem;
+            }
+            return true;
+        },
+        createNewDocumentFn: (newItem) => ({
+            ...createXmlDocumentBase(),
+            project: {
+                "@_version": "4",
+                component: {
+                    "@_name": "PublishConfigData",
+                    "@_serverName": data.appShortId,
+                    "@_remoteFilesAllowedToDisappearOnAutoupload": "false",
+                    serverData: { paths: newItem },
+                },
+            },
+        }),
+    };
+    manipulateXmlFile(ideaDir, config, deploymentPathItem);
+}

package/dist/lib/intellij/config.test.d.ts

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

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;