bdy 1.18.24-dev → 1.18.24-dev-pipeline

package/distTs/src/output/pipeline.js

@@ -0,0 +1,915 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_1 = __importDefault(require("../output"));
+const pipeline_1 = require("../types/pipeline");
+const utils_1 = require("../utils");
+// @ts-ignore
+const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
+class OutputPipeline {
+    static async runStatus(client, workspace, project, pipelineId, runId, noWait) {
+        if (output_1.default.isTTY() && !noWait) {
+            return await this._runStatusInteractive(client, workspace, project, pipelineId, runId);
+        }
+        return await this._runStatusNonInteractive(client, workspace, project, pipelineId, runId, noWait);
+    }
+    static _fillString(str, length) {
+        if (str.length >= length - 1)
+            return str.substring(0, length - 1) + ' ';
+        for (let i = str.length; i < length; i += 1)
+            str += ' ';
+        return str;
+    }
+    static _formatDate(date) {
+        let str = `${date.getFullYear()}-`;
+        const m = date.getMonth() + 1;
+        if (m < 10)
+            str += '0';
+        str += `${m}-`;
+        const d = date.getDate();
+        if (d < 10)
+            str += '0';
+        str += `${d} `;
+        const h = date.getHours();
+        if (h < 10)
+            str += '0';
+        str += `${h}:`;
+        const mm = date.getMinutes();
+        if (mm < 10)
+            str += '0';
+        str += `${mm}:`;
+        const s = date.getSeconds();
+        if (s < 10)
+            str += '0';
+        str += s;
+        return str;
+    }
+    static _formatTimespan(start, end) {
+        if (!end)
+            end = new Date();
+        let ts = Math.abs(end.getTime() - start.getTime());
+        if (!ts)
+            return '';
+        const hours = Math.floor(ts / 1000 / 60 / 60);
+        ts -= hours * 60 * 60 * 1000;
+        const minutes = Math.floor(ts / 1000 / 60);
+        ts -= minutes * 60 * 1000;
+        const seconds = Math.ceil(ts / 1000);
+        let str = '';
+        if (hours > 0)
+            str += `${hours}h `;
+        if (minutes > 0 || hours > 0)
+            str += `${minutes}m `;
+        if (seconds < 10 && (hours > 0 || minutes > 0))
+            str += '0';
+        str += `${seconds}s`;
+        return str;
+    }
+    static _runDetailsHeader() {
+        return `${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor('DETAILS')}`;
+    }
+    static _runLogsHeader() {
+        return `${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor('LOGS')}`;
+    }
+    static _runDetailsStarted(status, started, delayed = null, tabs = 25) {
+        if (delayed && status === pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED) {
+            let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Scheduled', tabs))}`;
+            str += output_1.default.getTermKitMutedColor(this._formatDate(delayed || new Date()));
+            return str;
+        }
+        if ([
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATING,
+            pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL,
+            pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+            pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION,
+        ].includes(status)) {
+            let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Started', tabs))}`;
+            str += output_1.default.getTermKitMutedColor(this._formatDate(started || new Date()));
+            return str;
+        }
+        return null;
+    }
+    static _runActionsHeader(tabs = 25) {
+        return `${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor(this._fillString('ACTIONS', tabs + 40))} ${output_1.default.getTermKitLabelColor('ID')}`;
+    }
+    static _actionLogs(action, limit = 0) {
+        const str = [];
+        if (action.logs && action.logs.length > 0) {
+            let start = action.logs.length - limit;
+            if (start < 0)
+                start = 0;
+            let end = start + limit;
+            if (end > action.logs.length)
+                end = action.logs.length;
+            for (let i = start; i < end; i += 1) {
+                str.push(`  ${output_1.default.getTermKitDimColor(action.logs[i])}`);
+            }
+        }
+        else {
+            str.push(`  ${output_1.default.getTermKitDimColor('Waiting...')}`);
+        }
+        return str;
+    }
+    static _runActions(run, onlyChanged = false, limit = 0, selected = -1, tabs = 25) {
+        const str = [];
+        if (!run)
+            return str;
+        if (!onlyChanged) {
+            str.push(this._runActionsHeader(tabs));
+        }
+        let count = 0;
+        let start = 0;
+        if (selected >= limit / 2) {
+            start = selected - limit / 2;
+            if (start + limit >= run.actions.length) {
+                start = run.actions.length - limit;
+            }
+        }
+        for (let i = start; i < run.actions.length; i += 1) {
+            const a = run.actions[i];
+            if (!a || (onlyChanged && !a.changed))
+                continue;
+            let s = '';
+            const highlight = i === selected;
+            if (highlight) {
+                s += output_1.default.getTermKitCyanColor('❯ ');
+                s += output_1.default.getTermKitCyanColor(this._fillString(a.type, tabs));
+            }
+            else {
+                s += '  ';
+                s += output_1.default.getTermKitDimColor(this._fillString(a.type, tabs));
+            }
+            const name = this._fillString(a.name || '', 41);
+            if (highlight) {
+                s += output_1.default.getTermKitCyanColor(name);
+            }
+            else if ([
+                pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS,
+                pipeline_1.PIPELINE_RUN_STATUS.TERMINATING,
+            ].includes(a.status)) {
+                s += output_1.default.getTermKitBlueColor(name);
+            }
+            else if ([
+                pipeline_1.PIPELINE_RUN_STATUS.INITIAL,
+                pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED,
+                pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED,
+                pipeline_1.PIPELINE_RUN_STATUS.SKIPPED,
+            ].includes(a.status)) {
+                s += output_1.default.getTermKitDimColor(name);
+            }
+            else {
+                s += output_1.default.getTermKitMutedColor(name);
+            }
+            if (![
+                pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED,
+                pipeline_1.PIPELINE_RUN_STATUS.INITIAL,
+                pipeline_1.PIPELINE_RUN_STATUS.SKIPPED,
+                pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED,
+            ].includes(a.status)) {
+                if (highlight) {
+                    s += output_1.default.getTermKitCyanColor(this._fillString(a.id, 25));
+                }
+                else {
+                    s += output_1.default.getTermKitDimColor(this._fillString(a.id, 25));
+                }
+            }
+            else {
+                s += this._fillString('', 25);
+            }
+            let ts = false;
+            if (a.status === pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS) {
+                if (onlyChanged) {
+                    s += output_1.default.getTermKitBlueColor(pipeline_1.PIPELINE_STATUS_ICONS.INPROGRESS);
+                }
+                else {
+                    s += output_1.default.getTermKitBlueColor(this._statusAnimationString());
+                }
+                ts = true;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED) {
+                s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.ENQUEUED);
+                s += ` ${output_1.default.getTermKitDimColor('Enqueued')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATED) {
+                s += output_1.default.getTermKitRedColor(pipeline_1.PIPELINE_STATUS_ICONS.TERMINATED);
+                ts = true;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL) {
+                s += output_1.default.getTermKitGreenColor(pipeline_1.PIPELINE_STATUS_ICONS.SUCCESSFUL);
+                ts = true;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.FAILED) {
+                s += output_1.default.getTermKitRedColor(pipeline_1.PIPELINE_STATUS_ICONS.FAILED);
+                ts = true;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.INITIAL) {
+                s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.INITIAL);
+                s += ` ${output_1.default.getTermKitDimColor('Created')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED) {
+                s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.NOT_EXECUTED);
+                s += ` ${output_1.default.getTermKitDimColor('Created')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.SKIPPED) {
+                s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.SKIPPED);
+                s += ` ${output_1.default.getTermKitDimColor('Skipped')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATING) {
+                if (onlyChanged) {
+                    s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.TERMINATING);
+                }
+                else {
+                    s += output_1.default.getTermKitBlueColor(this._statusAnimationString());
+                }
+                ts = true;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY) {
+                s += output_1.default.getTermKitPurpleColor(pipeline_1.PIPELINE_STATUS_ICONS.WAITING_FOR_APPLY);
+                s += ` ${output_1.default.getTermKitPurpleColor('Waiting')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES) {
+                s += output_1.default.getTermKitPurpleColor(pipeline_1.PIPELINE_STATUS_ICONS.WAITING_FOR_VARIABLES);
+                s += ` ${output_1.default.getTermKitPurpleColor('Waiting')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES) {
+                s += output_1.default.getTermKitPurpleColor(pipeline_1.PIPELINE_STATUS_ICONS.WAITING_FOR_SETTABLE_VARIABLES);
+                s += ` ${output_1.default.getTermKitPurpleColor('Waiting')}`;
+            }
+            else if (a.status === pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION) {
+                s += output_1.default.getTermKitPurpleColor(pipeline_1.PIPELINE_STATUS_ICONS.WAITING_FOR_VT_SESSION);
+                s += ` ${output_1.default.getTermKitPurpleColor('Waiting')}`;
+            }
+            else {
+                s += output_1.default.getTermKitDimColor(pipeline_1.PIPELINE_STATUS_ICONS.SKIPPED);
+                s += ` ${output_1.default.getTermKitDimColor(a.status)}`;
+            }
+            if (ts && a.started) {
+                s += ` ${output_1.default.getTermKitMutedColor(this._formatTimespan(a.started, a.finished))}`;
+            }
+            str.push(s);
+            count += 1;
+            if (limit && count >= limit)
+                break;
+        }
+        return str;
+    }
+    static _runContext(run, tabs = 25) {
+        const str = [];
+        if (run?.context) {
+            str.push(`${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor('CONTEXT')}`);
+            const ctx = run.context;
+            Object.keys(ctx).forEach((name) => {
+                str.push(`  ${output_1.default.getTermKitDimColor(this._fillString(name, tabs))}${output_1.default.getTermKitMutedColor(ctx[name])}`);
+            });
+        }
+        return str;
+    }
+    static _runDetailsFinished(status, finished, tabs = 25) {
+        if (finished &&
+            [
+                pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+                pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL,
+                pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            ].includes(status)) {
+            let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Finished', tabs))}`;
+            str += output_1.default.getTermKitMutedColor(this._formatDate(finished));
+            return str;
+        }
+        return null;
+    }
+    static _runDetailsTriggerer(run, tabs = 25) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Triggerer', tabs))}`;
+        str += output_1.default.getTermKitMutedColor(run?.creator || 'Unknown');
+        return str;
+    }
+    static _runDetailsDescription(run, tabs = 25) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Description', tabs))}`;
+        str += output_1.default.getTermKitMutedColor(run?.description || '');
+        return str;
+    }
+    static _statusAnimationIndex = 0;
+    static _statusAnimationTs;
+    static _statusAnimationString() {
+        const opts = pipeline_1.PIPELINE_STATUS_PROGRESS_ANIMATION;
+        if (!this._statusAnimationTs) {
+            this._statusAnimationTs = setInterval(() => {
+                this._statusAnimationIndex += 1;
+                if (this._statusAnimationIndex > opts.length - 1)
+                    this._statusAnimationIndex = 0;
+            }, 100);
+        }
+        return opts[this._statusAnimationIndex];
+    }
+    static _runDetailsTrigger(run, tabs = 25) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Trigger', tabs))}`;
+        if (!run || run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.CLICK) {
+            str += output_1.default.getTermKitMutedColor('Manual');
+        }
+        else if (run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.SCHEDULE) {
+            str += output_1.default.getTermKitMutedColor('Schedule');
+        }
+        else if (run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.EVENT) {
+            str += output_1.default.getTermKitMutedColor('Event');
+        }
+        else if (run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.PIPELINE) {
+            str += output_1.default.getTermKitMutedColor('Pipeline');
+        }
+        else if (run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.WEBHOOK) {
+            str += output_1.default.getTermKitMutedColor('Webhook');
+        }
+        else if (run.trigger === pipeline_1.PIPELINE_RUN_TRIGGER.EMAIL) {
+            str += output_1.default.getTermKitMutedColor('Email');
+        }
+        else {
+            str += run.trigger;
+        }
+        if (run?.priority === pipeline_1.PIPELINE_PRIORITY.HIGH) {
+            str += output_1.default.getTermKitMutedColor(', high');
+        }
+        else if (run?.priority === pipeline_1.PIPELINE_PRIORITY.LOW) {
+            str += output_1.default.getTermKitMutedColor(', low');
+        }
+        if (run?.refresh) {
+            str += output_1.default.getTermKitMutedColor(', from scratch');
+        }
+        if (run?.clearCache) {
+            str += output_1.default.getTermKitMutedColor(', clear cache');
+        }
+        return str;
+    }
+    static _runDetailsStatus(status, started, finished, tabs = 25) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Status', tabs))}`;
+        let ts = false;
+        if (status === pipeline_1.PIPELINE_RUN_STATUS.INITIAL) {
+            str += output_1.default.getTermKitMutedColor('Created');
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS) {
+            str += output_1.default.getTermKitBlueColor('Running');
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED) {
+            str += output_1.default.getTermKitMutedColor('Queued');
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATED) {
+            str += output_1.default.getTermKitRedColor('Canceled');
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL) {
+            str += output_1.default.getTermKitGreenColor('Passed');
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.FAILED) {
+            str += output_1.default.getTermKitRedColor('Failed');
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED) {
+            str += output_1.default.getTermKitMutedColor('Created');
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SKIPPED) {
+            str += output_1.default.getTermKitMutedColor('Skipped');
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATING) {
+            str += output_1.default.getTermKitBlueColor('Canceling');
+            ts = true;
+        }
+        else if ([
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VT_SESSION,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_SETTABLE_VARIABLES,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_VARIABLES,
+            pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY,
+        ].includes(status)) {
+            str += output_1.default.getTermKitPurpleColor('Awaiting');
+        }
+        else {
+            str += output_1.default.getTermKitMutedColor(status);
+        }
+        if (ts && started) {
+            str += ` ${output_1.default.getTermKitDimColor(this._formatTimespan(started, finished))}`;
+        }
+        return str;
+    }
+    static _runInteractiveHelp() {
+        let help = output_1.default.getTermKitLabelColor('↑↓');
+        help += output_1.default.getTermKitDimColor(' navigate •');
+        help += output_1.default.getTermKitLabelColor(' ⏎');
+        help += output_1.default.getTermKitDimColor(' view logs •');
+        help += output_1.default.getTermKitLabelColor(' esc');
+        help += output_1.default.getTermKitDimColor(' exit');
+        return help;
+    }
+    static _actionInteractiveHelp() {
+        let help = output_1.default.getTermKitLabelColor(' esc');
+        help += output_1.default.getTermKitDimColor(' exit');
+        return help;
+    }
+    static _drawInteractiveAction(action, viewPort) {
+        viewPort.fill({
+            char: ' ',
+        });
+        if (action) {
+            let y = 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsHeader());
+            y += 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsStatus(action.status, action.started, action.finished));
+            const started = this._runDetailsStarted(action.status, action.started);
+            if (started) {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, started);
+            }
+            const finished = this._runDetailsFinished(action.status, action.finished);
+            if (finished) {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, finished);
+            }
+            y += 2;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runLogsHeader());
+            let logsLimit = termkit_no_lazy_require_1.default.terminal.height - y - 5;
+            if (logsLimit < 2)
+                logsLimit = 2;
+            const logs = this._actionLogs(action, logsLimit);
+            logs.forEach((str) => {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, str);
+            });
+            y += 2;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._actionInteractiveHelp());
+        }
+        viewPort.draw();
+    }
+    static _drawInteractiveRun(run, viewPort, opts) {
+        viewPort.fill({
+            char: ' ',
+        });
+        if (run) {
+            let y = 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsHeader());
+            y += 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsStatus(run.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL, run.started, run.finished));
+            y += 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsTrigger(run));
+            y += 1;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runDetailsTriggerer(run));
+            if (run.description) {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, this._runDetailsDescription(run));
+            }
+            const started = this._runDetailsStarted(run.status, run.started, run.delayed);
+            if (started) {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, started);
+            }
+            const finished = this._runDetailsFinished(run.status, run.finished);
+            if (finished) {
+                y += 1;
+                viewPort.put({
+                    x: 1,
+                    y,
+                    markup: true,
+                }, finished);
+            }
+            const context = this._runContext(run);
+            if (context.length > 0) {
+                y += 1;
+                context.forEach((str) => {
+                    y += 1;
+                    viewPort.put({
+                        x: 1,
+                        y,
+                        markup: true,
+                    }, str);
+                });
+            }
+            let actionsLimit = termkit_no_lazy_require_1.default.terminal.height - y - 5;
+            if (actionsLimit < 2)
+                actionsLimit = 2;
+            if (opts.selectedActionIndex >= (run?.actions.length || actionsLimit)) {
+                opts.selectedActionIndex = run.actions.length - 1;
+            }
+            const actions = this._runActions(run, false, actionsLimit, opts.selectedActionIndex);
+            if (actions.length > 0) {
+                y += 1;
+                actions.forEach((str) => {
+                    y += 1;
+                    viewPort.put({
+                        x: 1,
+                        y,
+                        markup: true,
+                    }, str);
+                });
+            }
+            y += 2;
+            viewPort.put({
+                x: 1,
+                y,
+                markup: true,
+            }, this._runInteractiveHelp());
+        }
+        viewPort.draw();
+    }
+    static async _runStatusInteractive(client, workspace, project, pipelineId, runId) {
+        const MODE_RUN = 'run';
+        const MODE_ACTION = 'action';
+        let mode = MODE_RUN;
+        let run = null;
+        let action = null;
+        let cancelActionFetch = () => { };
+        let selectedActionId = null;
+        const opts = {
+            selectedActionIndex: -1,
+        };
+        const viewPort = new termkit_no_lazy_require_1.default.ScreenBuffer({
+            dst: termkit_no_lazy_require_1.default.terminal,
+            width: Math.min(termkit_no_lazy_require_1.default.terminal.width),
+            height: Math.min(termkit_no_lazy_require_1.default.terminal.height),
+            x: 1,
+            y: 1,
+        });
+        const draw = () => {
+            if (mode === MODE_RUN) {
+                this._drawInteractiveRun(run, viewPort, opts);
+            }
+            else {
+                this._drawInteractiveAction(action, viewPort);
+            }
+        };
+        const exit = () => {
+            termkit_no_lazy_require_1.default.terminal.fullscreen(false);
+            termkit_no_lazy_require_1.default.terminal.hideCursor(false);
+            termkit_no_lazy_require_1.default.terminal.grabInput(false);
+            process.exit();
+        };
+        termkit_no_lazy_require_1.default.terminal.grabInput();
+        termkit_no_lazy_require_1.default.terminal.hideCursor();
+        termkit_no_lazy_require_1.default.terminal.fullscreen(true);
+        termkit_no_lazy_require_1.default.terminal.on('key', (name) => {
+            if (name === 'CTRL_C') {
+                exit();
+            }
+            else if (name === 'ESCAPE') {
+                if (mode === MODE_RUN) {
+                    exit();
+                }
+                else {
+                    selectedActionId = null;
+                    action = null;
+                    cancelActionFetch();
+                    mode = MODE_RUN;
+                    draw();
+                }
+            }
+            else if (name === 'DOWN') {
+                if (mode === MODE_RUN) {
+                    opts.selectedActionIndex += 1;
+                    draw();
+                }
+            }
+            else if (name === 'UP') {
+                if (mode === MODE_RUN) {
+                    opts.selectedActionIndex -= 1;
+                    if (opts.selectedActionIndex < 0)
+                        opts.selectedActionIndex = -1;
+                    draw();
+                }
+            }
+            else if (name === 'ENTER') {
+                if (mode === MODE_RUN && run && run.actions[opts.selectedActionIndex]) {
+                    selectedActionId = run.actions[opts.selectedActionIndex].id;
+                    mode = MODE_ACTION;
+                    this._actionStatusLoop(client, workspace, project, pipelineId, runId, selectedActionId, (a, cancel) => {
+                        if (cancel)
+                            cancelActionFetch = cancel;
+                        if (a && selectedActionId === a.id)
+                            action = a;
+                        draw();
+                    });
+                    draw();
+                }
+            }
+        });
+        termkit_no_lazy_require_1.default.terminal.on('resize', () => {
+            opts.selectedActionIndex = -1;
+            viewPort.resize({
+                width: Math.min(termkit_no_lazy_require_1.default.terminal.width),
+                height: Math.min(termkit_no_lazy_require_1.default.terminal.height),
+                x: 1,
+                y: 1,
+            });
+            draw();
+        });
+        setInterval(() => draw(), 100);
+        draw();
+        await this._runStatusLoop(client, workspace, project, pipelineId, runId, (r) => {
+            run = r;
+            draw();
+        });
+    }
+    static async _runStatusNonInteractive(client, workspace, project, pipelineId, runId, noWait) {
+        let run = null;
+        let totalFetchesCount = 0;
+        const draw = (r) => {
+            if (!run) {
+                output_1.default.normal(this._runDetailsHeader());
+                output_1.default.normal(this._runDetailsStatus(r.status, r.started, r.finished));
+                output_1.default.normal(this._runDetailsTrigger(r));
+                output_1.default.normal(this._runDetailsTriggerer(r));
+                if (r?.description)
+                    output_1.default.normal(this._runDetailsDescription(r));
+                const started = this._runDetailsStarted(r.status, r.started, r.delayed);
+                if (started)
+                    output_1.default.normal(started);
+                const finished = this._runDetailsFinished(r.status, r.finished);
+                if (finished)
+                    output_1.default.normal(finished);
+                output_1.default.normal('');
+                const context = this._runContext(r);
+                if (context) {
+                    context.forEach((str) => {
+                        output_1.default.normal(str);
+                    });
+                }
+                output_1.default.normal('');
+                output_1.default.normal(this._runActionsHeader());
+            }
+            const actions = this._runActions(r, true);
+            actions.forEach((str) => {
+                output_1.default.normal(str);
+            });
+            run = r;
+        };
+        run = await this._runStatusLoop(client, workspace, project, pipelineId, runId, (run) => {
+            totalFetchesCount += 1;
+            draw(run);
+            if (noWait) {
+                output_1.default.exitNormal();
+            }
+        });
+        if (totalFetchesCount > 1) {
+            output_1.default.normal('');
+            output_1.default.normal(this._runDetailsHeader());
+            output_1.default.normal(this._runDetailsStatus(run.status, run.started, run.finished));
+            const started = this._runDetailsStarted(run.status, run.started, run.delayed);
+            if (started)
+                output_1.default.normal(started);
+            const finished = this._runDetailsFinished(run.status, run.finished);
+            if (finished)
+                output_1.default.normal(finished);
+        }
+        output_1.default.exitNormal();
+    }
+    static async _actionStatusLoop(client, workspace, project, pipelineId, runId, actionExecutionId, onChange) {
+        let lastAction = null;
+        const fetchAction = async () => {
+            return await client.getPipelineRunActionExecution(workspace, project, pipelineId, runId, actionExecutionId);
+        };
+        let type;
+        let name;
+        let status;
+        let oldStatus = null;
+        let started;
+        let finished;
+        let logs = [];
+        let changed;
+        let shouldCancel = false;
+        const cancel = () => {
+            shouldCancel = true;
+        };
+        onChange(null, cancel);
+        for (;;) {
+            if (shouldCancel)
+                return lastAction;
+            const a = await fetchAction();
+            started = null;
+            if (a.start_date)
+                started = new Date(a.start_date);
+            finished = null;
+            if (a.finish_date)
+                finished = new Date(a.finish_date);
+            status = a.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+            name = a.action?.name || '';
+            const originalType = a.action?.type || pipeline_1.PIPELINE_ACTION_TYPE.BUILD;
+            type = originalType;
+            if (pipeline_1.PIPELINE_ACTION_NAME[originalType]) {
+                type = pipeline_1.PIPELINE_ACTION_NAME[originalType];
+            }
+            if (a.log)
+                logs = a.log;
+            changed = !oldStatus || status !== oldStatus;
+            lastAction = {
+                id: actionExecutionId,
+                status,
+                started,
+                finished,
+                name,
+                type,
+                changed,
+                logs,
+            };
+            onChange(lastAction, null);
+            oldStatus = status;
+            if ([
+                pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+                pipeline_1.PIPELINE_RUN_STATUS.SKIPPED,
+                pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED,
+                pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL,
+                pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            ].includes(status)) {
+                break;
+            }
+            await (0, utils_1.sleep)(3000);
+        }
+        return lastAction;
+    }
+    static async _runStatusLoop(client, workspace, project, pipelineId, runId, onChange) {
+        let lastRun;
+        const fetchRun = async () => {
+            return await client.getPipelineRun(workspace, project, pipelineId, runId);
+        };
+        let status;
+        let started;
+        let finished = null;
+        let delayed = null;
+        let trigger;
+        let creator = 'Unknown';
+        let description = '';
+        let refresh = false;
+        let clearCache = false;
+        let priority = pipeline_1.PIPELINE_PRIORITY.NORMAL;
+        let context = null;
+        let actions = [];
+        for (;;) {
+            const run = await fetchRun();
+            started = new Date(run.start_date || new Date());
+            trigger = run.triggered_on || pipeline_1.PIPELINE_RUN_TRIGGER.CLICK;
+            status = run.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+            if (run.creator) {
+                if (run.creator.name)
+                    creator = run.creator.name;
+                else if (run.creator.email)
+                    creator = run.creator.email;
+            }
+            if (run.finish_date)
+                finished = new Date(run.finish_date);
+            if (run.comment)
+                description = run.comment;
+            if (run.priority)
+                priority = run.priority;
+            if (run.delay_until)
+                delayed = new Date(run.delay_until);
+            if (run.refresh)
+                refresh = true;
+            if (run.clear_cache)
+                clearCache = true;
+            if (run.branch) {
+                if (!context)
+                    context = {};
+                context['Branch'] = run.branch.name;
+            }
+            if (run.tag) {
+                if (!context)
+                    context = {};
+                context['Tag'] = run.tag.name;
+            }
+            if (run.pull_request) {
+                if (!context)
+                    context = {};
+                context['Pull request'] = run.pull_request.name;
+            }
+            if (run.to_revision) {
+                if (!context)
+                    context = {};
+                context['Revision'] = `#${run.to_revision.revision.substring(0, 7)}`;
+                if (run.to_revision.message)
+                    context['Revision'] += `: ${run.to_revision.message}`;
+            }
+            if (run.environment) {
+                if (!context)
+                    context = {};
+                context['Environment'] = run.environment.identifier;
+            }
+            if (run.package && run.package_version) {
+                if (!context)
+                    context = {};
+                context['Package'] =
+                    `${run.package.identifier}:${run.package_version.version}`;
+            }
+            if (run.action_executions) {
+                const old = actions;
+                actions = (run.action_executions || []).map((a) => {
+                    const originalType = a.action?.type ||
+                        pipeline_1.PIPELINE_ACTION_TYPE.BUILD;
+                    let type = originalType;
+                    if (pipeline_1.PIPELINE_ACTION_NAME[originalType]) {
+                        type = pipeline_1.PIPELINE_ACTION_NAME[originalType];
+                    }
+                    const name = a.action?.name || '';
+                    const id = a.action_execution_id;
+                    const status = a.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+                    let started = null;
+                    if (a.start_date)
+                        started = new Date(a.start_date);
+                    let finished = null;
+                    if (a.finish_date)
+                        finished = new Date(a.finish_date);
+                    const oldAction = old.find((o) => o.id === id);
+                    const changed = !oldAction || oldAction.status !== status;
+                    const action = {
+                        type,
+                        name,
+                        id,
+                        status,
+                        started,
+                        finished,
+                        changed,
+                    };
+                    return action;
+                });
+            }
+            lastRun = {
+                creator,
+                description,
+                started,
+                status,
+                trigger,
+                finished,
+                clearCache,
+                refresh,
+                priority,
+                delayed,
+                context,
+                actions,
+            };
+            onChange(lastRun);
+            if ([
+                pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+                pipeline_1.PIPELINE_RUN_STATUS.SKIPPED,
+                pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED,
+                pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL,
+                pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            ].includes(status)) {
+                break;
+            }
+            await (0, utils_1.sleep)(3000);
+        }
+        return lastRun;
+    }
+}
+exports.default = OutputPipeline;