@mittwald/cli 1.0.0-alpha.32 → 1.0.0-alpha.33

package/dist/esm/lib/hasbin.d.ts

@@ -0,0 +1 @@
+export declare function hasBinary(name: string): Promise<boolean>;

package/dist/esm/lib/hasbin.js

@@ -0,0 +1,17 @@
+import path from "path";
+import fs from "fs";
+export async function hasBinary(name) {
+    const p = process.env.PATH ?? "";
+    const pathItems = p.split(path.delimiter);
+    for (const item of pathItems) {
+        const fullPath = path.join(item, name);
+        try {
+            fs.statSync(fullPath);
+            return true;
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    return false;
+}

package/dist/esm/lib/ssh/appinstall.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SSHConnectionData } from "./types.js";
+export declare function getSSHConnectionForAppInstallation(client: MittwaldAPIV2Client, appInstallationId: string): Promise<SSHConnectionData>;

package/dist/esm/lib/ssh/appinstall.js

@@ -0,0 +1,25 @@
+import { assertStatus } from "@mittwald/api-client";
+import path from "path";
+export async function getSSHConnectionForAppInstallation(client, appInstallationId) {
+    const appInstallationResponse = await client.app.getAppinstallation({
+        appInstallationId,
+    });
+    assertStatus(appInstallationResponse, 200);
+    if (appInstallationResponse.data.projectId === undefined) {
+        throw new Error("Project ID of app must not be undefined");
+    }
+    const projectResponse = await client.project.getProject({
+        projectId: appInstallationResponse.data.projectId,
+    });
+    assertStatus(projectResponse, 200);
+    const userResponse = await client.user.getOwnAccount();
+    assertStatus(userResponse, 200);
+    const host = `ssh.${projectResponse.data.clusterID}.${projectResponse.data.clusterDomain}`;
+    const user = `${userResponse.data.email}@${appInstallationResponse.data.shortId}`;
+    const directory = path.join(projectResponse.data.directories["Web"], appInstallationResponse.data.installationPath);
+    return {
+        host,
+        user,
+        directory,
+    };
+}

package/dist/esm/lib/ssh/exec.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export type RunTarget = {
+    appInstallationId: string;
+} | {
+    projectId: string;
+};
+export declare function executeViaSSH(client: MittwaldAPIV2Client, target: RunTarget, command: string, args: string[], output: NodeJS.WritableStream): Promise<void>;

package/dist/esm/lib/ssh/exec.js

@@ -0,0 +1,41 @@
+import cp from "child_process";
+import { getSSHConnectionForAppInstallation } from "./appinstall.js";
+import { getSSHConnectionForProject } from "./project.js";
+export async function executeViaSSH(client, target, command, args, output) {
+    const { user, host } = await connectionDataForTarget(client, target);
+    const sshArgs = ["-l", user, "-T", host, command, ...args];
+    const ssh = cp.spawn("ssh", sshArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let err = "";
+    ssh.stdout.pipe(output);
+    ssh.stderr.on("data", (data) => {
+        err += data.toString();
+    });
+    await new Promise((res, rej) => {
+        ssh.on("exit", (code) => {
+            const resolve = () => {
+                if (code === 0) {
+                    res(undefined);
+                }
+                else {
+                    rej(new Error(`ssh+${command} exited with code ${code}\n${err}`));
+                }
+            };
+            if (output === process.stdout) {
+                resolve();
+            }
+            else {
+                output.end(resolve);
+            }
+        });
+    });
+}
+async function connectionDataForTarget(client, target) {
+    if ("appInstallationId" in target) {
+        return getSSHConnectionForAppInstallation(client, target.appInstallationId);
+    }
+    else {
+        return getSSHConnectionForProject(client, target.projectId);
+    }
+}

package/dist/esm/lib/ssh/project.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { SSHConnectionData } from "./types.js";
+export declare function getSSHConnectionForProject(client: MittwaldAPIV2Client, projectId: string): Promise<SSHConnectionData>;

package/dist/esm/lib/ssh/project.js

@@ -0,0 +1,15 @@
+import { assertStatus } from "@mittwald/api-client";
+export async function getSSHConnectionForProject(client, projectId) {
+    const projectResponse = await client.project.getProject({ projectId });
+    assertStatus(projectResponse, 200);
+    const userResponse = await client.user.getOwnAccount();
+    assertStatus(userResponse, 200);
+    const host = `ssh.${projectResponse.data.clusterID}.${projectResponse.data.clusterDomain}`;
+    const user = `${userResponse.data.email}@${projectResponse.data.shortId}`;
+    const directory = projectResponse.data.directories["Web"];
+    return {
+        host,
+        user,
+        directory,
+    };
+}

package/dist/esm/lib/ssh/types.d.ts

@@ -0,0 +1,5 @@
+export interface SSHConnectionData {
+    host: string;
+    user: string;
+    directory: string;
+}

package/dist/esm/lib/ssh/types.js

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

package/dist/esm/rendering/process/components/ProcessState.js

@@ -4,5 +4,5 @@ import { ProcessStateSummary } from "./ProcessStateSummary.js";
 import { ProcessError } from "./ProcessError.js";
 import { Box, Text } from "ink";
 export const ProcessState = ({ step }) => {
-    return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsx(Text, { children: step.title }), _jsx(ProcessStateSummary, { step: step })] }), step.type === "step" && step.error ? (_jsx(ProcessError, { err: step.error })) : null] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(Box, { marginX: 2, children: [_jsx(ProcessStateIcon, { step: step }), _jsx(Text, { children: step.title }), _jsx(ProcessStateSummary, { step: step })] }), step.type === "step" && step.output ? (_jsx(Box, { marginX: 6, children: _jsx(Text, { color: "gray", children: step.output.split("\n").slice(-10).join("\n") }) })) : null, step.type === "step" && step.error ? (_jsx(ProcessError, { err: step.error })) : null] }));
 };

