@mittwald/cli 1.0.0-alpha.41 → 1.0.0-alpha.42

package/README.md

@@ -138,6 +138,7 @@ USAGE
 * [`mw app list`](#mw-app-list)
 * [`mw app ssh [INSTALLATION-ID]`](#mw-app-ssh-installation-id)
 * [`mw app uninstall [INSTALLATION-ID]`](#mw-app-uninstall-installation-id)
+* [`mw app upload [INSTALLATION-ID]`](#mw-app-upload-installation-id)
 * [`mw app versions [APP]`](#mw-app-versions-app)
 * [`mw autocomplete [SHELL]`](#mw-autocomplete-shell)
 * [`mw backup create`](#mw-backup-create)
@@ -170,6 +171,7 @@ USAGE
 * [`mw database mysql delete DATABASE-ID`](#mw-database-mysql-delete-database-id)
 * [`mw database mysql dump DATABASE-ID`](#mw-database-mysql-dump-database-id)
 * [`mw database mysql get DATABASE-ID`](#mw-database-mysql-get-database-id)
+* [`mw database mysql import DATABASE-ID`](#mw-database-mysql-import-database-id)
 * [`mw database mysql list`](#mw-database-mysql-list)
 * [`mw database mysql phpmyadmin DATABASE-ID`](#mw-database-mysql-phpmyadmin-database-id)
 * [`mw database mysql port-forward DATABASE-ID`](#mw-database-mysql-port-forward-database-id)
@@ -1781,6 +1783,47 @@ FLAG DESCRIPTIONS
     scripts), you can use this flag to easily get the IDs of created resources for further processing.
 ```
 
+## `mw app upload [INSTALLATION-ID]`
+
+Upload the filesystem of an app to a project
+
+```
+USAGE
+  $ mw app upload [INSTALLATION-ID] --source <value> [-q] [--ssh-user <value>] [--dry-run] [--delete]
+
+ARGUMENTS
+  INSTALLATION-ID  ID or short ID of an app installation; this argument is optional if a default app installation is set
+                   in the context
+
+FLAGS
+  -q, --quiet             suppress process output and only display a machine-readable summary.
+      --delete            delete remote files that are not present locally
+      --dry-run           do not actually upload the app installation
+      --source=<value>    (required) source directory from which to upload the app installation
+      --ssh-user=<value>  override the SSH user to connect with; if omitted, your own user will be used
+
+DESCRIPTION
+  Upload the filesystem of an app to a project
+
+  Upload the filesystem of an app from your local machine to a project.
+
+  CAUTION: This is a potentially destructive operation. It will overwrite files on the server with the files from your
+  local machine. This is NOT a turnkey deployment solution. It is intended for development purposes only.
+
+FLAG DESCRIPTIONS
+  -q, --quiet  suppress process output and only display a machine-readable summary.
+
+    This flag controls if you want to see the process output or only a summary. When using mw non-interactively (e.g. in
+    scripts), you can use this flag to easily get the IDs of created resources for further processing.
+
+  --ssh-user=<value>  override the SSH user to connect with; if omitted, your own user will be used
+
+    This flag can be used to override the SSH user that is used for a connection; be default, your own personal user
+    will be used for this.
+
+    You can also set this value by setting the MITTWALD_SSH_USER environment variable.
+```
+
 ## `mw app versions [APP]`
 
 List supported Apps and Versions
@@ -1825,7 +1868,7 @@ EXAMPLES
   $ mw autocomplete --refresh-cache
 ```
 
-_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v3.0.13/src/commands/autocomplete/index.ts)_
+_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v3.0.15/src/commands/autocomplete/index.ts)_
 
 ## `mw backup create`
 
@@ -2540,7 +2583,7 @@ Create a dump of a MySQL database
 
 ```
 USAGE
-  $ mw database mysql dump DATABASE-ID -o <value> [-q] [-p <value>] [--ssh-user <value>] [--temporary-user] [--gzip]
+  $ mw database mysql dump DATABASE-ID -o <value> [-q] [-p <value>] [--temporary-user] [--ssh-user <value>] [--gzip]
 
 ARGUMENTS
   DATABASE-ID  The ID or name of the database
@@ -2587,8 +2630,8 @@ FLAG DESCRIPTIONS
 
   --[no-]temporary-user  create a temporary user for the dump
 
-    Create a temporary user for the dump. This user will be deleted after the dump has been created. This is useful if
-    you want to dump a database that is not accessible from the outside.
+    Create a temporary user for this operation. This user will be deleted after the operation has completed. This is
+    useful if you want to work with a database that is not accessible from the outside.
 
     If this flag is disabled, you will need to specify the password of the default user; either via the --mysql-password
     flag or via the MYSQL_PWD environment variable.
@@ -2613,6 +2656,65 @@ DESCRIPTION
   Get a MySQLDatabase.
 ```
 
+## `mw database mysql import DATABASE-ID`
+
+Imports a dump of a MySQL database
+
+```
+USAGE
+  $ mw database mysql import DATABASE-ID -i <value> [-q] [-p <value>] [--temporary-user] [--ssh-user <value>] [--gzip]
+
+ARGUMENTS
+  DATABASE-ID  The ID or name of the database
+
+FLAGS
+  -i, --input=<value>           (required) the input file from which to read the dump ("-" for stdin)
+  -p, --mysql-password=<value>  the password to use for the MySQL user (env: MYSQL_PWD)
+  -q, --quiet                   suppress process output and only display a machine-readable summary.
+      --gzip                    uncompress the dump with gzip
+      --ssh-user=<value>        override the SSH user to connect with; if omitted, your own user will be used
+      --[no-]temporary-user     create a temporary user for the dump
+
+FLAG DESCRIPTIONS
+  -i, --input=<value>  the input file from which to read the dump ("-" for stdin)
+
+    The input file from which to read the dump to. You can specify "-" or "/dev/stdin" to read the dump directly from
+    STDIN.
+
+  -p, --mysql-password=<value>  the password to use for the MySQL user (env: MYSQL_PWD)
+
+    The password to use for the MySQL user. If not provided, the environment variable MYSQL_PWD will be used. If that is
+    not set either, the command will interactively ask for the password.
+
+    NOTE: This is a security risk, as the password will be visible in the process list of your system, and will be
+    visible in your Shell history. It is recommended to use the environment variable instead.
+
+  -q, --quiet  suppress process output and only display a machine-readable summary.
+
+    This flag controls if you want to see the process output or only a summary. When using mw non-interactively (e.g. in
+    scripts), you can use this flag to easily get the IDs of created resources for further processing.
+
+  --gzip  uncompress the dump with gzip
+
+    Uncompress the dump with gzip while importing. This is useful for large databases, as it can significantly reduce
+    the size of the dump.
+
+  --ssh-user=<value>  override the SSH user to connect with; if omitted, your own user will be used
+
+    This flag can be used to override the SSH user that is used for a connection; be default, your own personal user
+    will be used for this.
+
+    You can also set this value by setting the MITTWALD_SSH_USER environment variable.
+
+  --[no-]temporary-user  create a temporary user for the dump
+
+    Create a temporary user for this operation. This user will be deleted after the operation has completed. This is
+    useful if you want to work with a database that is not accessible from the outside.
+
+    If this flag is disabled, you will need to specify the password of the default user; either via the --mysql-password
+    flag or via the MYSQL_PWD environment variable.
+```
+
 ## `mw database mysql list`
 
 List MySQLDatabases belonging to a Project.
@@ -3391,7 +3493,7 @@ DESCRIPTION
   Display help for mw.
 ```
 
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.0.20/src/commands/help.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.0.21/src/commands/help.ts)_
 
 ## `mw login reset`
 
@@ -4785,7 +4887,7 @@ EXAMPLES
     $ mw update --available
 ```
 
-_See code: [@oclif/plugin-update](https://github.com/oclif/plugin-update/blob/v4.2.3/src/commands/update.ts)_
+_See code: [@oclif/plugin-update](https://github.com/oclif/plugin-update/blob/v4.2.6/src/commands/update.ts)_
 
 ## `mw user api-token create`
 

package/dist/commands/app/list.js

@@ -1,9 +1,8 @@
 import { assertStatus } from "@mittwald/api-client-commons";
 import { projectFlags, withProjectId } from "../../lib/project/flags.js";
 import { ListBaseCommand } from "../../ListBaseCommand.js";
-import { phpInstaller } from "./create/php.js";
-import { nodeInstaller } from "./create/node.js";
 import { getAppFromUuid, getAppVersionFromUuid } from "../../lib/app/uuid.js";
+import { isCustomAppInstallation } from "../../lib/app/custom_installation.js";
 export default class List extends ListBaseCommand {
     static description = "List installed apps in a project.";
     static flags = {
@@ -44,7 +43,7 @@ export default class List extends ListBaseCommand {
             appVersion: {
                 header: "Version",
                 get: (i) => {
-                    if ([phpInstaller.appId, nodeInstaller.appId].includes(i.appId)) {
+                    if (isCustomAppInstallation(i.appId)) {
                         return "n/a";
                     }
                     if (i.appVersionCurrent?.id === i.appVersionDesired.id) {

package/dist/commands/app/upload.d.ts

@@ -0,0 +1,18 @@
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Upload extends ExecRenderBaseCommand<typeof Upload, void> {
+    static summary: string;
+    static description: string;
+    static args: {
+        "installation-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string>;
+    };
+    static flags: {
+        "dry-run": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        delete: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        source: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "ssh-user": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}

package/dist/commands/app/upload.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../rendering/react/ExecRenderBaseCommand.js";
+import { appInstallationArgs } from "../../lib/app/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { Success } from "../../rendering/react/components/Success.js";
+import { hasBinary } from "../../lib/hasbin.js";
+import { getSSHConnectionForAppInstallation } from "../../lib/ssh/appinstall.js";
+import { spawnInProcess } from "../../rendering/process/process_exec.js";
+import { sshConnectionFlags } from "../../lib/ssh/flags.js";
+export class Upload extends ExecRenderBaseCommand {
+    static summary = "Upload the filesystem of an app to a project";
+    static description = "Upload the filesystem of an app from your local machine to a project.\n\n" +
+        "" +
+        "CAUTION: This is a potentially destructive operation. It will overwrite files on the server with the files from your local machine. " +
+        "This is NOT a turnkey deployment solution. It is intended for development purposes only.";
+    static args = {
+        ...appInstallationArgs,
+    };
+    static flags = {
+        ...processFlags,
+        ...sshConnectionFlags,
+        "dry-run": Flags.boolean({
+            description: "do not actually upload the app installation",
+            default: false,
+        }),
+        delete: Flags.boolean({
+            description: "delete remote files that are not present locally",
+            default: false,
+        }),
+        source: Flags.directory({
+            description: "source directory from which to upload the app installation",
+            required: true,
+            exists: true,
+        }),
+    };
+    async exec() {
+        const appInstallationId = await this.withAppInstallationId(Upload);
+        const { "dry-run": dryRun, source, delete: deleteRemote, "ssh-user": sshUser, } = this.flags;
+        const p = makeProcessRenderer(this.flags, "Uploading app installation");
+        const { host, user, directory } = await p.runStep("getting connection data", async () => {
+            return getSSHConnectionForAppInstallation(this.apiClient, appInstallationId, sshUser);
+        });
+        await p.runStep("check if rsync is installed", async () => {
+            if (!(await hasBinary("rsync"))) {
+                throw new Error("this command requires rsync to be installed");
+            }
+        });
+        const rsyncOpts = [
+            "--archive",
+            "--recursive",
+            "--verbose",
+            "--progress",
+            "--exclude=typo3temp",
+        ];
+        if (dryRun) {
+            rsyncOpts.push("--dry-run");
+        }
+        if (deleteRemote) {
+            rsyncOpts.push("--delete");
+        }
+        await spawnInProcess(p, "uploading app installation" + (dryRun ? " (dry-run)" : ""), "rsync", [...rsyncOpts, source, `${user}@${host}:${directory}/`]);
+        await p.complete(_jsx(UploadSuccess, { dryRun: dryRun }));
+    }
+    render() {
+        return undefined;
+    }
+}
+function UploadSuccess({ dryRun }) {
+    if (dryRun) {
+        return (_jsx(Success, { children: "App would (probably) have successfully been uploaded. \uD83D\uDE42" }));
+    }
+    return _jsx(Success, { children: "App successfully uploaded; have fun! \uD83D\uDE80" });
+}

package/dist/commands/database/mysql/dump.d.ts

@@ -3,10 +3,10 @@ import { ReactNode } from "react";
 export declare class Dump extends ExecRenderBaseCommand<typeof Dump, Record<string, never>> {
     static summary: string;
     static flags: {
-        "temporary-user": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         gzip: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         "ssh-user": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "temporary-user": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         "mysql-password": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
@@ -16,5 +16,4 @@ export declare class Dump extends ExecRenderBaseCommand<typeof Dump, Record<stri
     protected exec(): Promise<Record<string, never>>;
     protected render(): ReactNode;
     private getOutputStream;
-    private createTemporaryUser;
 }

package/dist/commands/database/mysql/dump.js

@@ -6,27 +6,17 @@ import { Text } from "ink";
 import { Value } from "../../../rendering/react/components/Value.js";
 import * as fs from "fs";
 import { Success } from "../../../rendering/react/components/Success.js";
-import { mysqlArgs, mysqlConnectionFlags, withMySQLId, } from "../../../lib/database/mysql/flags.js";
-import { getConnectionDetailsWithPassword } from "../../../lib/database/mysql/connect.js";
-import { assertStatus } from "@mittwald/api-client";
-import { randomBytes } from "crypto";
+import { mysqlArgs, mysqlConnectionFlagsWithTempUser, withMySQLId, } from "../../../lib/database/mysql/flags.js";
+import { runWithConnectionDetails } from "../../../lib/database/mysql/connect.js";
 import { executeViaSSH } from "../../../lib/ssh/exec.js";
-import assertSuccess from "../../../lib/assert_success.js";
 import shellEscape from "shell-escape";
 import { sshConnectionFlags } from "../../../lib/ssh/flags.js";
 export class Dump extends ExecRenderBaseCommand {
     static summary = "Create a dump of a MySQL database";
     static flags = {
         ...processFlags,
-        ...mysqlConnectionFlags,
+        ...mysqlConnectionFlagsWithTempUser,
         ...sshConnectionFlags,
-        "temporary-user": Flags.boolean({
-            summary: "create a temporary user for the dump",
-            description: "Create a temporary user for the dump. This user will be deleted after the dump has been created. This is useful if you want to dump a database that is not accessible from the outside.\n\nIf this flag is disabled, you will need to specify the password of the default user; either via the --mysql-password flag or via the MYSQL_PWD environment variable.",
-            default: true,
-            required: false,
-            allowNo: true,
-        }),
         output: Flags.string({
             char: "o",
             summary: 'the output file to write the dump to ("-" for stdout)',
@@ -45,29 +35,20 @@ export class Dump extends ExecRenderBaseCommand {
     async exec() {
         const databaseId = await withMySQLId(this.apiClient, this.flags, this.args);
         const p = makeProcessRenderer(this.flags, "Dumping a MySQL database");
-        const connectionDetails = await getConnectionDetailsWithPassword(this.apiClient, databaseId, p, this.flags);
-        if (this.flags["temporary-user"]) {
-            const [tempUser, tempPassword] = await p.runStep("creating a temporary database user", () => this.createTemporaryUser(databaseId));
-            p.addCleanup("removing temporary database user", async () => {
-                const r = await this.apiClient.database.deleteMysqlUser({
-                    mysqlUserId: tempUser.id,
-                });
-                assertSuccess(r);
-            });
-            connectionDetails.user = tempUser.name;
-            connectionDetails.password = tempPassword;
-        }
-        const { project } = connectionDetails;
-        const mysqldumpArgs = buildMySqlDumpArgs(connectionDetails);
-        let cmd = { command: "mysqldump", args: mysqldumpArgs };
-        if (this.flags.gzip) {
-            const escapedArgs = shellEscape(mysqldumpArgs);
-            cmd = {
-                shell: `set -e -o pipefail > /dev/null ; mysqldump ${escapedArgs} | gzip`,
-            };
-        }
-        await p.runStep(_jsxs(Text, { children: ["starting mysqldump via SSH on project ", _jsx(Value, { children: project.shortId })] }), () => executeViaSSH(this.apiClient, this.flags["ssh-user"], { projectId: connectionDetails.project.id }, cmd, this.getOutputStream()));
-        await p.complete(_jsx(DumpSuccess, { database: connectionDetails.database, output: this.flags.output }));
+        const databaseName = await runWithConnectionDetails(this.apiClient, databaseId, p, this.flags, async (connectionDetails) => {
+            const { project } = connectionDetails;
+            const mysqldumpArgs = buildMySqlDumpArgs(connectionDetails);
+            let cmd = { command: "mysqldump", args: mysqldumpArgs };
+            if (this.flags.gzip) {
+                const escapedArgs = shellEscape(mysqldumpArgs);
+                cmd = {
+                    shell: `set -e -o pipefail > /dev/null ; mysqldump ${escapedArgs} | gzip`,
+                };
+            }
+            await p.runStep(_jsxs(Text, { children: ["starting mysqldump via SSH on project", " ", _jsx(Value, { children: project.shortId })] }), () => executeViaSSH(this.apiClient, this.flags["ssh-user"], { projectId: connectionDetails.project.id }, cmd, { input: null, output: this.getOutputStream() }));
+            return connectionDetails.database;
+        });
+        await p.complete(_jsx(DumpSuccess, { database: databaseName, output: this.flags.output }));
         return {};
     }
     render() {
@@ -79,29 +60,10 @@ export class Dump extends ExecRenderBaseCommand {
         }
         return fs.createWriteStream(this.flags.output);
     }
-    async createTemporaryUser(databaseId) {
-        const password = randomBytes(32).toString("base64");
-        const createResponse = await this.apiClient.database.createMysqlUser({
-            mysqlDatabaseId: databaseId,
-            data: {
-                accessLevel: "full", // needed for "PROCESS" privilege
-                externalAccess: false,
-                password,
-                databaseId,
-                description: "Temporary user for exporting database",
-            },
-        });
-        assertStatus(createResponse, 201);
-        const userResponse = await this.apiClient.database.getMysqlUser({
-            mysqlUserId: createResponse.data.id,
-        });
-        assertStatus(userResponse, 200);
-        return [userResponse.data, password];
-    }
 }
 function DumpSuccess({ database, output, }) {
     return (_jsxs(Success, { children: ["Dump of MySQL database ", _jsx(Value, { children: database }), " written to", " ", _jsx(Value, { children: output })] }));
 }
 function buildMySqlDumpArgs(d) {
-    return ["-h", d.hostname, "-u", d.user, "-p" + d.password, d.database];
+    return ["-h", d.hostname, "-u", d.user, `-p${d.password}`, d.database];
 }

package/dist/commands/database/mysql/import.d.ts

@@ -0,0 +1,19 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Import extends ExecRenderBaseCommand<typeof Import, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        input: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        gzip: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "ssh-user": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "temporary-user": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        "mysql-password": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Record<string, never>>;
+    protected render(): ReactNode;
+    private getInputStream;
+}

package/dist/commands/database/mysql/import.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { Flags } from "@oclif/core";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Text } from "ink";
+import { Value } from "../../../rendering/react/components/Value.js";
+import * as fs from "fs";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { mysqlArgs, mysqlConnectionFlagsWithTempUser, withMySQLId, } from "../../../lib/database/mysql/flags.js";
+import { executeViaSSH } from "../../../lib/ssh/exec.js";
+import { sshConnectionFlags } from "../../../lib/ssh/flags.js";
+import shellEscape from "shell-escape";
+import { runWithConnectionDetails } from "../../../lib/database/mysql/connect.js";
+export class Import extends ExecRenderBaseCommand {
+    static summary = "Imports a dump of a MySQL database";
+    static flags = {
+        ...processFlags,
+        ...mysqlConnectionFlagsWithTempUser,
+        ...sshConnectionFlags,
+        input: Flags.string({
+            char: "i",
+            summary: 'the input file from which to read the dump ("-" for stdin)',
+            description: 'The input file from which to read the dump to. You can specify "-" or "/dev/stdin" to read the dump directly from STDIN.',
+            required: true,
+        }),
+        gzip: Flags.boolean({
+            summary: "uncompress the dump with gzip",
+            aliases: ["gz"],
+            description: "Uncompress the dump with gzip while importing. This is useful for large databases, as it can significantly reduce the size of the dump.",
+            default: false,
+            required: false,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        const p = makeProcessRenderer(this.flags, "Importing a MySQL database");
+        const databaseName = await runWithConnectionDetails(this.apiClient, databaseId, p, this.flags, async (connectionDetails) => {
+            const { project } = connectionDetails;
+            const mysqlArgs = buildMySqlArgs(connectionDetails);
+            let cmd = { command: "mysql", args: mysqlArgs };
+            if (this.flags.gzip) {
+                const escapedArgs = shellEscape(mysqlArgs);
+                cmd = {
+                    shell: `set -e -o pipefail > /dev/null ; gunzip | mysql ${escapedArgs}`,
+                };
+            }
+            await p.runStep(_jsxs(Text, { children: ["starting mysql via SSH on project ", _jsx(Value, { children: project.shortId })] }), () => executeViaSSH(this.apiClient, this.flags["ssh-user"], { projectId: connectionDetails.project.id }, cmd, { input: this.getInputStream(), output: null }));
+            return connectionDetails.database;
+        });
+        await p.complete(_jsx(ImportSuccess, { database: databaseName, input: this.flags.input }));
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+    getInputStream() {
+        if (this.flags.input === "-") {
+            return process.stdin;
+        }
+        return fs.createReadStream(this.flags.input);
+    }
+}
+function ImportSuccess({ database, input, }) {
+    return (_jsxs(Success, { children: ["Dump of MySQL database ", _jsx(Value, { children: database }), " successfully imported", " ", "from ", _jsx(Value, { children: input })] }));
+}
+function buildMySqlArgs(d) {
+    return ["-h", d.hostname, "-u", d.user, `-p${d.password}`, d.database];
+}

package/dist/lib/app/custom_installation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests if an app installation is for a custom app (for example, a custom PHP
+ * or Node.js app). These are treated differently in the UI.
+ *
+ * @param appId
+ */
+export declare function isCustomAppInstallation(appId: string): boolean;

package/dist/lib/app/custom_installation.js

@@ -0,0 +1,16 @@
+import { phpInstaller } from "../../commands/app/create/php.js";
+import { nodeInstaller } from "../../commands/app/create/node.js";
+import { pythonInstaller } from "../../commands/app/create/python.js";
+/**
+ * Tests if an app installation is for a custom app (for example, a custom PHP
+ * or Node.js app). These are treated differently in the UI.
+ *
+ * @param appId
+ */
+export function isCustomAppInstallation(appId) {
+    return [
+        phpInstaller.appId,
+        nodeInstaller.appId,
+        pythonInstaller.appId,
+    ].includes(appId);
+}

package/dist/lib/app/flags.js

@@ -13,6 +13,10 @@ import { makeFlagSet } from "../context_flags.js";
 export const { flags: appInstallationFlags, args: appInstallationArgs, withId: withAppInstallationId, } = makeFlagSet("installation", "i", {
     displayName: "app installation",
     normalize: normalizeAppInstallationId,
+    expectedShortIDFormat: {
+        pattern: /^a-.*/,
+        display: "a-XXXXXX",
+    },
 });
 function buildFlagsWithDescription(appName) {
     return {

package/dist/lib/context_flags.d.ts

@@ -33,6 +33,10 @@ export type FlagSet<TName extends ContextNames> = {
 export type FlagSetOptions = {
     normalize: NormalizeFn;
     displayName: string;
+    expectedShortIDFormat: {
+        pattern: RegExp;
+        display: string;
+    };
 };
 export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string) => string | Promise<string>;
 export declare function makeMissingContextInputError<TName extends ContextNames>(commandType: {

package/dist/lib/context_flags.js

@@ -1,5 +1,8 @@
 import { Args, Flags } from "@oclif/core";
 import { Context } from "./context.js";
+import UnexpectedShortIDPassedError from "./error/UnexpectedShortIDPassedError.js";
+import { isUuid } from "../normalize_id.js";
+import { articleForWord } from "./language.js";
 export class MissingFlagError extends Error {
     constructor(name, flagName) {
         super(`No ${name} ID given. Please specify one with --${flagName} or set a default ${name} with 'mittwald context set --${flagName} <${flagName}>'`);
@@ -30,7 +33,7 @@ export function makeMissingContextInputError(commandType, name, flagName, contex
 }
 export function makeFlagSet(name, char, opts = {}) {
     const { displayName = name, normalize = (_, id) => id } = opts;
-    const article = displayName.match(/^[aeiou]/i) ? "an" : "a";
+    const article = articleForWord(displayName);
     const flagName = `${name}-id`;
     const flags = {
         [flagName]: Flags.string({
@@ -55,9 +58,19 @@ export function makeFlagSet(name, char, opts = {}) {
         }
         return undefined;
     };
+    let idInputSanityCheck = () => { };
+    if (opts.expectedShortIDFormat != null) {
+        const format = opts.expectedShortIDFormat;
+        idInputSanityCheck = (id) => {
+            if (!isUuid(id) && !format.pattern.test(id)) {
+                throw new UnexpectedShortIDPassedError(displayName, format.display);
+            }
+        };
+    }
     const withId = async (apiClient, commandType, flags, args, cfg) => {
         const idInput = idFromArgsOrFlag(flags, args);
         if (idInput) {
+            idInputSanityCheck(idInput);
             return normalize(apiClient, idInput);
         }
         const idFromContext = await new Context(apiClient, cfg).getContextValue(flagName);

package/dist/lib/database/mysql/connect.d.ts

@@ -1,23 +1,31 @@
 import { ProcessRenderer } from "../../../rendering/process/process.js";
-import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
-export declare function getConnectionDetailsWithPassword(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: {
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+type Project = MittwaldAPIV2.Components.Schemas.ProjectProject;
+export interface MySQLConnectionFlags {
     "mysql-password": string | undefined;
     "temporary-user"?: boolean;
     "ssh-user"?: string;
-}): Promise<{
-    password: string;
+}
+export interface MySQLConnectionDetails {
     hostname: string;
     database: string;
     user: string;
     sshHost: string;
     sshUser: string;
-    project: MittwaldAPIV2.Components.Schemas.ProjectProject;
-}>;
-export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, sshUser: string | undefined, p: ProcessRenderer): Promise<{
-    hostname: string;
-    database: string;
-    user: string;
-    sshHost: string;
-    sshUser: string;
-    project: MittwaldAPIV2.Components.Schemas.ProjectProject;
-}>;
+    project: Project;
+}
+export type MySQLConnectionDetailsWithPassword = MySQLConnectionDetails & {
+    password: string;
+};
+/**
+ * Runs a callback function with connection details for a MySQL database.
+ *
+ * Depending on the flags, this function will either use the credentials
+ * provided in the flags (or prompt for a password), or create a temporary user
+ * for the operation, which will be cleaned up afterwards.
+ */
+export declare function runWithConnectionDetails<TRes>(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: MySQLConnectionFlags, cb: (connectionDetails: MySQLConnectionDetailsWithPassword) => Promise<TRes>): Promise<TRes>;
+export declare function getConnectionDetailsWithPassword(apiClient: MittwaldAPIV2Client, databaseId: string, p: ProcessRenderer, flags: MySQLConnectionFlags): Promise<MySQLConnectionDetailsWithPassword>;
+export declare function getConnectionDetails(apiClient: MittwaldAPIV2Client, databaseId: string, sshUser: string | undefined, p: ProcessRenderer): Promise<MySQLConnectionDetails>;
+export {};