bdy 1.18.33-dev → 1.18.34-dev-pipeline

package/distTs/src/output/pipeline.js

@@ -0,0 +1,1383 @@
+"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"));
+var LOOP_STATUS;
+(function (LOOP_STATUS) {
+    LOOP_STATUS["DISABLED"] = "DISABLED";
+    LOOP_STATUS["RESOLVED"] = "RESOLVED";
+    LOOP_STATUS["NO_LOOP"] = "NO_LOOP";
+    LOOP_STATUS["LIMIT_REACHED"] = "LIMIT_REACHED";
+    LOOP_STATUS["ERROR"] = "ERROR";
+    LOOP_STATUS["DYNAMIC"] = "DYNAMIC";
+})(LOOP_STATUS || (LOOP_STATUS = {}));
+class OutputPipeline {
+    static async runLogs(client, workspace, project, pipelineId, runId, runActionId, noWait) {
+        if (output_1.default.isTTY() && !noWait) {
+            return await this._runLogsInteractive(client, workspace, project, pipelineId, runId, runActionId);
+        }
+        return await this._runLogsNonInteractive(client, workspace, project, pipelineId, runId, runActionId, noWait);
+    }
+    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 _makeSpaces(length) {
+        let str = '';
+        for (let i = 0; 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, tabs) {
+        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) {
+        return `${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor(this._fillString('ACTIONS', 3 * tabs))} ${output_1.default.getTermKitLabelColor('ID')}`;
+    }
+    static _actionLogs(logs, scroll, limit = 0) {
+        const str = [];
+        if (logs.length > 0) {
+            let start = logs.length - scroll - limit;
+            if (start < 0)
+                start = 0;
+            let end = start + limit;
+            if (end > logs.length)
+                end = logs.length;
+            for (let i = start; i < end; i += 1) {
+                str.push(`  ${output_1.default.getTermKitDimColor(logs[i])}`);
+            }
+        }
+        else {
+            str.push(`  ${output_1.default.getTermKitDimColor('Waiting...')}`);
+        }
+        return str;
+    }
+    static _getActionLoop(action, highlight, tabs) {
+        let outer = '[';
+        let dim = false;
+        let red = false;
+        if (action.loop === LOOP_STATUS.DYNAMIC) {
+            outer += 'Loop';
+            dim = true;
+        }
+        else if (action.loop === LOOP_STATUS.RESOLVED) {
+            outer += 'Loop';
+        }
+        else if (action.loop !== LOOP_STATUS.DISABLED) {
+            red = true;
+            outer += 'Loop';
+        }
+        if (action.target) {
+            if (action.loop !== LOOP_STATUS.DISABLED)
+                outer += ', ';
+            outer += action.target;
+        }
+        if (outer.length + 2 >= tabs) {
+            outer = outer.substring(0, tabs - 2);
+        }
+        outer += ']';
+        outer = this._fillString(outer, tabs);
+        if (highlight) {
+            return output_1.default.getTermKitCyanColor(outer);
+        }
+        if (red) {
+            return output_1.default.getTermKitRedColor(outer);
+        }
+        if (dim) {
+            return output_1.default.getTermKitDimColor(outer);
+        }
+        return output_1.default.getTermKitArgColor(outer);
+    }
+    static _getActionName(action, highlight, tabs) {
+        let s = '';
+        let name = action.name || '';
+        if (name.length + 1 >= tabs)
+            name = name.substring(0, tabs - 1);
+        if (highlight) {
+            s += output_1.default.getTermKitCyanColor(name);
+        }
+        else if ([
+            pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS,
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATING,
+        ].includes(action.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(action.status)) {
+            s += output_1.default.getTermKitDimColor(name);
+        }
+        else {
+            s += output_1.default.getTermKitMutedColor(name);
+        }
+        const loopLength = tabs - name.length;
+        if (action.loopValues.length > 0 && loopLength >= 5) {
+            let loop = ' [';
+            action.loopValues.forEach((v, i) => {
+                if (i > 0)
+                    loop += ', ';
+                loop += `${v.value}`;
+            });
+            if (loop.length > loopLength - 2) {
+                loop = loop.substring(0, loopLength - 2);
+            }
+            loop += ']';
+            if (highlight) {
+                s += output_1.default.getTermKitCyanColor(loop);
+            }
+            else {
+                s += output_1.default.getTermKitArgColor(loop);
+            }
+            s += this._fillString('', loopLength - loop.length + 1);
+        }
+        else if (loopLength > 0) {
+            s += this._fillString('', loopLength + 1);
+        }
+        return s;
+    }
+    static _getActionType(action, highlight, tabs) {
+        let s = '';
+        let l = action.type.length;
+        if (highlight) {
+            s += output_1.default.getTermKitCyanColor('❯ ');
+            s += output_1.default.getTermKitCyanColor(action.type);
+        }
+        else {
+            s += '  ';
+            s += output_1.default.getTermKitDimColor(action.type);
+        }
+        if (tabs - l > 6 &&
+            (action.target || action.loop !== LOOP_STATUS.DISABLED)) {
+            l += 1;
+            s += ' ';
+            s += this._getActionLoop(action, highlight, tabs - l);
+        }
+        else {
+            s += this._makeSpaces(tabs - l);
+        }
+        return s;
+    }
+    static _runActions(run, onlyChanged = false, limit, selected, tabs) {
+        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 - Math.floor(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;
+            s += this._getActionType(a, highlight, tabs);
+            s += this._getActionName(a, highlight, 2 * tabs);
+            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;
+            const txt = this.runStatusText(a.status);
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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(txt)}`;
+            }
+            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) {
+        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 _runActionTarget(action, tabs) {
+        if (!action.target)
+            return null;
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Target', tabs))}`;
+        str += output_1.default.getTermKitMutedColor(action.target);
+        return str;
+    }
+    static _runLoopText(loop, variables) {
+        if (loop === LOOP_STATUS.NO_LOOP) {
+            return 'Not found';
+        }
+        else if (loop === LOOP_STATUS.LIMIT_REACHED) {
+            return 'Limit reached';
+        }
+        else if (loop === LOOP_STATUS.ERROR) {
+            return 'Something went wrong';
+        }
+        else if (loop === LOOP_STATUS.DYNAMIC) {
+            return 'Not calculated yet';
+        }
+        else if (!variables.length) {
+            return 'No variables resolved';
+        }
+        else {
+            let vars = '';
+            variables.forEach((v, i) => {
+                if (i > 0)
+                    vars += ', ';
+                vars += `${v.key}:${v.value}`;
+            });
+            return vars;
+        }
+    }
+    static _runLoopVariables(loop, variables, tabs) {
+        if (loop === LOOP_STATUS.DISABLED)
+            return null;
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Loop', tabs))}`;
+        const txt = this._runLoopText(loop, variables);
+        if (loop === LOOP_STATUS.NO_LOOP) {
+            str += output_1.default.getTermKitRedColor(txt);
+        }
+        else if (loop === LOOP_STATUS.LIMIT_REACHED) {
+            str += output_1.default.getTermKitRedColor(txt);
+        }
+        else if (loop === LOOP_STATUS.ERROR) {
+            str += output_1.default.getTermKitRedColor(txt);
+        }
+        else if (loop === LOOP_STATUS.DYNAMIC) {
+            str += output_1.default.getTermKitDimColor(txt);
+        }
+        else if (!variables.length) {
+            str += output_1.default.getTermKitMutedColor(txt);
+        }
+        else {
+            str += output_1.default.getTermKitMutedColor(txt);
+        }
+        return str;
+    }
+    static _runDetailsFinished(status, finished, tabs) {
+        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) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Trigger', tabs))}`;
+        if (run?.creator) {
+            str += `${output_1.default.getTermKitBlueColor(run.creator)} - `;
+        }
+        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 _runDetailsDescription(run, tabs) {
+        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 _runHtmlUrl(htmlUrl, tabs) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('URL', tabs))}`;
+        str += output_1.default.getTermKitMutedColor(htmlUrl);
+        return str;
+    }
+    static _runDetailsId(id, tabs) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('ID', tabs))}`;
+        str += output_1.default.getTermKitMutedColor(id);
+        return str;
+    }
+    static runStatusText(status) {
+        if (status === pipeline_1.PIPELINE_RUN_STATUS.INITIAL) {
+            return 'Created';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS) {
+            return 'Running';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED) {
+            return 'Queued';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATED) {
+            return 'Canceled';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL) {
+            return 'Passed';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.FAILED) {
+            return 'Failed';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED) {
+            return 'Created';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SKIPPED) {
+            return 'Skipped';
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATING) {
+            return 'Canceling';
+        }
+        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)) {
+            return 'Awaiting';
+        }
+        else {
+            return status;
+        }
+    }
+    static _runDetailsStatus(status, started, finished, tabs) {
+        let str = `  ${output_1.default.getTermKitDimColor(this._fillString('Status', tabs))}`;
+        let ts = false;
+        const txt = this.runStatusText(status);
+        if (status === pipeline_1.PIPELINE_RUN_STATUS.INITIAL) {
+            str += output_1.default.getTermKitDimColor(txt);
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.INPROGRESS) {
+            str += output_1.default.getTermKitBlueColor(txt);
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.ENQUEUED) {
+            str += output_1.default.getTermKitDimColor(txt);
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATED) {
+            str += output_1.default.getTermKitRedColor(txt);
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL) {
+            str += output_1.default.getTermKitGreenColor(txt);
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.FAILED) {
+            str += output_1.default.getTermKitRedColor(txt);
+            ts = true;
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED) {
+            str += output_1.default.getTermKitDimColor(txt);
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.SKIPPED) {
+            str += output_1.default.getTermKitDimColor(txt);
+        }
+        else if (status === pipeline_1.PIPELINE_RUN_STATUS.TERMINATING) {
+            str += output_1.default.getTermKitBlueColor(txt);
+            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(txt);
+        }
+        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('↑↓|⇞⇟|↖↘');
+        help += output_1.default.getTermKitDimColor(' navigate •');
+        help += output_1.default.getTermKitLabelColor(' esc');
+        help += output_1.default.getTermKitDimColor(' exit');
+        return help;
+    }
+    static _drawInteractiveAction(action, actionLogs, put, blank, opts) {
+        const fullActionLogs = [...actionLogs];
+        if (action?.outputtedVariables.length) {
+            if (actionLogs.length > 0)
+                fullActionLogs.push('');
+            fullActionLogs.push('Output Variables');
+            action.outputtedVariables.forEach((v) => {
+                fullActionLogs.push(`${v.key}="${v.value}"`);
+            });
+        }
+        const tabs = 25;
+        if (action) {
+            put(this._runDetailsHeader());
+            put(this._runDetailsId(action.id, tabs));
+            put(this._runHtmlUrl(action.url, tabs));
+            put(this._runDetailsStatus(action.status, action.started, action.finished, tabs));
+            const target = this._runActionTarget(action, tabs);
+            if (target) {
+                put(target);
+            }
+            const loop = this._runLoopVariables(action.loop, action.loopValues, tabs);
+            if (loop) {
+                put(loop);
+            }
+            const started = this._runDetailsStarted(action.status, action.started, null, tabs);
+            if (started) {
+                put(started);
+            }
+            const finished = this._runDetailsFinished(action.status, action.finished, tabs);
+            if (finished) {
+                put(finished);
+            }
+            blank();
+            const y = put(this._runLogsHeader());
+            let logsLimit = termkit_no_lazy_require_1.default.terminal.height - y - 3;
+            if (logsLimit < 2)
+                logsLimit = 2;
+            if (opts.actionLogsScroll > fullActionLogs.length - logsLimit) {
+                opts.actionLogsScroll = fullActionLogs.length - logsLimit;
+            }
+            if (opts.actionLogsScroll < 0) {
+                opts.actionLogsScroll = 0;
+            }
+            const logs = this._actionLogs(fullActionLogs, opts.actionLogsScroll, logsLimit);
+            logs.forEach((str) => {
+                put(str);
+            });
+            blank();
+            put(this._actionInteractiveHelp());
+        }
+    }
+    static _drawInteractiveRun(run, put, blank, getY, opts) {
+        const tabs = 40;
+        if (run) {
+            put(this._runDetailsHeader());
+            put(this._runDetailsId(run.id, tabs));
+            put(this._runHtmlUrl(run.url, tabs));
+            put(this._runDetailsStatus(run.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL, run.started, run.finished, tabs));
+            put(this._runDetailsTriggerer(run, tabs));
+            if (run.description) {
+                put(this._runDetailsDescription(run, tabs));
+            }
+            const started = this._runDetailsStarted(run.status, run.started, run.delayed, tabs);
+            if (started) {
+                put(started);
+            }
+            const finished = this._runDetailsFinished(run.status, run.finished, tabs);
+            if (finished) {
+                put(finished);
+            }
+            const context = this._runContext(run, tabs);
+            if (context.length > 0) {
+                blank();
+                context.forEach((str) => {
+                    put(str);
+                });
+            }
+            const y = getY();
+            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, tabs);
+            if (actions.length > 0) {
+                blank();
+                actions.forEach((str) => {
+                    put(str);
+                });
+            }
+            blank();
+            put(this._runInteractiveHelp());
+        }
+    }
+    static async _runLogsInteractive(client, workspace, project, pipelineId, runId, runActionId) {
+        let action = null;
+        let actionLogs = [];
+        const opts = {
+            actionLogsScroll: 0,
+        };
+        let draw = () => { };
+        const { put, apply, reset, blank } = output_1.default.createScreenBuffer((name) => {
+            let logsPage = termkit_no_lazy_require_1.default.terminal.height - 15;
+            if (logsPage <= 0)
+                logsPage = 1;
+            if (name === 'CTRL_C') {
+                return true;
+            }
+            else if (name === 'ESCAPE') {
+                return true;
+            }
+            else if (name === 'DOWN') {
+                opts.actionLogsScroll -= 1;
+                if (opts.actionLogsScroll < 0)
+                    opts.actionLogsScroll = 0;
+                draw();
+                return false;
+            }
+            else if (name === 'UP') {
+                opts.actionLogsScroll += 1;
+                draw();
+                return false;
+            }
+            else if (name === 'PAGE_UP') {
+                opts.actionLogsScroll += logsPage;
+                draw();
+                return false;
+            }
+            else if (name === 'PAGE_DOWN') {
+                opts.actionLogsScroll -= logsPage;
+                if (opts.actionLogsScroll < 0)
+                    opts.actionLogsScroll = 0;
+                draw();
+                return false;
+            }
+            else if (name === 'HOME') {
+                opts.actionLogsScroll = actionLogs.length;
+                draw();
+                return false;
+            }
+            else if (name === 'END') {
+                opts.actionLogsScroll = 0;
+                draw();
+                return false;
+            }
+            else {
+                return false;
+            }
+        }, () => {
+            draw();
+        });
+        draw = () => {
+            reset();
+            this._drawInteractiveAction(action, actionLogs, put, blank, opts);
+            apply();
+        };
+        setInterval(() => draw(), 100);
+        draw();
+        this._actionLogsLoop(client, workspace, project, pipelineId, runId, runActionId, (logs) => {
+            actionLogs = logs;
+            draw();
+        })
+            .then()
+            .catch((err) => output_1.default.exitError(err));
+        await this._actionStatusLoop(client, workspace, project, pipelineId, runId, runActionId, (a) => {
+            action = a;
+            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 actionLogs = [];
+        let cancelActionFetch = () => { };
+        let cancelActionLogs = () => { };
+        let selectedActionId = null;
+        const opts = {
+            selectedActionIndex: -1,
+            actionLogsScroll: 0,
+        };
+        let draw = () => { };
+        const { put, apply, reset, blank, getY } = output_1.default.createScreenBuffer((name) => {
+            let logsPage = termkit_no_lazy_require_1.default.terminal.height - 15;
+            if (logsPage <= 0)
+                logsPage = 1;
+            if (name === 'CTRL_C') {
+                return true;
+            }
+            else if (name === 'ESCAPE') {
+                if (mode === MODE_RUN) {
+                    return true;
+                }
+                else {
+                    selectedActionId = null;
+                    action = null;
+                    actionLogs = [];
+                    opts.actionLogsScroll = 0;
+                    cancelActionFetch();
+                    cancelActionLogs();
+                    mode = MODE_RUN;
+                    draw();
+                }
+            }
+            else if (name === 'DOWN') {
+                if (mode === MODE_RUN) {
+                    opts.selectedActionIndex += 1;
+                    draw();
+                }
+                else {
+                    opts.actionLogsScroll -= 1;
+                    if (opts.actionLogsScroll < 0)
+                        opts.actionLogsScroll = 0;
+                    draw();
+                }
+            }
+            else if (name === 'UP') {
+                if (mode === MODE_RUN) {
+                    opts.selectedActionIndex -= 1;
+                    if (opts.selectedActionIndex < 0)
+                        opts.selectedActionIndex = -1;
+                    draw();
+                }
+                else {
+                    opts.actionLogsScroll += 1;
+                    draw();
+                }
+            }
+            else if (name === 'PAGE_UP') {
+                if (mode === MODE_ACTION) {
+                    opts.actionLogsScroll += logsPage;
+                    draw();
+                }
+            }
+            else if (name === 'PAGE_DOWN') {
+                if (mode === MODE_ACTION) {
+                    opts.actionLogsScroll -= logsPage;
+                    if (opts.actionLogsScroll < 0)
+                        opts.actionLogsScroll = 0;
+                    draw();
+                }
+            }
+            else if (name === 'HOME') {
+                if (mode === MODE_ACTION) {
+                    opts.actionLogsScroll = actionLogs.length;
+                    draw();
+                }
+            }
+            else if (name === 'END') {
+                if (mode === MODE_ACTION) {
+                    opts.actionLogsScroll = 0;
+                    draw();
+                }
+            }
+            else if (name === 'ENTER') {
+                if (mode === MODE_RUN &&
+                    run &&
+                    run.actions[opts.selectedActionIndex]) {
+                    selectedActionId = run.actions[opts.selectedActionIndex].id;
+                    mode = MODE_ACTION;
+                    this._actionLogsLoop(client, workspace, project, pipelineId, runId, selectedActionId, (logs, cancel) => {
+                        cancelActionLogs = cancel;
+                        actionLogs = logs;
+                        draw();
+                    });
+                    this._actionStatusLoop(client, workspace, project, pipelineId, runId, selectedActionId, (a, cancel) => {
+                        if (cancel)
+                            cancelActionFetch = cancel;
+                        if (a && selectedActionId === a.id)
+                            action = a;
+                        draw();
+                    });
+                    draw();
+                }
+            }
+            return false;
+        }, () => {
+            draw();
+        });
+        draw = () => {
+            reset();
+            if (mode === MODE_RUN) {
+                this._drawInteractiveRun(run, put, blank, getY, opts);
+            }
+            else {
+                this._drawInteractiveAction(action, actionLogs, put, blank, opts);
+            }
+            apply();
+        };
+        setInterval(() => draw(), 100);
+        draw();
+        await this._runStatusLoop(client, workspace, project, pipelineId, runId, (r) => {
+            run = r;
+            draw();
+        });
+    }
+    static async _runLogsNonInteractive(client, workspace, project, pipelineId, runId, runActionId, noWait) {
+        let action = null;
+        let actionLogsStart = 0;
+        let lastActionLogsStart = -1;
+        let drawnStart = false;
+        let logsEnd = false;
+        let totalFetchesCount = 0;
+        const tabs = 40;
+        const draw = (logs) => {
+            if (!drawnStart && action) {
+                output_1.default.normal(this._runDetailsHeader());
+                output_1.default.normal(this._runDetailsId(action.id, tabs));
+                output_1.default.normal(this._runHtmlUrl(action.url, tabs));
+                output_1.default.normal(this._runDetailsStatus(action.status, action.started, action.finished, tabs));
+                const target = this._runActionTarget(action, tabs);
+                if (target) {
+                    output_1.default.normal(target);
+                }
+                const loop = this._runLoopVariables(action.loop, action.loopValues, tabs);
+                if (loop) {
+                    output_1.default.normal(loop);
+                }
+                const started = this._runDetailsStarted(action.status, action.started, null, tabs);
+                if (started) {
+                    output_1.default.normal(started);
+                }
+                const finished = this._runDetailsFinished(action.status, action.finished, tabs);
+                if (finished) {
+                    output_1.default.normal(finished);
+                }
+                output_1.default.normal('');
+                output_1.default.normal(this._runLogsHeader());
+                drawnStart = true;
+            }
+            if (drawnStart && logs && !logsEnd) {
+                for (; actionLogsStart < logs.length; actionLogsStart += 1) {
+                    output_1.default.normal(`  ${logs[actionLogsStart]}`);
+                }
+                if (action &&
+                    [
+                        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(action.status) &&
+                    actionLogsStart === lastActionLogsStart) {
+                    logsEnd = true;
+                }
+                lastActionLogsStart = actionLogsStart;
+            }
+            if (logsEnd || (drawnStart && noWait && logs)) {
+                if (logsEnd && action?.outputtedVariables.length) {
+                    output_1.default.normal('');
+                    output_1.default.normal('  Output Variables');
+                    action.outputtedVariables.forEach((v) => {
+                        output_1.default.normal(`  ${v.key}="${v.value}"`);
+                    });
+                }
+                if (logsEnd && action && totalFetchesCount > 1) {
+                    output_1.default.normal('');
+                    output_1.default.normal(this._runDetailsHeader());
+                    output_1.default.normal(this._runDetailsStatus(action.status, action.started, action.finished, tabs));
+                    const target = this._runActionTarget(action, tabs);
+                    if (target) {
+                        output_1.default.normal(target);
+                    }
+                    const loop = this._runLoopVariables(action.loop, action.loopValues, tabs);
+                    if (loop) {
+                        output_1.default.normal(loop);
+                    }
+                    const started = this._runDetailsStarted(action.status, action.started, null, tabs);
+                    if (started) {
+                        output_1.default.normal(started);
+                    }
+                    const finished = this._runDetailsFinished(action.status, action.finished, tabs);
+                    if (finished) {
+                        output_1.default.normal(finished);
+                    }
+                }
+                output_1.default.exitNormal();
+            }
+        };
+        this._actionLogsLoop(client, workspace, project, pipelineId, runId, runActionId, draw)
+            .then()
+            .catch((err) => output_1.default.exitError(err));
+        await this._actionStatusLoop(client, workspace, project, pipelineId, runId, runActionId, (a) => {
+            if (a) {
+                action = a;
+                totalFetchesCount += 1;
+                draw();
+            }
+        });
+    }
+    static async _runStatusNonInteractive(client, workspace, project, pipelineId, runId, noWait) {
+        let run = null;
+        let totalFetchesCount = 0;
+        const tabs = 40;
+        const draw = (r) => {
+            if (!run) {
+                output_1.default.normal(this._runDetailsHeader());
+                output_1.default.normal(this._runDetailsId(r.id, tabs));
+                output_1.default.normal(this._runHtmlUrl(r.url, tabs));
+                output_1.default.normal(this._runDetailsStatus(r.status, r.started, r.finished, tabs));
+                output_1.default.normal(this._runDetailsTriggerer(r, tabs));
+                if (r?.description)
+                    output_1.default.normal(this._runDetailsDescription(r, tabs));
+                const started = this._runDetailsStarted(r.status, r.started, r.delayed, tabs);
+                if (started)
+                    output_1.default.normal(started);
+                const finished = this._runDetailsFinished(r.status, r.finished, tabs);
+                if (finished)
+                    output_1.default.normal(finished);
+                const context = this._runContext(r, tabs);
+                if (context.length > 0) {
+                    output_1.default.normal('');
+                    context.forEach((str) => {
+                        output_1.default.normal(str);
+                    });
+                    output_1.default.normal('');
+                }
+                output_1.default.normal(this._runActionsHeader(tabs));
+            }
+            const actions = this._runActions(r, true, 0, -1, tabs);
+            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, tabs));
+            const started = this._runDetailsStarted(run.status, run.started, run.delayed, tabs);
+            if (started)
+                output_1.default.normal(started);
+            const finished = this._runDetailsFinished(run.status, run.finished, tabs);
+            if (finished)
+                output_1.default.normal(finished);
+        }
+        output_1.default.exitNormal();
+    }
+    static async _actionLogsLoop(client, workspace, project, pipelineId, runId, actionExecutionId, onChange) {
+        const logs = [];
+        let offset = 0;
+        const limit = 1000;
+        let shouldCancel = false;
+        const cancel = () => {
+            shouldCancel = true;
+        };
+        onChange(logs, cancel);
+        const fetchLogs = async () => {
+            return await client.getPipelineRunActionLogs(workspace, project, pipelineId, runId, actionExecutionId, offset, limit);
+        };
+        for (;;) {
+            const o = await fetchLogs();
+            offset = o.offset + o.element_count;
+            logs.push(...o.logs);
+            if (shouldCancel)
+                return;
+            onChange(logs, cancel);
+            if (o.logs.length > 0)
+                continue;
+            await (0, utils_1.sleep)(3000);
+        }
+    }
+    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 actionId;
+        let url;
+        let status;
+        let oldStatus = null;
+        let started;
+        let finished;
+        let target = null;
+        let loop = LOOP_STATUS.DISABLED;
+        let loopValues = [];
+        let outputtedVariables = [];
+        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 || '';
+            actionId = a.action?.id || -1;
+            url = a.html_url;
+            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.target)
+                target = a.target;
+            if (a.outputted_variables) {
+                outputtedVariables = [];
+                a.outputted_variables.forEach((v) => {
+                    outputtedVariables.push({
+                        key: String(v.key),
+                        value: String(v.value),
+                    });
+                });
+            }
+            if (a.loop_details) {
+                loop = a.loop_details.status;
+                if (a.loop_details.resolved_variables) {
+                    loopValues = [];
+                    a.loop_details.resolved_variables.forEach((v) => {
+                        if (v.value)
+                            loopValues.push({
+                                key: String(v.key),
+                                value: String(v.value),
+                            });
+                    });
+                }
+            }
+            changed = !oldStatus || status !== oldStatus;
+            lastAction = {
+                id: actionExecutionId,
+                actionId,
+                url,
+                status,
+                target,
+                loop,
+                loopValues,
+                outputtedVariables,
+                started,
+                finished,
+                name,
+                type,
+                changed,
+            };
+            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)) {
+                cancel();
+            }
+            if (shouldCancel)
+                return lastAction;
+            await (0, utils_1.sleep)(3000);
+        }
+    }
+    static async _runStatusLoop(client, workspace, project, pipelineId, runId, onChange) {
+        let lastRun;
+        const fetchRun = async () => {
+            return await client.getPipelineRun(workspace, project, pipelineId, runId);
+        };
+        const id = String(runId);
+        let url;
+        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;
+            url = run.html_url;
+            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.loop_details) {
+                if (!context)
+                    context = {};
+                context['Loop'] = this._runLoopText(run.loop_details.status, run.loop_details.resolved_variables || []);
+            }
+            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 url = a.html_url;
+                    const actionId = a.action?.id || -1;
+                    const status = a.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+                    let target = null;
+                    let loop = LOOP_STATUS.DISABLED;
+                    const loopValues = [];
+                    const outputtedVariables = [];
+                    if (a.target)
+                        target = a.target;
+                    if (a.outputted_variables) {
+                        a.outputted_variables.forEach((v) => {
+                            outputtedVariables.push({
+                                key: String(v.key),
+                                value: String(v.value),
+                            });
+                        });
+                    }
+                    if (a.loop_details) {
+                        loop = a.loop_details.status;
+                        if (a.loop_details.resolved_variables) {
+                            a.loop_details.resolved_variables.forEach((v) => {
+                                if (v.value)
+                                    loopValues.push({
+                                        key: String(v.key),
+                                        value: String(v.value),
+                                    });
+                            });
+                        }
+                    }
+                    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,
+                        url,
+                        loop,
+                        loopValues,
+                        outputtedVariables,
+                        target,
+                        actionId,
+                        id,
+                        status,
+                        started,
+                        finished,
+                        changed,
+                    };
+                    return action;
+                });
+                actions = actions.filter((a) => {
+                    if (a.target)
+                        return true;
+                    return !actions.find((a2) => {
+                        if (a2.id === a.id)
+                            return false;
+                        if (a2.actionId !== a.actionId)
+                            return false;
+                        return !!a2.target;
+                    });
+                });
+            }
+            lastRun = {
+                id,
+                creator,
+                description,
+                started,
+                url,
+                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;