bdy 1.22.24-dev → 1.22.24-dev-pipeline

package/distTs/src/output/pipeline.js

@@ -0,0 +1,1695 @@
+"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 = {}));
+var MODE;
+(function (MODE) {
+    MODE["RUN"] = "RUN";
+    MODE["ACTION"] = "ACTION";
+})(MODE || (MODE = {}));
+const LOGS_LIMIT = 1000;
+class OutputPipeline {
+    static async runLogs(client, workspace, project, pipelineId, runId, runActionId, noWait, isJson) {
+        if (output_1.default.isTTY() && !noWait && !isJson) {
+            return await this._runLogsInteractive(client, workspace, project, pipelineId, runId, runActionId);
+        }
+        return await this._runLogsNonInteractive(client, workspace, project, pipelineId, runId, runActionId, noWait, isJson);
+    }
+    static async runStatus(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson) {
+        if (output_1.default.isTTY() && !noWait && !noFollow && !isJson) {
+            return await this._runStatusInteractive(client, workspace, project, pipelineId, runId);
+        }
+        return await this._runStatusNonInteractive(client, workspace, project, identifier, pipelineId, runId, noWait, noFollow, isJson);
+    }
+    static _canCancel(status) {
+        return ![
+            pipeline_1.PIPELINE_RUN_STATUS.SKIPPED,
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATING,
+            pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+            pipeline_1.PIPELINE_RUN_STATUS.NOT_EXECUTED,
+            pipeline_1.PIPELINE_RUN_STATUS.SUCCESSFUL,
+        ].includes(status);
+    }
+    static _canRetry(status) {
+        return [
+            pipeline_1.PIPELINE_RUN_STATUS.TERMINATED,
+            pipeline_1.PIPELINE_RUN_STATUS.FAILED,
+        ].includes(status);
+    }
+    static _canApprove(status) {
+        return [pipeline_1.PIPELINE_RUN_STATUS.WAITING_FOR_APPLY].includes(status);
+    }
+    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 _runOutputHeader() {
+        return `${output_1.default.getTermKitBlueColor('/')} ${output_1.default.getTermKitLabelColor('OUTPUT')}`;
+    }
+    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.runId, 25));
+                }
+                else {
+                    s += output_1.default.getTermKitDimColor(this._fillString(a.runId, 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 _dimLine() {
+        const termWidth = termkit_no_lazy_require_1.default.terminal.width;
+        const width = Number.isFinite(termWidth) && termWidth > 2 ? termWidth - 2 : 25;
+        return output_1.default.getTermKitDimColor(`  ${'—'.repeat(width)}`);
+    }
+    static _runActionsLogsHelp(identifier, runId) {
+        return `${output_1.default.getTermKitDimColor('  To view action logs run: ')}${output_1.default.getTermKitMutedColor(`bdy pip run logs ${identifier} ${runId} <action-run-id>`)}`;
+    }
+    static _jsonActionsLogsHelp(identifier, runId) {
+        return `To view action logs run: \`bdy pip run logs ${identifier} ${runId} <action-run-id>\``;
+    }
+    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(String(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(run) {
+        let help = output_1.default.getTermKitLabelColor('↑↓');
+        help += output_1.default.getTermKitDimColor(' navigate •');
+        help += output_1.default.getTermKitLabelColor(' ⏎');
+        help += output_1.default.getTermKitDimColor(' view logs •');
+        if (this._canCancel(run.status)) {
+            help += output_1.default.getTermKitLabelColor(' c');
+            help += output_1.default.getTermKitDimColor(' cancel •');
+        }
+        if (this._canRetry(run.status)) {
+            help += output_1.default.getTermKitLabelColor(' r');
+            help += output_1.default.getTermKitDimColor(' retry •');
+        }
+        if (this._canApprove(run.status)) {
+            help += output_1.default.getTermKitLabelColor(' a');
+            help += output_1.default.getTermKitDimColor(' approve •');
+        }
+        help += output_1.default.getTermKitLabelColor(' esc');
+        help += output_1.default.getTermKitDimColor(' exit');
+        return help;
+    }
+    static _actionInteractiveHelp(action) {
+        let help = output_1.default.getTermKitLabelColor('↑↓|⇞⇟|↖↘');
+        help += output_1.default.getTermKitDimColor(' navigate •');
+        if (this._canCancel(action.status)) {
+            help += output_1.default.getTermKitLabelColor(' c');
+            help += output_1.default.getTermKitDimColor(' cancel •');
+        }
+        if (this._canRetry(action.status)) {
+            help += output_1.default.getTermKitLabelColor(' r');
+            help += output_1.default.getTermKitDimColor(' retry •');
+        }
+        if (this._canApprove(action.status)) {
+            help += output_1.default.getTermKitLabelColor(' a');
+            help += output_1.default.getTermKitDimColor(' approve •');
+        }
+        help += output_1.default.getTermKitLabelColor(' esc');
+        help += output_1.default.getTermKitDimColor(' exit');
+        return help;
+    }
+    static _drawInteractiveAction(action, actionLogs, put, blank, opts) {
+        const fullActionLogs = [...actionLogs.map((str) => `  ${str}`)];
+        if (action?.outputtedVariables.length) {
+            if (actionLogs.length > 0)
+                fullActionLogs.push('');
+            fullActionLogs.push(this._runOutputHeader());
+            action.outputtedVariables.forEach((v, i) => {
+                let line = '  ';
+                if (i <= 0)
+                    line += 'Variables     ';
+                else
+                    line += '              ';
+                line += output_1.default.getTermKitMutedColor(v.key);
+                line += ' = "';
+                line += output_1.default.getTermKitBlueColor(v.value);
+                line += '"';
+                fullActionLogs.push(line);
+            });
+        }
+        const tabs = 25;
+        if (action) {
+            put(this._runDetailsHeader());
+            put(this._runDetailsId(action.runId, 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(action));
+        }
+    }
+    static _drawInteractiveRun(run, put, blank, getY, opts) {
+        const tabs = 40;
+        if (run) {
+            put(this._runDetailsHeader());
+            put(this._runDetailsId(run.runId, 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(run));
+        }
+    }
+    static async _approveRun(client, workspace, project, pipelineId, runId, action, forceFetch) {
+        await client.pipelineRunApply(workspace, project, pipelineId, runId, {
+            operation: 'APPLY',
+            approve_action_id: action.runId,
+        });
+        if (forceFetch)
+            setTimeout(forceFetch, 100);
+    }
+    static async _retryRun(client, workspace, project, pipelineId, runId, forceFetch) {
+        try {
+            await client.pipelineRunRetry(workspace, project, pipelineId, runId);
+            if (forceFetch)
+                setTimeout(forceFetch, 100);
+        }
+        catch (err) {
+            if (err.message !== 'Unable to update/delete pipeline in progress') {
+                throw err;
+            }
+        }
+    }
+    static async _cancelRun(client, workspace, project, pipelineId, runId, forceFetch) {
+        try {
+            await client.pipelineRunCancel(workspace, project, pipelineId, runId);
+            if (forceFetch)
+                setTimeout(forceFetch, 100);
+        }
+        catch (err) {
+            if (err.message !== 'Unable to cancel pipeline execution') {
+                throw err;
+            }
+        }
+    }
+    static async _runLogsInteractive(client, workspace, project, pipelineId, runId, runActionId) {
+        let action = null;
+        let forceFetchAction = () => { };
+        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();
+            }
+            else if (name === 'UP') {
+                opts.actionLogsScroll += 1;
+                draw();
+            }
+            else if (name === 'PAGE_UP') {
+                opts.actionLogsScroll += logsPage;
+                draw();
+            }
+            else if (name === 'PAGE_DOWN') {
+                opts.actionLogsScroll -= logsPage;
+                if (opts.actionLogsScroll < 0)
+                    opts.actionLogsScroll = 0;
+                draw();
+            }
+            else if (name === 'HOME') {
+                opts.actionLogsScroll = actionLogs.length;
+                draw();
+            }
+            else if (name === 'END') {
+                opts.actionLogsScroll = 0;
+                draw();
+            }
+            else if (action &&
+                name.toLowerCase() === 'c' &&
+                this._canCancel(action.status)) {
+                this._cancelRun(client, workspace, project, pipelineId, runId, forceFetchAction)
+                    .then()
+                    .catch((err) => output_1.default.exitError(err));
+            }
+            else if (action &&
+                name.toLowerCase() === 'r' &&
+                this._canRetry(action.status)) {
+                this._retryRun(client, workspace, project, pipelineId, runId, forceFetchAction)
+                    .then()
+                    .catch((err) => output_1.default.exitError(err));
+            }
+            else if (action &&
+                name.toLowerCase() === 'a' &&
+                this._canApprove(action.status)) {
+                this._approveRun(client, workspace, project, pipelineId, runId, action, forceFetchAction)
+                    .then()
+                    .catch((err) => output_1.default.exitError(err));
+            }
+            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, _, ffa) => {
+            action = a;
+            forceFetchAction = ffa;
+            draw();
+        }, true);
+    }
+    static async _runStatusInteractive(client, workspace, project, pipelineId, runId) {
+        let mode = MODE.RUN;
+        let run = null;
+        let forceFetchRun = null;
+        let action = null;
+        let actionLogs = [];
+        let cancelActionFetch = () => { };
+        let forceActionFetch = () => { };
+        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();
+                    forceActionFetch = () => { };
+                    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].runId;
+                    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, ffa) => {
+                        if (cancel)
+                            cancelActionFetch = cancel;
+                        if (a && selectedActionId === a.runId)
+                            action = a;
+                        if (ffa)
+                            forceActionFetch = ffa;
+                        draw();
+                    }, true);
+                    draw();
+                }
+            }
+            else if (run &&
+                name.toLowerCase() === 'c' &&
+                this._canCancel(run.status)) {
+                this._cancelRun(client, workspace, project, pipelineId, runId, mode === MODE.RUN ? forceFetchRun : forceActionFetch)
+                    .then()
+                    .catch((err) => output_1.default.exitError(err));
+            }
+            else if (run &&
+                name.toLowerCase() === 'r' &&
+                this._canRetry(run.status)) {
+                this._retryRun(client, workspace, project, pipelineId, runId, mode === MODE.RUN ? forceFetchRun : forceActionFetch)
+                    .then()
+                    .catch((err) => output_1.default.exitError(err));
+            }
+            else if (run &&
+                name.toLowerCase() === 'a' &&
+                this._canApprove(run.status)) {
+                let a = null;
+                if (mode === MODE.ACTION) {
+                    a = action;
+                }
+                else if (mode === MODE.RUN) {
+                    if (run.actions[opts.selectedActionIndex]) {
+                        a = run.actions[opts.selectedActionIndex];
+                    }
+                    if (!a || !this._canApprove(a.status)) {
+                        a = run.actions.find((a) => this._canApprove(a.status));
+                    }
+                }
+                if (a && this._canApprove(a.status)) {
+                    this._approveRun(client, workspace, project, pipelineId, runId, a, mode === MODE.RUN ? forceFetchRun : forceActionFetch)
+                        .then()
+                        .catch((err) => output_1.default.exitError(err));
+                }
+            }
+            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, ffr) => {
+            run = r;
+            forceFetchRun = ffr;
+            draw();
+        }, true);
+    }
+    static _exitByStatus(isJson, status) {
+        if (status &&
+            [pipeline_1.PIPELINE_RUN_STATUS.FAILED, pipeline_1.PIPELINE_RUN_STATUS.TERMINATED].includes(status)) {
+            if (isJson)
+                this.jsonExit(1);
+            process.exit(1);
+        }
+        else {
+            if (isJson)
+                this.jsonExit(0);
+            process.exit(0);
+        }
+    }
+    static jsonExit(code) {
+        output_1.default.json({ type: 'exit', code });
+    }
+    static jsonInfo(message) {
+        output_1.default.json({ type: 'info', message });
+    }
+    static jsonAction(action) {
+        output_1.default.json({ type: 'action', action });
+    }
+    static jsonRun(run) {
+        output_1.default.json({ type: 'run', run });
+    }
+    static jsonLog(log) {
+        output_1.default.json({ type: 'log', log });
+    }
+    static async _runLogsNonInteractive(client, workspace, project, pipelineId, runId, runActionId, noWait, isJson) {
+        let action = null;
+        let actionLogsStart = 0;
+        let lastActionLogsStart = -1;
+        let drawnStart = false;
+        let logsEnd = false;
+        let totalFetchesCount = 0;
+        const tabs = 40;
+        if (noWait) {
+            const msg = 'Fetching action and not waiting to finish...';
+            if (isJson) {
+                this.jsonInfo(msg);
+            }
+            else {
+                output_1.default.getTerminal().gray(msg);
+                output_1.default.newline();
+                output_1.default.newline();
+            }
+        }
+        else {
+            const msg = 'Fetching action and following changes...';
+            if (isJson) {
+                this.jsonInfo(msg);
+            }
+            else {
+                output_1.default.getTerminal().gray(msg);
+                output_1.default.newline();
+                output_1.default.newline();
+            }
+        }
+        const draw = (logs) => {
+            if (!drawnStart && action) {
+                if (isJson) {
+                    this.jsonAction(action);
+                }
+                else {
+                    output_1.default.normal(this._runDetailsHeader());
+                    output_1.default.normal(this._runDetailsId(action.runId, 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) {
+                    if (isJson) {
+                        this.jsonLog(logs[actionLogsStart]);
+                    }
+                    else {
+                        output_1.default.normal(output_1.default.getTermKitDimColor(`  ${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 || logs.length < LOGS_LIMIT)) {
+                    logsEnd = true;
+                }
+                lastActionLogsStart = actionLogsStart;
+            }
+            if (logsEnd || (drawnStart && noWait && logs)) {
+                if (isJson) {
+                    if (action)
+                        this.jsonAction(action);
+                }
+                else {
+                    if (logsEnd && action?.outputtedVariables.length) {
+                        output_1.default.normal('');
+                        output_1.default.normal(this._runOutputHeader());
+                        output_1.default.normal(output_1.default.getTermKitDimColor('  Variables     '), false);
+                        action.outputtedVariables.forEach((v, i) => {
+                            let line = '';
+                            if (i > 0)
+                                line += '                ';
+                            line += output_1.default.getTermKitMutedColor(v.key);
+                            line += output_1.default.getTermKitDimColor(` = "`);
+                            line += output_1.default.getTermKitBlueColor(v.value);
+                            line += output_1.default.getTermKitDimColor('"');
+                            output_1.default.normal(line);
+                        });
+                    }
+                    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);
+                        }
+                    }
+                }
+                this._exitByStatus(isJson, action?.status);
+            }
+        };
+        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, identifier, pipelineId, runId, noWait, noFollow, isJson) {
+        let run = null;
+        let totalFetchesCount = 0;
+        const tabs = 40;
+        if (noWait) {
+            const msg = 'Fetching execution and not waiting to finish...';
+            if (isJson) {
+                this.jsonInfo(msg);
+            }
+            else {
+                output_1.default.getTerminal().gray(msg);
+                output_1.default.newline();
+                output_1.default.newline();
+            }
+        }
+        else if (noFollow) {
+            const msg = 'Fetching execution and waiting for finish...';
+            if (isJson) {
+                this.jsonInfo(msg);
+            }
+            else {
+                output_1.default.getTerminal().gray(msg);
+                output_1.default.newline();
+                output_1.default.newline();
+            }
+        }
+        else {
+            const msg = 'Fetching execution and following changes...';
+            if (isJson) {
+                this.jsonInfo(msg);
+            }
+            else {
+                output_1.default.getTerminal().gray(msg);
+                output_1.default.newline();
+                output_1.default.newline();
+            }
+        }
+        const draw = (r) => {
+            if (!run) {
+                output_1.default.normal(this._runDetailsHeader());
+                output_1.default.normal(this._runDetailsId(r.runId, 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;
+            if (!noFollow || noWait) {
+                if (isJson)
+                    this.jsonRun(run);
+                else
+                    draw(run);
+            }
+            if (noWait) {
+                this._exitByStatus(isJson, run.status);
+            }
+        });
+        if (isJson) {
+            this.jsonRun(run);
+            this.jsonInfo(this._jsonActionsLogsHelp(identifier, runId));
+        }
+        else {
+            if (totalFetchesCount > 1 || noFollow) {
+                if (!noFollow)
+                    output_1.default.normal('');
+                output_1.default.normal(this._runDetailsHeader());
+                if (noFollow) {
+                    output_1.default.normal(this._runDetailsId(run.runId, tabs));
+                    output_1.default.normal(this._runHtmlUrl(run.url, tabs));
+                }
+                output_1.default.normal(this._runDetailsStatus(run.status, run.started, run.finished, tabs));
+                if (noFollow) {
+                    output_1.default.normal(this._runDetailsTriggerer(run, tabs));
+                    if (run?.description)
+                        output_1.default.normal(this._runDetailsDescription(run, 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);
+                if (noFollow) {
+                    const context = this._runContext(run, 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(run, true, 0, -1, tabs);
+                    actions.forEach((str) => {
+                        output_1.default.normal(str);
+                    });
+                }
+            }
+            output_1.default.normal(this._dimLine());
+            output_1.default.normal(this._runActionsLogsHelp(identifier, runId));
+        }
+        this._exitByStatus(isJson, run.status);
+    }
+    static async _actionLogsLoop(client, workspace, project, pipelineId, runId, actionExecutionId, onChange) {
+        let logs = [];
+        let offset = 0;
+        let shouldCancel = false;
+        const cancel = () => {
+            shouldCancel = true;
+        };
+        onChange(logs, cancel);
+        const fetchLogs = async () => {
+            return await client.getPipelineRunActionLogs(workspace, project, pipelineId, runId, actionExecutionId, offset, LOGS_LIMIT);
+        };
+        for (;;) {
+            let o = await fetchLogs();
+            if (o.total_element_count < offset) {
+                logs = [];
+                offset = 0;
+                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, dontExit = false) {
+        const fetchAction = async () => {
+            return await client.getPipelineRunActionExecution(workspace, project, pipelineId, runId, actionExecutionId);
+        };
+        let status = pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+        let oldStatus = null;
+        let shouldCancel = false;
+        const cancel = () => {
+            shouldCancel = true;
+        };
+        const forceFetchAction = async () => {
+            const a = await fetchAction();
+            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);
+            status = a.status || pipeline_1.PIPELINE_RUN_STATUS.INITIAL;
+            const name = a.action?.name || '';
+            const actionId = a.action?.id || -1;
+            const url = a.html_url || '';
+            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];
+            }
+            let target = null;
+            if (a.target)
+                target = a.target;
+            let outputtedVariables = [];
+            if (a.outputted_variables) {
+                outputtedVariables = [];
+                a.outputted_variables.forEach((v) => {
+                    outputtedVariables.push({
+                        key: String(v.key),
+                        value: String(v.value),
+                    });
+                });
+            }
+            let loop = LOOP_STATUS.DISABLED;
+            let loopValues = [];
+            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),
+                            });
+                    });
+                }
+            }
+            const changed = !oldStatus || status !== oldStatus;
+            const action = {
+                runId: actionExecutionId,
+                id: actionId,
+                url,
+                status,
+                target,
+                loop,
+                loopValues,
+                outputtedVariables,
+                started,
+                finished,
+                name,
+                type,
+                changed,
+            };
+            onChange(action, cancel, forceFetchAction);
+            return action;
+        };
+        await forceFetchAction();
+        for (;;) {
+            await (0, utils_1.sleep)(3000);
+            if (shouldCancel)
+                return;
+            await forceFetchAction();
+            oldStatus = status;
+            if (!dontExit &&
+                [
+                    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;
+        }
+    }
+    static async _runStatusLoop(client, workspace, project, pipelineId, runId, onChange, dontExit = false) {
+        let lastRun;
+        const fetchRun = async () => {
+            return await client.getPipelineRun(workspace, project, pipelineId, runId);
+        };
+        const id = 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 = [];
+        const forceFetchRun = async () => {
+            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.runId === id);
+                    const changed = !oldAction || oldAction.status !== status;
+                    const action = {
+                        type,
+                        name,
+                        url,
+                        loop,
+                        loopValues,
+                        outputtedVariables,
+                        target,
+                        id: actionId,
+                        runId: id,
+                        status,
+                        started,
+                        finished,
+                        changed,
+                    };
+                    return action;
+                });
+                actions = actions.filter((a) => {
+                    if (a.target)
+                        return true;
+                    return !actions.find((a2) => {
+                        if (a2.runId === a.runId)
+                            return false;
+                        if (a2.id !== a.id)
+                            return false;
+                        return !!a2.target;
+                    });
+                });
+            }
+            const r = {
+                runId: id,
+                creator,
+                description,
+                started,
+                url,
+                status,
+                trigger,
+                finished,
+                clearCache,
+                refresh,
+                priority,
+                delayed,
+                context,
+                actions,
+            };
+            onChange(r, forceFetchRun);
+            return r;
+        };
+        lastRun = await forceFetchRun();
+        for (;;) {
+            if (!dontExit &&
+                [
+                    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(lastRun.status)) {
+                break;
+            }
+            await (0, utils_1.sleep)(3000);
+            lastRun = await forceFetchRun();
+        }
+        return lastRun;
+    }
+}
+exports.default = OutputPipeline;