@mittwald/cli 1.10.0 → 1.11.1

package/dist/commands/project/create.js

@@ -1,11 +1,9 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { serverFlags } from "../../lib/resources/server/flags.js";
 import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
-import { Text } from "ink";
 import { Success } from "../../rendering/react/components/Success.js";
-import { Value } from "../../rendering/react/components/Value.js";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
 import { waitFlags, waitUntil } from "../../lib/wait.js";
 import Context from "../../lib/context/Context.js";
@@ -29,16 +27,16 @@ export default class Create extends ExecRenderBaseCommand {
         const { description } = flags;
         const process = makeProcessRenderer(flags, "Creating project");
         const serverId = await this.withServerId(Create);
-        const stepCreating = process.addStep(_jsx(Text, { children: "creating a new project" }));
+        const stepCreating = process.addStep("creating a new project");
         const result = await this.apiClient.project.createProject({
             serverId,
             data: { description },
         });
         assertStatus(result, 201);
         stepCreating.complete();
-        process.addInfo(_jsxs(Text, { children: ["project ID: ", _jsx(Value, { children: result.data.id })] }));
+        process.addInfo(`project ID: ${result.data.id}`);
         if (flags.wait) {
-            const stepWaiting = process.addStep(_jsx(Text, { children: "waiting for project to be ready" }));
+            const stepWaiting = process.addStep("waiting for project to be ready");
             await waitUntil(async () => {
                 const projectResponse = await this.apiClient.project.getProject({
                     projectId: result.data.id,

package/dist/commands/registry/create.js

@@ -6,7 +6,6 @@ import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
 import { projectFlags } from "../../lib/resources/project/flags.js";
 import { Flags } from "@oclif/core";
-import { Text } from "ink";
 export class Create extends ExecRenderBaseCommand {
     static summary = "Create a new container registry";
     static flags = {
@@ -72,6 +71,6 @@ export class Create extends ExecRenderBaseCommand {
         if (this.flags.password) {
             return this.flags.password;
         }
-        return await process.addInput(_jsx(Text, { children: "enter registry password" }), true);
+        return await process.addInput("enter registry password", true);
     }
 }

package/dist/commands/registry/update.js

@@ -4,7 +4,6 @@ import { Args, Flags } from "@oclif/core";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
 import { Success } from "../../rendering/react/components/Success.js";
 import assertSuccess from "../../lib/apiutil/assert_success.js";
-import { Text } from "ink";
 export default class Update extends ExecRenderBaseCommand {
     static description = "Update an existing container registry";
     static args = {
@@ -68,6 +67,6 @@ export default class Update extends ExecRenderBaseCommand {
         if (this.flags.password) {
             return this.flags.password;
         }
-        return await process.addInput(_jsx(Text, { children: "enter registry password" }), true);
+        return await process.addInput("enter registry password", true);
     }
 }

package/dist/commands/user/api-token/create.js

@@ -39,7 +39,7 @@ export default class Create extends ExecRenderBaseCommand {
             });
             step.complete();
             assertStatus(response, 201);
-            process.complete(_jsx(Success, { width: 100, children: _jsxs(Text, { children: ["API token successfully created. Have fun. \uD83E\uDD73", _jsx(Newline, { count: 2 }), "This is your API token; make sure to store it somewhere safe:", _jsx(Newline, { count: 1 }), _jsx(Value, { children: response.data.token })] }) }));
+            process.complete(_jsx(Success, { children: _jsxs(Text, { children: ["API token successfully created. Have fun. \uD83E\uDD73", _jsx(Newline, { count: 2 }), "This is your API token; make sure to store it somewhere safe:", _jsx(Newline, { count: 1 }), _jsx(Value, { children: response.data.token })] }) }));
             return { token: response.data.token };
         }
         catch (e) {

package/dist/commands/user/ssh-key/create.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import * as path from "path";
@@ -7,8 +7,6 @@ import * as fs from "fs/promises";
 import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
 import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
 import { Success } from "../../../rendering/react/components/Success.js";
-import { Filename } from "../../../rendering/react/components/Filename.js";
-import { Text } from "ink";
 import { spawnInProcess } from "../../../rendering/process/process_exec.js";
 import { expireFlags } from "../../../lib/flags/expireFlags.js";
 export default class Create extends ExecRenderBaseCommand {
@@ -39,7 +37,7 @@ export default class Create extends ExecRenderBaseCommand {
         }
         await spawnInProcess(r, "generating SSH key using ssh-keygen", cmd, args);
         const publicKey = await fs.readFile(outputFile + ".pub", "utf-8");
-        r.addInfo(_jsx(InfoSSHKeySaved, { filename: outputFile }));
+        r.addInfo(`ssh key saved to ${outputFile}.`);
         await r.runStep("importing SSH key", async () => {
             const response = await this.apiClient.user.createSshKey({
                 data: {
@@ -58,12 +56,9 @@ export default class Create extends ExecRenderBaseCommand {
         if (this.flags["no-passphrase"]) {
             return "";
         }
-        return await r.addInput(_jsx(Text, { children: "enter passphrase for SSH key" }), true);
+        return await r.addInput("enter passphrase for SSH key", true);
     }
 }
 function SSHKeySuccess() {
     return (_jsx(Success, { children: "Your SSH key was successfully created and imported to your user profile." }));
 }
-function InfoSSHKeySaved({ filename }) {
-    return (_jsxs(Text, { children: ["ssh key saved to ", _jsx(Filename, { filename: filename }), "."] }));
-}

package/dist/commands/user/ssh-key/import.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import * as path from "path";
@@ -7,7 +7,6 @@ import * as fs from "fs/promises";
 import { ExecRenderBaseCommand } from "../../../lib/basecommands/ExecRenderBaseCommand.js";
 import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
 import { Success } from "../../../rendering/react/components/Success.js";
-import { Filename } from "../../../rendering/react/components/Filename.js";
 import { expireFlags } from "../../../lib/flags/expireFlags.js";
 export default class Import extends ExecRenderBaseCommand {
     static description = "Import an existing (local) SSH key";
@@ -32,7 +31,7 @@ export default class Import extends ExecRenderBaseCommand {
         });
         const keyAlreadyExists = (keys.sshKeys ?? []).some(({ key }) => publicKeyParts.includes(key));
         if (keyAlreadyExists) {
-            r.addInfo(_jsxs(_Fragment, { children: ["the SSH key ", _jsx(Filename, { filename: inputFile }), " is already imported."] }));
+            r.addInfo(`the SSH key ${inputFile} is already imported.`);
             await r.complete(_jsx(SSHKeySuccess, {}));
             return;
         }

package/dist/lib/basecommands/DeleteBaseCommand.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Flags, ux } from "@oclif/core";
 import { ExecRenderBaseCommand } from "./ExecRenderBaseCommand.js";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
@@ -18,15 +18,15 @@ export class DeleteBaseCommand extends ExecRenderBaseCommand {
         const resourceName = this.ctor.resourceName;
         const process = makeProcessRenderer(this.flags, `Deleting ${resourceName}`);
         if (!this.flags.force) {
-            const confirmed = await process.addConfirmation(_jsxs(Text, { children: ["confirm deletion of ", resourceName] }));
+            const confirmed = await process.addConfirmation(`confirm deletion of ${resourceName}`);
             if (!confirmed) {
-                process.addInfo(_jsxs(Text, { children: ["deletion of ", resourceName, " was cancelled"] }));
+                process.addInfo(`deletion of ${resourceName} was cancelled`);
                 process.complete(_jsx(_Fragment, {}));
                 ux.exit(1);
                 return;
             }
         }
-        const deletingStep = process.addStep(_jsxs(Text, { children: ["deleting ", resourceName] }));
+        const deletingStep = process.addStep(`deleting ${resourceName}`);
         try {
             await this.deleteResource();
             deletingStep.complete();

package/dist/lib/ddev/init_assert.js

@@ -1,7 +1,5 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { promisify } from "util";
 import { exec } from "child_process";
-import { Value } from "../../rendering/react/components/Value.js";
 import { hasBinaryInPath } from "../util/fs/hasBinaryInPath.js";
 const execAsync = promisify(exec);
 export async function assertDDEVIsInstalled(r) {
@@ -14,9 +12,6 @@ export async function assertDDEVIsInstalled(r) {
 export async function determineDDEVVersion(r) {
     const { stdout } = await execAsync("ddev --version");
     const version = stdout.trim().replace(/^ddev version +/, "");
-    r.addInfo(_jsx(InfoDDEVVersion, { version: version }));
+    r.addInfo(`detected DDEV version: ${version}`);
     return version;
 }
-function InfoDDEVVersion({ version }) {
-    return (_jsxs(_Fragment, { children: ["detected DDEV version: ", _jsx(Value, { children: version })] }));
-}

package/dist/lib/ddev/init_database.js

@@ -1,7 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { assertStatus, } from "@mittwald/api-client";
-import { Value } from "../../rendering/react/components/Value.js";
-import { Text } from "ink";
 /**
  * Determines the database ID to use for the DDEV project.
  *
@@ -29,7 +26,7 @@ export async function determineDDEVDatabaseId(r, apiClient, flags, appInstallati
             mysqlDatabaseId: databaseId,
         });
         assertStatus(mysqlDatabaseResponse, 200);
-        r.addInfo(_jsx(InfoDatabase, { name: mysqlDatabaseResponse.data.name }));
+        r.addInfo(`using database: ${mysqlDatabaseResponse.data.name}`);
         return mysqlDatabaseResponse.data.name;
     }
     return await promptDatabaseFromUser(r, apiClient, appInstallation);
@@ -54,6 +51,3 @@ async function promptDatabaseFromUser(r, apiClient, appInstallation) {
         },
     ]);
 }
-function InfoDatabase({ name }) {
-    return (_jsxs(Text, { children: ["using database: ", _jsx(Value, { children: name })] }));
-}

package/dist/lib/ddev/init_projecttype.js

@@ -1,9 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { typo3Installer } from "../../commands/app/install/typo3.js";
 import { wordpressInstaller } from "../../commands/app/install/wordpress.js";
 import { shopware6Installer } from "../../commands/app/install/shopware6.js";
-import { Value } from "../../rendering/react/components/Value.js";
-import { Text } from "ink";
 /**
  * A list of all known DDEV project types. Shamelessly stolen from
  * https://ddev.readthedocs.io/en/latest/users/configuration/config/#type
@@ -38,12 +35,12 @@ export const knownDDEVProjectTypes = [
  */
 export async function determineProjectType(r, client, inst, typeOverride) {
     if (typeOverride !== "auto") {
-        r.addInfo(_jsx(ProjectTypeInfoOverride, { type: typeOverride }));
+        r.addInfo(`using DDEV project type: ${typeOverride} (explicitly specified)`);
         return typeOverride;
     }
     const determinedProjectType = await determineProjectTypeFromAppInstallation(client, inst);
     if (determinedProjectType !== null) {
-        r.addInfo(_jsx(ProjectTypeInfoAuto, { type: determinedProjectType }));
+        r.addInfo(`using DDEV project type: ${determinedProjectType} (derived from app installation)`);
         return determinedProjectType;
     }
     return await promptProjectTypeFromUser(r);
@@ -76,9 +73,3 @@ export async function determineProjectTypeFromAppInstallation(client, inst) {
             return null;
     }
 }
-function ProjectTypeInfoOverride({ type }) {
-    return (_jsxs(Text, { children: ["using DDEV project type: ", _jsx(Value, { children: type }), " (explicitly specified)"] }));
-}
-function ProjectTypeInfoAuto({ type }) {
-    return (_jsxs(Text, { children: ["using DDEV project type: ", _jsx(Value, { children: type }), " (derived from app installation)"] }));
-}

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

@@ -0,0 +1,5 @@
+import { SSHConnectionData } from "../resources/ssh/types.js";
+export interface IntellijConfigData extends SSHConnectionData {
+    appShortId: string;
+}
+export declare function generateIntellijConfigs(data: IntellijConfigData, projectDir?: string): void;

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