@mittwald/cli 1.7.0 → 1.8.1

package/dist/commands/app/upgrade.js

@@ -12,6 +12,7 @@ import { waitUntilAppStateHasNormalized } from "../../lib/resources/app/wait.js"
 import { assertStatus } from "@mittwald/api-client-commons";
 import { waitFlags } from "../../lib/wait.js";
 import semver from "semver";
+import { validate as validateUuid } from "uuid";
 export class UpgradeApp extends ExecRenderBaseCommand {
     static description = "Upgrade app installation to target version";
     static args = {
@@ -39,7 +40,8 @@ export class UpgradeApp extends ExecRenderBaseCommand {
             ux.exit(1);
         }
         const currentAppVersion = await getAppVersionFromUuid(this.apiClient, currentApp.id, currentAppInstallation.appVersion.current);
-        if (targetAppVersionCandidates.length == 0) {
+        if (targetAppVersionCandidates.length == 0 &&
+            !validateUuid(this.flags["target-version"])) {
             process.complete(_jsxs(Text, { children: ["Your ", currentApp.name, " ", currentAppVersion.externalVersion, " is already Up-To-Date. \u2705"] }));
             return;
         }
@@ -121,6 +123,10 @@ export class UpgradeApp extends ExecRenderBaseCommand {
         if (targetAppVersionString == "latest") {
             return await getLatestAvailableTargetAppVersionForAppVersionUpgradeCandidates(this.apiClient, currentApp.id, currentAppVersion.id);
         }
+        if (validateUuid(targetAppVersionString) &&
+            typeof targetAppVersionString === "string") {
+            return await getAppVersionFromUuid(this.apiClient, currentApp.id, targetAppVersionString);
+        }
         if (targetAppVersionString) {
             const exactVersionMatch = targetAppVersionCandidates.find((v) => v.externalVersion === targetAppVersionString);
             if (exactVersionMatch) {

package/dist/commands/app/version-info.d.ts

@@ -0,0 +1,13 @@
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import React from "react";
+export declare class VersionInfo extends RenderBaseCommand<typeof VersionInfo> {
+    static description: string;
+    static summary: string;
+    static args: {
+        app: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        version: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected render(): React.ReactNode;
+    private getAppVersion;
+    private getApp;
+}

package/dist/commands/app/version-info.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
+import { Args } from "@oclif/core";
+import { assertStatus } from "@mittwald/api-client";
+import { usePromise } from "@mittwald/react-use-promise";
+import { Box, Text } from "ink";
+import { SingleResult, SingleResultTable, } from "../../rendering/react/components/SingleResult.js";
+import { Value } from "../../rendering/react/components/Value.js";
+export class VersionInfo extends RenderBaseCommand {
+    static description = "show information about specific app versions";
+    static summary = "This command shows information about a specific app version. It is useful to get information about the user inputs that are required for the version to be deployed successfully.";
+    static args = {
+        app: Args.string({
+            description: "name of the app",
+            required: true,
+        }),
+        version: Args.string({
+            description: "version of the app",
+            required: true,
+        }),
+    };
+    render() {
+        const { app, version } = this.args;
+        const appData = usePromise(this.getApp.bind(this), [app]);
+        const appVersionData = usePromise(this.getAppVersion.bind(this), [
+            appData,
+            version,
+        ]);
+        const sections = [
+            _jsx(AppVersionDetails, { app: appData, appVersion: appVersionData }, "details"),
+        ];
+        if (appVersionData.userInputs) {
+            sections.push(_jsx(UserInputTable, { appVersion: appVersionData }, "inputs"));
+        }
+        return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: sections }));
+    }
+    async getAppVersion(app, versionName) {
+        const appVersions = await this.apiClient.app.listAppversions({
+            appId: app.id,
+        });
+        assertStatus(appVersions, 200);
+        const version = appVersions.data.find((v) => v.externalVersion === versionName);
+        if (!version) {
+            throw new Error(`version ${this.args.version} not found`);
+        }
+        return version;
+    }
+    async getApp(appName) {
+        const appResult = await this.apiClient.app.listApps();
+        assertStatus(appResult, 200);
+        const app = appResult.data.find((a) => a.name.toLowerCase() === appName.toLowerCase());
+        if (!app) {
+            throw new Error(`app ${appName} not found`);
+        }
+        return app;
+    }
+}
+function UserInputValue({ input }) {
+    return (_jsxs(Text, { children: ["type=", _jsx(Value, { children: input.dataType }), input.defaultValue && (_jsxs(_Fragment, { children: [" ", "default=", _jsx(Value, { children: input.defaultValue })] }))] }));
+}
+function UserInputTable({ appVersion }) {
+    return (_jsx(SingleResult, { title: "USER INPUTS", rows: Object.fromEntries((appVersion.userInputs ?? []).map((u) => [
+            u.name,
+            _jsx(UserInputValue, { input: u }),
+        ])) }, "inputs"));
+}
+function AppVersionDetails({ app, appVersion, }) {
+    return (_jsx(SingleResult, { title: "APP VERSION DETAILS", rows: {
+            App: (_jsx(SingleResultTable, { rows: {
+                    UID: _jsx(Value, { children: app.id }),
+                    Name: _jsx(Value, { children: app.name }),
+                } })),
+            Version: (_jsx(SingleResultTable, { rows: {
+                    UID: _jsx(Value, { children: appVersion.id }),
+                    Version: _jsx(Value, { children: appVersion.externalVersion }),
+                } })),
+        } }, "details"));
+}

package/dist/commands/container/cp.d.ts

@@ -0,0 +1,23 @@
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { ReactNode } from "react";
+export default class Cp extends ExecRenderBaseCommand<typeof Cp, void> {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        source: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        dest: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        archive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        recursive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        "ssh-user": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "ssh-identity-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private parseContainerPath;
+    private buildScpCommand;
+    protected exec(): Promise<void>;
+    protected render(): ReactNode;
+}

package/dist/commands/container/cp.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as fs from "fs";
+import { Args, Flags } from "@oclif/core";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { getSSHConnectionForContainer } from "../../lib/resources/ssh/container.js";
+import { sshConnectionFlags } from "../../lib/resources/ssh/flags.js";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { spawnInProcess } from "../../rendering/process/process_exec.js";
+import { Success } from "../../rendering/react/components/Success.js";
+export default class Cp extends ExecRenderBaseCommand {
+    static summary = "Copy files/folders between a container and the local filesystem";
+    static description = `The syntax is similar to docker cp:
+- Copy from container to host: mw container cp CONTAINER:SRC_PATH DEST_PATH
+- Copy from host to container: mw container cp SRC_PATH CONTAINER:DEST_PATH
+
+Where CONTAINER can be a container ID, short ID, or service name.`;
+    static examples = [
+        "# Copy a file from container to current directory\n<%= config.bin %> <%= command.id %> mycontainer:/app/config.json .",
+        "# Copy a file from host to container\n<%= config.bin %> <%= command.id %> ./local-file.txt mycontainer:/app/",
+        "# Copy a directory recursively\n<%= config.bin %> <%= command.id %> mycontainer:/var/log ./logs",
+        "# Copy with archive mode (preserve permissions)\n<%= config.bin %> <%= command.id %> -a mycontainer:/app/data ./backup",
+    ];
+    static args = {
+        source: Args.string({
+            description: "Source path (either local path or CONTAINER:PATH)",
+            required: true,
+        }),
+        dest: Args.string({
+            description: "Destination path (either local path or CONTAINER:PATH)",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...processFlags,
+        ...sshConnectionFlags,
+        ...projectFlags,
+        archive: Flags.boolean({
+            char: "a",
+            summary: "archive mode (copy all uid/gid information)",
+            description: "Preserve file permissions and ownership when copying",
+        }),
+        recursive: Flags.boolean({
+            char: "r",
+            summary: "copy directories recursively",
+        }),
+    };
+    parseContainerPath(path) {
+        const colonIndex = path.indexOf(":");
+        if (colonIndex === -1) {
+            return { path };
+        }
+        const container = path.substring(0, colonIndex);
+        const containerPath = path.substring(colonIndex + 1);
+        // Ensure container path starts with / (absolute path)
+        const normalizedPath = containerPath.startsWith("/")
+            ? containerPath
+            : `/${containerPath}`;
+        return { container, path: normalizedPath };
+    }
+    buildScpCommand(source, dest, flags) {
+        const scpArgs = ["-o", "PasswordAuthentication=no"];
+        if (flags.archive) {
+            scpArgs.push("-p");
+        }
+        if (flags.recursive) {
+            scpArgs.push("-r");
+        }
+        scpArgs.push(source, dest);
+        return scpArgs;
+    }
+    async exec() {
+        const { args, flags } = await this.parse(Cp);
+        const sourceParsed = this.parseContainerPath(args.source);
+        const destParsed = this.parseContainerPath(args.dest);
+        // Validate that exactly one of source or dest is a container path
+        if (sourceParsed.container && destParsed.container) {
+            this.error("Cannot copy from container to container. One path must be local.");
+        }
+        if (!sourceParsed.container && !destParsed.container) {
+            this.error("At least one path must specify a container (CONTAINER:PATH format).");
+        }
+        const containerName = sourceParsed.container || destParsed.container;
+        const isDownload = !!sourceParsed.container;
+        const p = makeProcessRenderer(flags, `Copying files ${isDownload ? "from" : "to"} container`);
+        // Get container connection info
+        const [containerId, stackId] = await p.runStep("getting container connection info", async () => {
+            return withContainerAndStackId(this.apiClient, Cp, flags, { "container-id": containerName }, this.config);
+        });
+        const { host, user } = await p.runStep("establishing SSH connection", async () => {
+            return getSSHConnectionForContainer(this.apiClient, containerId, stackId, flags["ssh-user"]);
+        });
+        // Construct source and destination for SCP
+        let scpSource;
+        let scpDest;
+        if (isDownload) {
+            scpSource = `${user}@${host}:${sourceParsed.path}`;
+            scpDest = destParsed.path;
+        }
+        else {
+            scpSource = sourceParsed.path;
+            scpDest = `${user}@${host}:${destParsed.path}`;
+        }
+        // Automatically enable recursive for directories
+        const effectiveFlags = { ...flags };
+        if (!flags.recursive && !isDownload) {
+            try {
+                if (fs.existsSync(scpSource)) {
+                    const stats = fs.statSync(scpSource);
+                    if (stats.isDirectory()) {
+                        effectiveFlags.recursive = true;
+                    }
+                }
+            }
+            catch (ignored) {
+                // Ignore errors when checking if source is a directory
+            }
+        }
+        const scpCommand = this.buildScpCommand(scpSource, scpDest, effectiveFlags);
+        await spawnInProcess(p, `copying files ${isDownload ? "from" : "to"} container`, "/usr/bin/scp", scpCommand);
+        await p.complete(_jsx(CopySuccess, { isDownload: isDownload }));
+    }
+    render() {
+        return undefined;
+    }
+}
+function CopySuccess({ isDownload }) {
+    return (_jsxs(Success, { children: ["Files successfully ", isDownload ? "downloaded from" : "uploaded to", " ", "container! \uD83D\uDE80"] }));
+}

package/dist/commands/container/port-forward.js

@@ -45,7 +45,7 @@ export class PortForward extends ExecRenderBaseCommand {
                 .map((p) => ["-L", `${p.localPort}:localhost:${p.remotePort}`])
                 .flat(),
         });
-        cp.spawnSync("ssh", [...sshArgs, "cat", "/dev/zero"], {
+        cp.spawnSync("ssh", [...sshArgs, "sleep", "infinity"], {
             stdio: ["ignore", process.stdout, process.stderr],
         });
         return {};

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

@@ -33,7 +33,7 @@ export class PortForward extends ExecRenderBaseCommand {
             interactive: false,
             additionalFlags: ["-L", `${port}:${hostname}:3306`],
         });
-        cp.spawnSync("ssh", [...sshArgs, "cat", "/dev/zero"], {
+        cp.spawnSync("ssh", [...sshArgs, "sleep", "infinity"], {
             stdio: ["ignore", process.stdout, process.stderr],
         });
         return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {
@@ -68,7 +68,7 @@
     "semver-parser": "^4.1.6",
     "shell-escape": "^0.2.0",
     "slice-ansi": "^7.1.0",
-    "string-width": "^7.2.0",
+    "string-width": "^8.0.0",
     "tempfile": "^5.0.0",
     "uuid": "^11.0.3"
   },
@@ -94,7 +94,7 @@
     "oclif": "^4.14.31",
     "prettier": "~3.6.2",
     "prettier-plugin-jsdoc": "^1.3.2",
-    "prettier-plugin-package": "^1.4.0",
+    "prettier-plugin-package": "^2.0.0",
     "prettier-plugin-sort-json": "^4.1.1",
     "rimraf": "^5.0.1",
     "ts-jest": "^29.2.5",