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

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

@@ -0,0 +1,108 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { projectFlags } from "../../../lib/project/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import { Flags } from "@oclif/core";
+import { Text } from "ink";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { Success } from "../../../rendering/react/components/Success.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+export class Create extends ExecRenderBaseCommand {
+    static summary = "Create a new MySQL database";
+    static flags = {
+        ...projectFlags,
+        ...processFlags,
+        description: Flags.string({
+            char: "d",
+            summary: "a description for the database",
+            required: true,
+        }),
+        version: Flags.string({
+            summary: "the MySQL version to use",
+            description: 'Use the "database mysql versions" command to list available versions',
+            required: true,
+        }),
+        collation: Flags.string({
+            summary: "the collation to use",
+            default: "utf8mb4_unicode_ci",
+        }),
+        "character-set": Flags.string({
+            summary: "the character set to use",
+            default: "utf8mb4",
+        }),
+        "user-password": Flags.string({
+            summary: "the password to use for the default user (env: MYSQL_PWD)",
+            env: "MYSQL_PWD",
+        }),
+        "user-external": Flags.boolean({
+            summary: "enable external access for default user",
+            default: false,
+        }),
+        "user-access-level": Flags.string({
+            summary: "the access level preset for the default user",
+            options: ["full", "readonly"],
+            default: "full",
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating a new MySQL database");
+        const projectId = await this.withProjectId(Create);
+        const { description, version, collation, "character-set": characterSet, "user-external": externalAccess, "user-access-level": accessLevel, } = this.flags;
+        const password = await this.getPassword(p);
+        const db = await this.createMySQLDatabase(p, projectId, {
+            description,
+            version,
+            characterSettings: {
+                collation,
+                characterSet,
+            },
+        }, {
+            password,
+            externalAccess,
+            accessLevel: accessLevel,
+        });
+        const database = await p.runStep("fetching database", async () => {
+            const response = await this.apiClient.database.getMysqlDatabase({
+                mysqlDatabaseId: db.id,
+            });
+            assertStatus(response, 200);
+            return response.data;
+        });
+        const user = await p.runStep("fetching user", async () => {
+            const response = await this.apiClient.database.getMysqlUser({
+                mysqlUserId: db.userId,
+            });
+            assertStatus(response, 200);
+            return response.data;
+        });
+        await p.complete(_jsx(DatabaseCreateSuccess, { database: database, user: user }));
+        return { databaseId: db.id, userId: db.userId };
+    }
+    async createMySQLDatabase(p, projectId, database, user) {
+        return await p.runStep("creating MySQL database", async () => {
+            const r = await this.apiClient.database.createMysqlDatabase({
+                projectId,
+                data: {
+                    database: { projectId, ...database },
+                    user,
+                },
+            });
+            assertStatus(r, 201);
+            return r.data;
+        });
+    }
+    async getPassword(p) {
+        if (this.flags["user-password"]) {
+            return this.flags["user-password"];
+        }
+        return await p.addInput(_jsx(Text, { children: "enter password for default user" }), true);
+    }
+    render({ databaseId }) {
+        if (this.flags.quiet) {
+            return databaseId;
+        }
+    }
+}
+function DatabaseCreateSuccess({ database, user, }) {
+    return (_jsxs(Success, { children: ["The database ", _jsx(Value, { children: database.name }), " and the user", " ", _jsx(Value, { children: user.name }), " were successfully created."] }));
+}

package/dist/commands/database/mysql/create.test.d.ts

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

package/dist/commands/database/mysql/create.test.js

@@ -0,0 +1,100 @@
+import { expect, test } from "@oclif/test";
+describe("database:mysql:create", () => {
+    const projectId = "339d6458-839f-4809-a03d-78700069690c";
+    const databaseId = "83e0cb85-dcf7-4968-8646-87a63980ae91";
+    const userId = "a8c1eb2a-aa4d-4daf-8e21-9d91d56559ca";
+    const password = "secret";
+    const description = "Test";
+    const createFlags = [
+        "database mysql create",
+        "--project-id",
+        projectId,
+        "--version",
+        "8.0",
+        "--description",
+        description,
+        "--user-password",
+        password,
+    ];
+    test
+        .nock("https://api.mittwald.de", (api) => {
+        api.get(`/v2/projects/${projectId}`).reply(200, {
+            id: projectId,
+        });
+        api
+            .post(`/v2/projects/${projectId}/mysql-databases`, {
+            database: {
+                projectId,
+                description,
+                version: "8.0",
+                characterSettings: {
+                    collation: "utf8mb4_unicode_ci",
+                    characterSet: "utf8mb4",
+                },
+            },
+            user: {
+                password,
+                externalAccess: false,
+                accessLevel: "full",
+            },
+        })
+            .reply(201, { id: databaseId, userId });
+        api.get(`/v2/mysql-databases/${databaseId}`).reply(200, {
+            id: databaseId,
+            name: "mysql_xxxxxx",
+        });
+        api.get(`/v2/mysql-users/${userId}`).reply(200, {
+            id: userId,
+            name: "dbu_xxxxxx",
+        });
+    })
+        .env({ MITTWALD_API_TOKEN: "foo" })
+        .stdout()
+        .command(createFlags)
+        .it("creates a database and prints database and user name", (ctx) => {
+        // cannot match on exact output, because linebreaks
+        expect(ctx.stdout).to.contain("The database mysql_xxxxxx");
+        expect(ctx.stdout).to.contain("the user dbu_xxxxxx");
+    });
+    test
+        .nock("https://api.mittwald.de", (api) => {
+        api.get(`/v2/projects/${projectId}`).reply(200, {
+            id: projectId,
+        });
+        api
+            .post(`/v2/projects/${projectId}/mysql-databases`, {
+            database: {
+                projectId,
+                description: "Test",
+                version: "8.0",
+                characterSettings: {
+                    collation: "utf8mb4_unicode_ci",
+                    characterSet: "utf8mb4",
+                },
+            },
+            user: {
+                password: "secret",
+                externalAccess: false,
+                accessLevel: "full",
+            },
+        })
+            .reply(201, { id: databaseId, userId });
+        api.get(`/v2/mysql-databases/${databaseId}`).reply(200, {
+            id: databaseId,
+            name: "mysql_xxxxxx",
+        });
+        api.get(`/v2/mysql-users/${userId}`).times(3).reply(403);
+        api.get(`/v2/mysql-users/${userId}`).reply(200, {
+            id: userId,
+            name: "dbu_xxxxxx",
+        });
+    })
+        .env({ MITTWALD_API_TOKEN: "foo" })
+        .stdout()
+        .command(createFlags)
+        .it("retries fetching user until successful", (ctx) => {
+        // cannot match on exact output, because linebreaks
+        expect(ctx.stdout).to.contain("The database mysql_xxxxxx");
+        expect(ctx.stdout).to.contain("the user dbu_xxxxxx");
+    });
+});

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

@@ -0,0 +1,14 @@
+import { DeleteBaseCommand } from "../../../DeleteBaseCommand.js";
+export default class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static flags: {
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        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 deleteResource(): Promise<void>;
+    protected mapResourceId(id: string): Promise<string>;
+}

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

@@ -0,0 +1,20 @@
+import { normalizeProjectId } from "../../../normalize_id.js";
+import { DeleteBaseCommand } from "../../../DeleteBaseCommand.js";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+import assertSuccess from "../../../lib/assert_success.js";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a MySQL database";
+    static resourceName = "MySQL database";
+    static flags = { ...DeleteBaseCommand.baseFlags };
+    static args = { ...mysqlArgs };
+    async deleteResource() {
+        const mysqlDatabaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        const response = await this.apiClient.database.deleteMysqlDatabase({
+            mysqlDatabaseId,
+        });
+        assertSuccess(response);
+    }
+    mapResourceId(id) {
+        return normalizeProjectId(this.apiClient, id);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+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>;
+        "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 getOutputStream;
+    private createTemporaryUser;
+}

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

@@ -0,0 +1,107 @@
+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, 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 { 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,
+        ...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)',
+            description: 'The output file to write the dump to. You can specify "-" or "/dev/stdout" to write the dump directly to STDOUT; in this case, you might want to use the --quiet/-q flag to supress all other output, so that you can pipe the mysqldump for further processing.',
+            required: true,
+        }),
+        gzip: Flags.boolean({
+            summary: "compress the dump with gzip",
+            aliases: ["gz"],
+            description: "Compress the dump with gzip. 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, "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 }));
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+    getOutputStream() {
+        if (this.flags.output === "-") {
+            return process.stdout;
+        }
+        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];
+}

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

@@ -0,0 +1,15 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2MysqlDatabasesMysqlDatabaseId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["database"]["getMysqlDatabase"]>>;
+export declare abstract class Get extends GetBaseCommand<typeof Get, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").Flag<any>;
+    };
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { GetBaseCommand } from "../../../GetBaseCommand.js";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+export class Get extends GetBaseCommand {
+    static description = "Get a MySQLDatabase.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = { ...mysqlArgs };
+    async getData() {
+        const mysqlDatabaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        return await this.apiClient.database.getMysqlDatabase({
+            mysqlDatabaseId,
+        });
+    }
+}

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

@@ -0,0 +1,40 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SuccessfulResponse } from "../../../types.js";
+import { ListColumns } from "../../../Formatter.js";
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdMysqlDatabases.Get.Responses.$200.Content.ApplicationJson[number]>;
+type Response = Awaited<ReturnType<MittwaldAPIV2Client["database"]["listMysqlDatabases"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string>;
+        columns?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        csv?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        extended?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        filter?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        'no-header'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        'no-truncate'?: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean> | undefined;
+        output: import("@oclif/core/lib/interfaces/parser.js").FlagProps & {
+            type: "option";
+            helpValue?: string | undefined;
+            options?: readonly string[] | undefined;
+            multiple?: boolean | undefined;
+            multipleNonGreedy?: boolean | undefined;
+            delimiter?: "," | undefined;
+            allowStdin?: boolean | "only" | undefined;
+        } & {
+            parse: import("@oclif/core/lib/interfaces/parser.js").FlagParser<string | undefined, string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            defaultHelp?: import("@oclif/core/lib/interfaces/parser.js").FlagDefaultHelp<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+            input: string[];
+            default?: import("@oclif/core/lib/interfaces/parser.js").FlagDefault<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        };
+        sort?: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined> | undefined;
+        "no-relative-dates": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    getData(): Promise<Response>;
+    protected mapData(data: SuccessfulResponse<Response, 200>["data"]): MittwaldAPIV2.Components.Schemas.DatabaseMySqlDatabase[];
+    protected getColumns(ignoredData: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

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

@@ -0,0 +1,57 @@
+import { ListBaseCommand } from "../../../ListBaseCommand.js";
+import { projectFlags } from "../../../lib/project/flags.js";
+export class List extends ListBaseCommand {
+    static description = "List MySQLDatabases belonging to a Project.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return await this.apiClient.database.listMysqlDatabases({
+            projectId,
+        });
+    }
+    mapData(data) {
+        return data;
+    }
+    getColumns(ignoredData) {
+        const { id, name, createdAt } = super.getColumns(ignoredData, {
+            shortIdKey: "name",
+        });
+        return {
+            id,
+            name,
+            version: {
+                header: "Version",
+            },
+            description: {
+                header: "Description",
+            },
+            hostname: {
+                header: "Hostname",
+            },
+            status: {
+                header: "Status",
+                get: (row) => {
+                    if (!row.isReady) {
+                        return "pending";
+                    }
+                    return "ready";
+                },
+            },
+            characterSet: {
+                header: "Character Set",
+                get: (row) => row.characterSettings?.characterSet,
+                extended: true,
+            },
+            collation: {
+                header: "Collation",
+                get: (row) => row.characterSettings?.collation,
+                extended: true,
+            },
+            createdAt,
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+import { BaseCommand } from "../../../BaseCommand.js";
+export declare class PhpMyAdmin extends BaseCommand {
+    static summary: string;
+    static args: {
+        "database-id": import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+import { BaseCommand } from "../../../BaseCommand.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import open from "open";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+export class PhpMyAdmin extends BaseCommand {
+    static summary = "Open phpMyAdmin for a MySQL database.";
+    static args = { ...mysqlArgs };
+    async run() {
+        const { flags, args } = await this.parse(PhpMyAdmin);
+        const databaseId = await withMySQLId(this.apiClient, flags, args);
+        const users = await this.apiClient.database.listMysqlUsers({
+            mysqlDatabaseId: databaseId,
+        });
+        assertStatus(users, 200);
+        const mainUser = users.data.find((u) => u.mainUser);
+        if (!mainUser) {
+            throw new Error("no main user found.");
+        }
+        const pma = await this.apiClient.database.getMysqlUserPhpMyAdminUrl({
+            mysqlUserId: mainUser.id,
+        });
+        assertStatus(pma, 200);
+        await open(pma.data.url);
+    }
+}

package/dist/commands/database/mysql/port-forward.d.ts

@@ -0,0 +1,15 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class PortForward extends ExecRenderBaseCommand<typeof PortForward, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        port: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, 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>;
+    };
+    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;
+}

package/dist/commands/database/mysql/port-forward.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../../rendering/process/process_flags.js";
+import * as cp from "child_process";
+import { Text } from "ink";
+import { mysqlArgs, withMySQLId } from "../../../lib/database/mysql/flags.js";
+import { getConnectionDetails } from "../../../lib/database/mysql/connect.js";
+import { Value } from "../../../rendering/react/components/Value.js";
+import { Flags } from "@oclif/core";
+import { sshConnectionFlags } from "../../../lib/ssh/flags.js";
+export class PortForward extends ExecRenderBaseCommand {
+    static summary = "Forward the TCP port of a MySQL database to a local port";
+    static flags = {
+        ...processFlags,
+        ...sshConnectionFlags,
+        port: Flags.integer({
+            summary: "The local TCP port to forward to",
+            default: 3306,
+        }),
+    };
+    static args = { ...mysqlArgs };
+    async exec() {
+        const databaseId = await withMySQLId(this.apiClient, this.flags, this.args);
+        const p = makeProcessRenderer(this.flags, "Port-forwarding a MySQL database");
+        const { sshUser, sshHost, hostname, database } = await getConnectionDetails(this.apiClient, databaseId, this.flags["ssh-user"], p);
+        const { port } = this.flags;
+        p.complete(_jsxs(Text, { children: ["Forwarding MySQL database ", _jsx(Value, { children: database }), " to local port", " ", _jsx(Value, { children: port }), ". Use CTRL+C to cancel."] }));
+        const sshArgs = [
+            "-T",
+            "-L",
+            `${port}:${hostname}:3306`,
+            "-l",
+            sshUser,
+            sshHost,
+            "cat",
+            "/dev/zero",
+        ];
+        cp.spawnSync("ssh", sshArgs, {
+            stdio: ["ignore", process.stdout, process.stderr],
+        });
+        return {};
+    }
+    render() {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { ExecRenderBaseCommand } from "../../../rendering/react/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export declare class Shell extends ExecRenderBaseCommand<typeof Shell, Record<string, never>> {
+    static summary: string;
+    static flags: {
+        "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;
+}