package/dist/esm/rendering/process/process.d.ts

@@ -9,6 +9,7 @@ export type ProcessStepRunnable = {
     phase: "running" | "completed" | "failed" | "aborted";
     error?: unknown;
     progress?: string;
+    output?: string;
 };
 export type ProcessStepConfirm = {
     type: "confirm";
@@ -22,14 +23,23 @@ export type ProcessStepInput = {
     value?: string;
 };
 export type ProcessStep = ProcessStepInfo | ProcessStepRunnable | ProcessStepConfirm | ProcessStepInput;
+export type CleanupFunction = {
+    title: ReactNode;
+    fn: () => Promise<unknown>;
+};
 export declare class RunnableHandler {
     private readonly listener;
     private readonly processStep;
+    private readonly promise;
+    private resolve;
+    private reject;
     constructor(state: ProcessStepRunnable, l: () => void);
     get done(): boolean;
+    wait(): Promise<void>;
     abort(): void;
     complete(): void;
     progress(p: string): void;
+    appendOutput(o: string): void;
     error(err: unknown): void;
 }
 export interface ProcessRenderer {
@@ -39,6 +49,7 @@ export interface ProcessRenderer {
     addInfo(title: ReactElement): void;
     addConfirmation(question: ReactElement): Promise<boolean>;
     addInput(question: ReactNode, mask?: boolean): Promise<string>;
-    complete(summary: ReactElement): void;
-    error(err: unknown): void;
+    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    complete(summary: ReactElement): Promise<void>;
+    error(err: unknown): Promise<void>;
 }

package/dist/esm/rendering/process/process.js

@@ -1,28 +1,46 @@
 export class RunnableHandler {
     listener;
     processStep;
+    promise;
+    resolve = () => { };
+    reject = () => { };
     constructor(state, l) {
         this.processStep = state;
         this.listener = l;
+        this.promise = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+        this.promise.catch(() => { });
     }
     get done() {
         return this.processStep.phase !== "running";
     }
+    wait() {
+        return this.promise;
+    }
     abort() {
         this.processStep.phase = "aborted";
         this.listener();
+        this.resolve();
     }
     complete() {
         this.processStep.phase = "completed";
         this.listener();
+        this.resolve();
     }
     progress(p) {
         this.processStep.progress = p;
         this.listener();
     }
+    appendOutput(o) {
+        this.processStep.output += o;
+        this.listener();
+    }
     error(err) {
         this.processStep.phase = "failed";
         this.processStep.error = err;
         this.listener();
+        this.reject(err);
     }
 }

package/dist/esm/rendering/process/process_fancy.d.ts

@@ -4,6 +4,7 @@ export declare class FancyProcessRenderer implements ProcessRenderer {
     private readonly title;
     private started;
     private currentHandler;
+    private cleanupFns;
     constructor(title: string);
     start(): void;
     addStep(title: ReactNode): RunnableHandler;
@@ -11,7 +12,9 @@ export declare class FancyProcessRenderer implements ProcessRenderer {
     addInfo(title: ReactElement): void;
     addInput(question: React.ReactElement, mask?: boolean): Promise<string>;
     addConfirmation(question: ReactElement): Promise<boolean>;
-    complete(summary: ReactElement): void;
-    error(err: unknown): void;
+    complete(summary: ReactElement): Promise<void>;
+    error(err: unknown): Promise<void>;
     private renderStart;
+    addCleanup(title: ReactNode, fn: () => Promise<unknown>): void;
+    private cleanup;
 }

package/dist/esm/rendering/process/process_fancy.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { RunnableHandler } from "./process.js";
+import { RunnableHandler, } from "./process.js";
 import { Header } from "../react/components/Header.js";
 import { Box, render, Text } from "ink";
 import { ProcessState } from "./components/ProcessState.js";
@@ -9,6 +9,7 @@ export class FancyProcessRenderer {
     title;
     started = false;
     currentHandler = null;
+    cleanupFns = [];
     constructor(title) {
         this.title = title;
     }
@@ -43,7 +44,7 @@ export class FancyProcessRenderer {
             return result;
         }
         catch (err) {
-            step.error(err);
+            await this.error(err);
             throw err;
         }
     }
@@ -99,21 +100,37 @@ export class FancyProcessRenderer {
             const renderHandle = render(_jsx(ProcessConfirmation, { step: state, onConfirm: onConfirm }));
         });
     }
-    complete(summary) {
+    async complete(summary) {
         if (this.currentHandler) {
             this.currentHandler.complete();
         }
+        await this.cleanup();
         render(_jsx(Box, { marginY: 1, marginX: 2, children: summary })).unmount();
     }
-    error(err) {
+    async error(err) {
         if (this.currentHandler) {
             this.currentHandler.error(err);
+            await this.cleanup();
         }
         else {
+            await this.cleanup();
             render(_jsx(Box, { marginY: 1, marginX: 2, borderStyle: "round", borderColor: "red", children: _jsxs(Text, { color: "red", children: ["Error: ", err?.toString()] }) })).unmount();
         }
     }
     renderStart() {
         return (_jsx(Box, { marginY: 1, marginX: 2, children: _jsx(Header, { title: this.title }) }));
     }
+    addCleanup(title, fn) {
+        this.cleanupFns.push({ title, fn });
+    }
+    async cleanup() {
+        if (this.cleanupFns.length === 0) {
+            return;
+        }
+        for (const { title, fn } of this.cleanupFns) {
+            await this.runStep(title, async () => {
+                await fn();
+            });
+        }
+    }
 }

package/dist/esm/rendering/process/process_quiet.d.ts

@@ -1,12 +1,15 @@
 import { ReactNode } from "react";
 import { ProcessRenderer, RunnableHandler } from "./process.js";
 export declare class SilentProcessRenderer implements ProcessRenderer {
+    private cleanupFns;
     start(): void;
     addStep(title: ReactNode): RunnableHandler;
     runStep<TRes>(unusedTitle: ReactNode, fn: () => Promise<TRes>): Promise<TRes>;
     addInfo(): void;
-    complete(): void;
-    error(err: unknown): void;
+    complete(): Promise<void>;
+    error(err: unknown): Promise<void>;
     addConfirmation(): Promise<boolean>;
     addInput(): Promise<string>;
+    addCleanup(_: ReactNode, fn: () => Promise<unknown>): void;
+    private cleanup;
 }

package/dist/esm/rendering/process/process_quiet.js

@@ -1,5 +1,7 @@
 import { RunnableHandler } from "./process.js";
+import * as console from "console";
 export class SilentProcessRenderer {
+    cleanupFns = [];
     start() {
         // 🤐
     }
@@ -14,11 +16,12 @@ export class SilentProcessRenderer {
     addInfo() {
         // 🤐
     }
-    complete() {
-        // 🤐
+    async complete() {
+        await this.cleanup();
     }
     error(err) {
         console.error(err);
+        return Promise.resolve();
     }
     addConfirmation() {
         return Promise.resolve(true);
@@ -26,4 +29,12 @@ export class SilentProcessRenderer {
     addInput() {
         throw new Error("no interactive input available in quiet mode");
     }
+    addCleanup(_, fn) {
+        this.cleanupFns.push(fn);
+    }
+    async cleanup() {
+        for (const fn of this.cleanupFns) {
+            await fn();
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.0.0-alpha.32",
+  "version": "1.0.0-alpha.33",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {