@codiac.io/codiac-cli 1.2.217 → 1.2.219

package/lib/commands/asset/view.js

@@ -0,0 +1,1365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStreamer = exports.K8sContainerRef = exports.TermArgs = exports.ConfigFileArgs = exports.ExecArgs = exports.K8S_POD_PHASES = exports.InteractionModes = exports.AssetContentType = exports.PROMPT_ME_DESIGNATOR = void 0;
+const tslib_1 = require("tslib");
+//import * as path from 'path';
+const stream = require("stream");
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const SplitCmd = require('split-cmd');
+const request = require("request");
+const semver = require("semver");
+const k8s = require("@kubernetes/client-node");
+const codiac_relay_contracts_1 = require("@codiac.io/codiac-relay-contracts");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+const render = require("../../uilogic/render-methods");
+const cloud_provider_contextualizer_1 = require("../../uilogic/cloud-provider-contextualizer");
+const client_node_1 = require("@kubernetes/client-node");
+const web_socket_handler_1 = require("@kubernetes/client-node/dist/web-socket-handler");
+const codiac_ops_common_1 = require("@codiac.io/codiac-ops-common");
+// let logUpdate: any;
+// (async function () {
+//   logUpdate = (await import("log-update")).default;
+// })()
+// import * as logUpdate from "log-update";
+// import logUpdate from "log-update";
+// const logUpdate = (await import("log-update/index.js")).default
+// import { logUpdate } from "log-update";
+// const logUpdate = require("log-update");
+const log_update_wrapper_1 = require("../../log-update-wrapper");
+const codiac_constants_1 = require("../../codiac-constants");
+// const { selectFiles, COMPLETED, CANCELLED } = require('select-files-cli');  // gd js wo ts...
+// const { selectFiles, COMPLETED, CANCELLED } = require('../../uilogic/file-selector');  // gd js wo ts...
+/** The value provided as input that indicates
+ * a user's desire to be prompted with a list from which choose the value(s),
+ * instead of entering them manually or taking a default. */
+exports.PROMPT_ME_DESIGNATOR = "?";
+var AssetContentType;
+(function (AssetContentType) {
+    AssetContentType["logs"] = "logs";
+    AssetContentType["term"] = "term";
+    AssetContentType["exec"] = "exec";
+    AssetContentType["env"] = "env";
+    AssetContentType["config"] = "config";
+    AssetContentType["status"] = "status";
+    // | "footprint-usage" | "infrx" 
+    // | "ingress-domains" | "ingress-nslookup" | "ingress-routes" | "ingress-logs" | "ssl-certs" | "ssl-logs" | "ssl-cert-history";
+})(AssetContentType = exports.AssetContentType || (exports.AssetContentType = {}));
+const DEFAULT_TERMINAL_STARTER = "bash";
+/** The quantity of lines of backlog to include in the log output. */
+const DEFAULT_LOG_TAIL = 10;
+var InteractionModes;
+(function (InteractionModes) {
+    InteractionModes["echo"] = "echo";
+    InteractionModes["toscript"] = "toscript";
+    InteractionModes["silent"] = "silent";
+})(InteractionModes = exports.InteractionModes || (exports.InteractionModes = {}));
+/** This belongs to k8s - not us, but @kubernetes/client-node has no enum or constants for these magic strings...
+ *
+ * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase
+*/
+var K8S_POD_PHASES;
+(function (K8S_POD_PHASES) {
+    K8S_POD_PHASES["Pending"] = "Pending";
+    K8S_POD_PHASES["Running"] = "Running";
+    K8S_POD_PHASES["Succeeded"] = "Succeeded";
+    K8S_POD_PHASES["Failed"] = "Failed";
+    K8S_POD_PHASES["Unknown"] = "Unknown";
+})(K8S_POD_PHASES = exports.K8S_POD_PHASES || (exports.K8S_POD_PHASES = {}));
+class AssetView extends command_base_enterprise_1.CommandBaseEnterprise {
+    constructor() {
+        super(...arguments);
+        this.takeDefaults = false;
+    }
+    get uiCloudPvd() {
+        if (this._uiCloudPvd_backer === undefined) {
+            this._uiCloudPvd_backer = this.ioc.get(cloud_provider_contextualizer_1.CloudProviderContextualizer);
+        }
+        return this._uiCloudPvd_backer;
+    }
+    bootstrap() {
+        super.bootstrap();
+        cloud_provider_contextualizer_1.CloudProviderContextualizer.bootstrap(this.ioc); // (idempotent) this is a dependency of the configurators
+    }
+    run() {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                // ==================================================
+                // 1. Bootstrap
+                // ==================================================
+                this.bootstrap();
+                // this._relayContainer?.ready$
+                //   .subscribe(async (ready: boolean) => {
+                // ==================================================
+                // 2. Gather cli input
+                // ==================================================
+                const { args, flags } = yield this.parse(AssetView);
+                const interactionMode = (_b = (_a = (flags.echo ? InteractionModes.echo : undefined)) !== null && _a !== void 0 ? _a : (flags.toscript ? InteractionModes.toscript : undefined)) !== null && _b !== void 0 ? _b : (flags.silent ? InteractionModes.silent : undefined);
+                this.takeDefaults = (_c = flags.takeDefaults) !== null && _c !== void 0 ? _c : false;
+                let partialReq = {};
+                partialReq.enterprise = flags.enterprise;
+                partialReq.asset = flags.asset;
+                partialReq.environment = flags.environment;
+                partialReq.cabinet = flags.cabinet;
+                partialReq.content = (flags.type) ? AssetContentType[flags.type] : undefined;
+                partialReq.replica = flags.replica;
+                let givenCmd;
+                if (args.cmd) {
+                    givenCmd = args.cmd;
+                    let isep = this.argv.indexOf("--");
+                    if (isep >= 0) {
+                        if (isep + 1 < this.argv.length) {
+                            givenCmd = this.argv.slice(isep + 1);
+                        }
+                        else {
+                            givenCmd = undefined;
+                        }
+                    }
+                }
+                let contentOptions = {
+                    follow: flags.logsFollow,
+                    tailLines: flags.logsTail,
+                    /* tty: flags.tty, */
+                    command: givenCmd,
+                    terminalStartup: flags.terminal,
+                    rootPathName: flags.configFile
+                };
+                // ==================================================
+                // 3. Assemble candidate
+                // ==================================================
+                let candidate;
+                let cmd;
+                if (interactionMode == InteractionModes.silent) {
+                    candidate = yield this.buildCandidate_silently(partialReq, partialReq.content, contentOptions);
+                }
+                else {
+                    [candidate, cmd] = yield this.buildCandidate_interactively(partialReq, contentOptions, partialReq.content);
+                }
+                // ==================================================
+                // 4. Render ultimate command string
+                // ==================================================
+                if (interactionMode == InteractionModes.echo || interactionMode == InteractionModes.toscript) {
+                    if (cmd && cmd.length > 0) {
+                        this._ui.userMessage(cmd.join(" "));
+                    }
+                }
+                // ==================================================
+                // 5. Execute
+                // ==================================================
+                if (interactionMode != InteractionModes.toscript) {
+                    yield this.renderSelectedContent(candidate.context, candidate.contentType, candidate.k8sEntities, candidate.contentOptions, candidate.replicas);
+                }
+                //    return;
+                //   });
+                return;
+            }
+            catch (err) {
+                this.handleError(err);
+                throw err;
+            }
+        });
+    }
+    buildCandidate_silently(partialReq, content, contentOptions) {
+        var _a, _b, _c, _d, _e, _f;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.__ui = new codiac_ops_common_1.ThrowingUserInputProvider(this.logger);
+            if (content === undefined || _.isEmpty(partialReq.content))
+                throw new Error(`No content type specified.`);
+            if (partialReq.enterprise === undefined || _.isEmpty(partialReq.enterprise))
+                throw new Error(`No enterprise specified.`);
+            if (partialReq.asset === undefined || _.isEmpty(partialReq.asset))
+                throw new Error(`No asset specified.`);
+            if (partialReq.environment === undefined || _.isEmpty(partialReq.environment))
+                throw new Error(`No environment specified.`);
+            if (partialReq.cabinet === undefined || _.isEmpty(partialReq.cabinet))
+                throw new Error(`No cabinet specified.`);
+            // Replica should not be required 
+            // (though this can be confusing when there's more than one; 
+            // the user will have to know they're only getting a single replica of logs, 
+            // and they need to know they might have to call out for one.
+            // if (partialReq.replica === undefined || _.isEmpty(partialReq.replica)) throw new Error(`No replica specified.`);
+            let options;
+            switch (partialReq.content) {
+                case AssetContentType.logs:
+                    options = (contentOptions !== null && contentOptions !== void 0 ? contentOptions : {});
+                    // defaults?
+                    break;
+                case AssetContentType.exec:
+                    if (_.isEmpty(contentOptions.command))
+                        throw new Error(`No command specified.`);
+                    options = {
+                        command: contentOptions.command,
+                        tty: (_a = contentOptions.tty) !== null && _a !== void 0 ? _a : false
+                    };
+                    break;
+                case AssetContentType.config:
+                    if (_.isEmpty(contentOptions.rootPathName))
+                        throw new Error(`No file specified.`);
+                    options = {
+                        rootPathName: contentOptions.rootPathName
+                    };
+                    break;
+                case AssetContentType.term:
+                    options = {
+                        terminalStartup: (_b = contentOptions.terminalStartup) !== null && _b !== void 0 ? _b : DEFAULT_TERMINAL_STARTER
+                    };
+                    break;
+                case AssetContentType.env: /* env has no user input */
+                default:
+                    options = {};
+                    break;
+            }
+            // Retrieve the list of replicas for the given cabinet.
+            let rootMap = yield this.getRootMap(partialReq.enterprise);
+            let env = this.deriveEnvironmentFrom(partialReq.enterprise, partialReq.cabinet, rootMap); // this is fkng stupid.  Put this value into the cab value
+            let cabObj = this.getCabinetInfrx(partialReq.enterprise, env.name, partialReq.cabinet, rootMap);
+            if (cabObj.infrx == undefined || _.isEmpty(cabObj.infrx))
+                throw new Error(`Cannot connect to cabinet ${cabObj.name}: it has no infrastructure record.`);
+            let k8sObj = { namespace: cabObj.infrx.namespace };
+            let replicas = yield this.fetchReplicas(partialReq, cabObj.infrx.namespace);
+            if (replicas.length > 0) {
+                // Set first as default
+                partialReq.replica = (_d = (_c = replicas[0].metadata) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : "unnamed";
+                k8sObj = {
+                    namespace: cabObj.infrx.namespace,
+                    pod: partialReq.replica,
+                    container: (_f = (_e = replicas[0].spec) === null || _e === void 0 ? void 0 : _e.containers[0].name) !== null && _f !== void 0 ? _f : "unnamed"
+                };
+                // Select a replica unless it's an asset-level operation
+                if (content !== AssetContentType.status) {
+                    // This method falls back to first found as default, throws if not enough info is provided
+                    k8sObj = yield this.promptForReplica(replicas, undefined, partialReq.replica);
+                    partialReq.replica = k8sObj.pod;
+                }
+            }
+            // Assemble 
+            let candidate = {
+                context: {
+                    enterprise: partialReq.enterprise,
+                    environment: partialReq.environment,
+                    asset: partialReq.asset,
+                    cabinet: partialReq.cabinet,
+                    replica: partialReq.replica
+                },
+                contentType: content,
+                contentOptions: options,
+                k8sEntities: k8sObj,
+                replicas: replicas
+            };
+            return candidate;
+        });
+    }
+    buildCandidate_interactively(partialReq, contentOptions, content) {
+        var _a, _b, _c, _d;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this._userCntx = yield this.establishTenantContext(this._userCntx);
+            let enterprise = (yield this.establishEnterpriseContext()).enterprise;
+            partialReq.enterprise = enterprise.code;
+            let rootMap = yield this.getRootMap(enterprise.code);
+            let replicas;
+            let k8sObj;
+            let confirmed = false;
+            let optionsArgs = [];
+            do {
+                // 1.  Select Asset
+                partialReq.asset = yield this.promptForAsset(enterprise.assets, partialReq.asset);
+                // 2. Cabinet
+                let cabObj = yield this.promptForCabinet(partialReq.enterprise, rootMap, partialReq.cabinet);
+                partialReq.cabinet = cabObj.name;
+                partialReq.environment = this.deriveEnvironmentFrom(partialReq.enterprise, partialReq.cabinet, rootMap).name;
+                let cluster = this.deriveClusterFrom(partialReq.enterprise, partialReq.environment, partialReq.cabinet, rootMap);
+                // partialReq.cabinet = await this.establishCabinetContext(partialReq.cabinet);  
+                if (cabObj.infrx == undefined || _.isEmpty(cabObj.infrx))
+                    throw new Error(`Cannot connect to cabinet ${cabObj.name}: it has no infrastructure record.`);
+                k8sObj = { namespace: cabObj.infrx.namespace };
+                // 3. Content type
+                content = yield this.promptForContentType(content);
+                // 4. Content-specific arguments
+                // MarkStartHere("implement prompt-me designator.")
+                // MarkStartHere("Support the current logger or ioc ctr inside the ws event handlers");
+                // MarkStartHere("Need UI to operate a different stream than stdout (so piping stdout wont include the ui content");
+                [contentOptions, optionsArgs] = yield this.promptForContentOptions(content, partialReq, contentOptions);
+                // 5. Authenticate with CSP
+                this.uiCloudPvd.takeDefaults = this.takeDefaults;
+                yield this.uiCloudPvd.promptForCloudProviderCreds(this.ioc, cluster.provider);
+                // 6. Replica (Pod)
+                if (cabObj.infrx == undefined || _.isEmpty(cabObj.infrx))
+                    throw new Error(`Cannot connect to cabinet ${cabObj.name}: it has no infrastructure record.`);
+                replicas = yield this.fetchReplicas(partialReq, cabObj.infrx.namespace);
+                if (replicas.length > 0) {
+                    // Set first as default
+                    partialReq.replica = (_b = (_a = replicas[0].metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unnamed";
+                    k8sObj = {
+                        namespace: cabObj.infrx.namespace,
+                        pod: partialReq.replica,
+                        container: (_d = (_c = replicas[0].spec) === null || _c === void 0 ? void 0 : _c.containers[0].name) !== null && _d !== void 0 ? _d : "unnamed"
+                    };
+                    // Select a replica unless it's an asset-level operation
+                    if (content !== AssetContentType.status) {
+                        k8sObj = yield this.promptForReplica(replicas, undefined, partialReq.replica);
+                        partialReq.replica = k8sObj.pod;
+                    }
+                }
+                // 7. Confirm or loop back around to enterprise
+                confirmed = true; // This is a readonly ui (no danger), and we want to enable fast switching among diff content types, so let's not waste time confirming.  // await this._ui.promptConfirm("confirm", "Apply? ");
+            } while (!confirmed);
+            // We're hard-coding instead of casting here to validate at build-time that each partial property is fully-hydrated.
+            // Assemble 
+            let candidate = {
+                context: {
+                    enterprise: partialReq.enterprise,
+                    environment: partialReq.environment,
+                    asset: partialReq.asset,
+                    cabinet: partialReq.cabinet,
+                    replica: partialReq.replica
+                },
+                contentType: content,
+                contentOptions: contentOptions,
+                k8sEntities: k8sObj,
+                replicas: replicas
+            };
+            // Build command string
+            let cmd = ["cod", "asset", "view"];
+            cmd.push("--silent");
+            cmd.push("-e", candidate.context.enterprise);
+            cmd.push("-a", candidate.context.asset);
+            cmd.push("-n", candidate.context.environment);
+            cmd.push("-c", candidate.context.cabinet);
+            if (candidate.context.replica)
+                cmd.push("-r", candidate.context.replica);
+            cmd.push("-t", candidate.contentType);
+            cmd.push(...optionsArgs);
+            return [candidate, cmd];
+        });
+    }
+    promptForContentOptions(contentType, context, defaults) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let cmdArgs = [];
+            try {
+                switch (contentType) {
+                    case AssetContentType.logs:
+                        let logArgs = yield this.promptForLogOptions(defaults);
+                        if (logArgs.follow)
+                            cmdArgs.push("-f");
+                        if (logArgs.tailLines)
+                            cmdArgs.push(...["-l", "" + logArgs.tailLines]);
+                        return [logArgs, cmdArgs];
+                    case AssetContentType.exec:
+                        let execArgs = yield this.promptForExecOptions(defaults);
+                        cmdArgs.push(...execArgs.command);
+                        return [execArgs, cmdArgs];
+                    case AssetContentType.config:
+                        this.enterpriseContextor.takeDefaults = this.takeDefaults;
+                        let rootPathName = (yield this.enterpriseContextor.promptForTargetFile(context.enterprise, context.asset, defaults === null || defaults === void 0 ? void 0 : defaults.rootPathName));
+                        let cfgArgs = { rootPathName: rootPathName };
+                        cmdArgs.push("-F", rootPathName);
+                        return [cfgArgs, cmdArgs];
+                    case AssetContentType.term:
+                        let termArgs = yield this.promptForTerminalOptions(defaults);
+                        if (termArgs.terminalStartup)
+                            cmdArgs.push(...["--terminal", termArgs.terminalStartup]);
+                        return [termArgs, cmdArgs];
+                    default:
+                        return [{}, []];
+                }
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    promptForLogOptions(defaults) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let options = (defaults !== null && defaults !== void 0 ? defaults : {});
+            options.follow = (_a = options.follow) !== null && _a !== void 0 ? _a : true;
+            if (!this.takeDefaults) {
+                options.follow = yield this._ui.promptConfirm("follow", "Stream logs? ", options.follow);
+            }
+            options.tailLines = (_b = options.tailLines) !== null && _b !== void 0 ? _b : DEFAULT_LOG_TAIL;
+            if (!this.takeDefaults) {
+                options.tailLines = yield this._ui.prompt("tail", "Lines of backlog (-1 for all):", true, options.tailLines);
+            }
+            return options;
+        });
+    }
+    promptForExecOptions(defaults) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let options = (defaults !== null && defaults !== void 0 ? defaults : {});
+            // Command
+            let cmdStr;
+            let keep = this.takeDefaults;
+            if (!_.isEmpty(options.command) && !this.takeDefaults) {
+                cmdStr = (typeof options.command === 'string') ? options.command : options.command.join(" ");
+                keep = yield this._ui.promptConfirm("keepCommand", `Command: ${this._styler.hilite(cmdStr)} `);
+            }
+            if (keep && !_.isEmpty(options.command)) {
+                // do nothing
+            }
+            else {
+                options.command = (yield this._ui.prompt("command", "Command: ", true, cmdStr));
+                options.command = SplitCmd.split(options.command); // no types declarations - f#$&*ing script kiddie.
+                // the one above trips on the --output flag in this:   kubectl get pods -n cod-zombie-v1 -l assetNamme=codiac-api --output=jsonpath="{.items[*]['metadata.name', 'status.capacity']}"
+                // something safer than: options.command = options.command.split(" ");
+            }
+            return options;
+        });
+    }
+    promptForTerminalOptions(defaults) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let options = (defaults !== null && defaults !== void 0 ? defaults : {});
+            // Command
+            let keep = this.takeDefaults;
+            if (!_.isEmpty(options.terminalStartup) && !this.takeDefaults) {
+                keep = yield this._ui.promptConfirm("keepStartup", `Terminal Startup: ${this._styler.hilite(options.terminalStartup)} `);
+            }
+            if (keep && !_.isEmpty(options.terminalStartup)) {
+                // do nothing
+            }
+            else {
+                options.terminalStartup = (yield this._ui.prompt("startup", "Terminal Startup: ", true, options.terminalStartup));
+            }
+            return options;
+        });
+    }
+    promptForContentType(defaultValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let output;
+                let choices = Object.keys(AssetContentType);
+                let keep = this.takeDefaults;
+                if (defaultValue && choices.find(x => x == defaultValue) && !this.takeDefaults) {
+                    keep = yield this._ui.promptConfirm("keepType", `Type of content: ${this._styler.hilite(defaultValue)} `);
+                }
+                if (keep && defaultValue !== undefined) {
+                    output = defaultValue;
+                }
+                else {
+                    output = (yield this._ui.promptSelect("type", "Type of content: ", choices));
+                }
+                return output;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    promptForAsset(assets, defaultValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let output;
+                let choices = assets.map(a => { return { name: a.name, value: a.name }; });
+                choices = _.orderBy(choices, c => c.name);
+                /** If we changed the input they provided, we need their confirmation (whether or not they said takeDefaults)  */
+                let changedUserInput = false;
+                if (choices.length === 1) {
+                    if (defaultValue != choices[0].value) {
+                        changedUserInput = !_.isEmpty(defaultValue);
+                        defaultValue = choices[0].value;
+                    }
+                }
+                let keep = this.takeDefaults;
+                if (defaultValue && choices.find(x => x.value == defaultValue) && (changedUserInput || !this.takeDefaults)) {
+                    keep = yield this._ui.promptConfirm("keepAsset", `Asset: ${this._styler.hilite(defaultValue)} `);
+                }
+                if (keep && defaultValue !== undefined) {
+                    output = defaultValue;
+                }
+                else {
+                    output = (yield this._ui.promptSelect("asset", "Asset: ", choices));
+                }
+                return output;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    promptForCabinet(enterprise, rootMap, defaultValue) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let output;
+                // render cab tree with all lines selectable
+                let cabTree = this.buildCabinetTree(rootMap);
+                let choices = this.buildSelectChoicesFrom(cabTree);
+                // ISSUES:
+                // 0. Remove the freaking lines from the selected value.
+                // 1. Remember the last cabinet (user's enterprise context).
+                // 2. We should only render the cabinets that actually contain a deployment of the asset (or dim the others and loop back if selected)
+                // 3. The picklist should render the cluster (provider, name, location) 
+                // 4. PERHAPS?  The version of the asset running in the selected cabinet should get rendered (either in the picklist or after the cab is selected)
+                /** If we changed the input they provided, we need their confirmation (whether or not they said takeDefaults)  */
+                const CAB_PREFIX = "cabinet|";
+                let cabChoices = choices.filter(c => c.value.startsWith(CAB_PREFIX));
+                let changedUserInput = false;
+                if (cabChoices.length === 1) {
+                    if (defaultValue != cabChoices[0].value.slice(CAB_PREFIX.length)) {
+                        changedUserInput = !_.isEmpty(defaultValue);
+                        defaultValue = cabChoices[0].value.slice(CAB_PREFIX.length);
+                    }
+                }
+                let keep = this.takeDefaults;
+                if (defaultValue && Boolean(choices.find(x => x.value === `${CAB_PREFIX}${defaultValue}`)) && (changedUserInput || !this.takeDefaults)) {
+                    keep = yield this._ui.promptConfirm("keepCabinet", `Cabinet: ${this._styler.hilite(defaultValue)} `);
+                }
+                if (keep && defaultValue !== undefined) {
+                    output = defaultValue;
+                }
+                else {
+                    let scope;
+                    let target;
+                    do {
+                        if (scope === "environment") {
+                            // we could just filter it down from here...
+                        }
+                        let selection = (yield this._ui.promptSelect("cabinet", "Cabinet: ", choices, false, false));
+                        let parts = selection.split("|");
+                        scope = parts[0];
+                        target = parts[1];
+                    } while (scope !== "cabinet"); // ensure they select a cabinet
+                    output = target;
+                }
+                let env = this.deriveEnvironmentFrom(enterprise, output, rootMap); // this is fkng stupid.  Put this value into the cab value
+                let cabObj = this.getCabinetInfrx(enterprise, env.name, output, rootMap);
+                // return output;
+                return cabObj;
+            }
+            catch (err) {
+                throw (err);
+            }
+        });
+    }
+    deriveEnvironmentFrom(enterprise, cabinet, rootMap) {
+        try {
+            let ent = rootMap.enterprises.find(e => e.name === enterprise);
+            if (ent === undefined)
+                throw new Error(`Cannot find environment: did not recognize enterprise [${enterprise}]`);
+            let enviro = ent.environments.find(x => x.cabinets.find(c => c.name === cabinet));
+            if (enviro === undefined)
+                throw new Error(`Cannot find environment: did not recognize cabinet [${cabinet}]`);
+            return enviro;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    deriveClusterFrom(enterprise, environment, cabinet, rootMap) {
+        try {
+            let ent = rootMap.enterprises.find(e => e.name === enterprise);
+            if (ent === undefined)
+                throw new Error(`Cannot find cluster: did not recognize enterprise [${enterprise}]`);
+            let enviro = ent.environments.find(x => x.cabinets.find(c => c.name === cabinet));
+            if (enviro === undefined)
+                throw new Error(`Cannot find cluster: did not recognize cabinet [${cabinet}]`);
+            let cabObj = enviro.cabinets.find(c => c.name === cabinet);
+            if (cabObj == undefined)
+                throw new Error(`Cannot find cluster: did not recognize cabinet [${cabinet}]`);
+            if (cabObj.cluster == undefined)
+                throw new Error(`Cannot find cluster: cabinet [${cabinet}] does not have a cluster specified.`);
+            let cluster = rootMap.clusters.find(c => c.name == cabObj.cluster);
+            if (cluster == undefined)
+                throw new Error(`Did not recognize cluster [${cabObj.cluster}]`);
+            return cluster;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    buildSelectChoicesFrom(tree) {
+        try {
+            let choices = [];
+            // the value is no good here - need scope and target both available
+            render.renderStringTree(tree, (txt, item) => choices.push({ name: txt, value: item.value }));
+            // // This is one way to do it
+            // for (let item of tree) {
+            // 
+            //   let thisChoice: PromptChoice = { name: item.text, value: item.text };
+            //   choices.push(thisChoice);
+            // 
+            //   if (item.children && item.children.length > 0) {
+            //     let children = this.buildSelectChoicesFrom(item.children);
+            //     choices.push(...children);
+            //   }
+            // }
+            return choices;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    /** sets each value to "scope|target".
+     *
+     * This is MOSTLY a COPY-PASTE from the CabinetList command!!!  This view is prob gonna be pretty common - consider promoting it to a shared utility. */
+    buildCabinetTree(rootMap, existings) {
+        var _a, _b, _c, _d;
+        let tree = [];
+        for (let ent of rootMap.enterprises) {
+            let entBranch = { text: `${ent.name} enterprise:`, value: `${codiac_relay_contracts_1.ScopeLevel.enterprise}|${ent.name}` };
+            let entSetting = existings === null || existings === void 0 ? void 0 : existings.find(s => s.scope === codiac_relay_contracts_1.ScopeLevel.enterprise && s.target === ent.name);
+            if (entSetting !== undefined) {
+                let valueSuffix = this.ellipsis(35, (_a = entSetting.value) !== null && _a !== void 0 ? _a : "[set to undefined]");
+                valueSuffix = `(${valueSuffix})`;
+                entBranch.text = entBranch.text.concat(" ", this._styler.dim(valueSuffix));
+            }
+            for (let env of _.sortBy(ent.environments, e => e.sequence, e => e.name)) {
+                let envBranch = { text: `${env.name}`, value: `${codiac_relay_contracts_1.ScopeLevel.environment}|${env.name}` };
+                let envSetting = existings === null || existings === void 0 ? void 0 : existings.find(s => s.scope === codiac_relay_contracts_1.ScopeLevel.environment && s.target === env.name);
+                if (envSetting !== undefined) {
+                    let valueSuffix = this.ellipsis(35, (_b = envSetting.value) !== null && _b !== void 0 ? _b : "[set to undefined]");
+                    valueSuffix = `(${valueSuffix})`;
+                    envBranch.text = envBranch.text.concat(" ", this._styler.dim(valueSuffix));
+                }
+                for (let cab of env.cabinets) {
+                    // let cwg = rootMap.clusters.find(c => c.name === cab.cluster);
+                    // let clusterDesc = cwg ? ` (${cab.cluster}, ${cwg.provider} ${cwg.locationName})` : "";
+                    let cabBranch = {
+                        text: `${cab.name}`,
+                        value: `${codiac_relay_contracts_1.ScopeLevel.cabinet}|${cab.name}`
+                    };
+                    let cabSetting = existings === null || existings === void 0 ? void 0 : existings.find(s => s.scope === codiac_relay_contracts_1.ScopeLevel.cabinet && s.target === cab.name);
+                    if (cabSetting !== undefined) {
+                        let valueSuffix = this.ellipsis(35, (_c = cabSetting.value) !== null && _c !== void 0 ? _c : "[set to undefined]");
+                        valueSuffix = `(${valueSuffix})`;
+                        cabBranch.text = cabBranch.text.concat(" ", this._styler.dim(valueSuffix));
+                    }
+                    if (envBranch.children === undefined)
+                        envBranch.children = [];
+                    (_d = envBranch.children) === null || _d === void 0 ? void 0 : _d.push(cabBranch);
+                }
+                if (entBranch.children === undefined)
+                    entBranch.children = [];
+                entBranch.children.push(envBranch);
+            }
+            tree.push(entBranch);
+        }
+        return tree;
+    }
+    /** Truncates the string to the given length with an ellipses as suffix */
+    ellipsis(maxLength, value) {
+        let output = value;
+        if (output.length > maxLength) {
+            let ellipsis = "..."; // Rather use the ellipsis character but String.fromCharCode(133) is returning a problematic character.
+            output = output.slice(0, maxLength - 1 - ellipsis.length).concat(ellipsis);
+        }
+        return output;
+    }
+    /**
+     *
+     * @param enterprise
+     * @param environment
+     * @param cabinet
+     * @param asset
+     * @param ctrInPod (Optional, defaults to the first one in the spec) The name of the running container (not the image) inside the pod (relevant only when there's more than one).
+     * @param defaultValue
+     * @returns
+     */
+    promptForReplica(replicas, ctrInPod, defaultValue) {
+        var _a, _b, _c, _d, _e;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let podName;
+                // params:  enterprise: string, environment: string, cabinet: string, asset: string
+                // // Retrieve replicas
+                // this._ui.startSpinner(`Fetching ${asset} replicas in ${environment}/${cabinet}...`)
+                // let reps = await this.genRelayClient.Call.assetStatus({ assetName: asset, cabinetName: cabinet, enterpriseCode: enterprise, environment: environment });
+                // this._ui.stopSpinner((reps.successes) ? `${reps.successes.length} found.` : "failed.")
+                // if (reps.error) throw reps.error;
+                // if (reps.successes == undefined || reps.successes.length === 0) throw new Error(`No ${asset} replicas exist in cabinet ${environment}/${cabinet}. ${reps.message ?? ""}`);
+                // 
+                // let replicas = reps.successes[0].currentVersion.pods;   // <--- HEY!!! Relay shouldnt be exposing raw k8s contracts here - this shd be a codiac contract
+                let choices = replicas.filter(r => { var _a; return ((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.name) !== undefined; })
+                    .map(r => { var _a, _b, _c; return ({ name: `${(_a = r.metadata.name) !== null && _a !== void 0 ? _a : ""} (${(_b = r.status) === null || _b === void 0 ? void 0 : _b.phase})`, value: (_c = r.metadata.name) !== null && _c !== void 0 ? _c : "" }); });
+                // Select a replica...
+                if (choices.length === 0) {
+                    this._ui.userMessage(`No replicas found.`);
+                    podName = "unknown";
+                    // return undefined;  // <--- this is what we should do here.
+                }
+                else if (choices.length === 1) {
+                    podName = choices[0].value;
+                    this._ui.userMessage(`1 replica found: ${this._styler.hilite(podName)}`);
+                }
+                else {
+                    let keep = this.takeDefaults;
+                    if (defaultValue && Boolean(choices.find(x => x.value === defaultValue)) && !this.takeDefaults) {
+                        keep = yield this._ui.promptConfirm("keepReplica", `Replica: ${this._styler.hilite(defaultValue)} `);
+                    }
+                    if (keep && defaultValue !== undefined) {
+                        podName = defaultValue;
+                    }
+                    else {
+                        podName = (yield this._ui.promptSelect("replica", "Replica...", choices, false, false)); // Assertion operator ok here - we're not allowing undefined options.
+                    }
+                }
+                let replica = (replicas.find(r => { var _a; return ((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.name) === podName; })); // Assertion ok: selection was already limited to this list.
+                // Select the container inside...
+                let containerName;
+                if ((((_a = replica.spec) === null || _a === void 0 ? void 0 : _a.containers) == undefined) || (((_b = replica.spec) === null || _b === void 0 ? void 0 : _b.containers.length) === 0))
+                    throw new Error("No containers are specified in that replica");
+                if (!_.isEmpty(ctrInPod)) {
+                    let found = replica.spec.containers.find(c => c.name === ctrInPod);
+                    if (!found)
+                        throw new Error(`Container [${ctrInPod}] not found in that replica`);
+                    containerName = found.name;
+                }
+                else {
+                    containerName = replica.spec.containers[0].name;
+                    if (((_c = replica.spec) === null || _c === void 0 ? void 0 : _c.containers.length) > 1) {
+                        // TODO: promptSelect from the list of containers
+                        this._ui.userMessage(`${(_d = replica.spec) === null || _d === void 0 ? void 0 : _d.containers.length} containers in that replica; selected ${containerName}`);
+                    }
+                }
+                let k8sCtr = {
+                    namespace: (_e = replica.metadata) === null || _e === void 0 ? void 0 : _e.namespace,
+                    pod: podName,
+                    container: containerName
+                };
+                return k8sCtr;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    renderSelectedContent(context, contentType, k8sEntities, contentOptions, replicas) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                switch (contentType) {
+                    case (AssetContentType.logs):
+                        if (context.replica == undefined)
+                            throw new Error("No replica selected.");
+                        if (k8sEntities.pod == undefined || k8sEntities.container == undefined)
+                            throw new Error("No replica selected.");
+                        yield this.showLogs(context, contentOptions);
+                        break;
+                    case (AssetContentType.term):
+                        if (context.replica == undefined)
+                            throw new Error("No replica selected.");
+                        if (k8sEntities.pod == undefined || k8sEntities.container == undefined)
+                            throw new Error("No replica selected.");
+                        let termArgs = { tty: true, command: (_a = contentOptions === null || contentOptions === void 0 ? void 0 : contentOptions.terminalStartup) !== null && _a !== void 0 ? _a : DEFAULT_TERMINAL_STARTER };
+                        yield this.runExec(context, termArgs, k8sEntities);
+                        break;
+                    case (AssetContentType.exec):
+                        if (context.replica == undefined)
+                            throw new Error("No replica selected.");
+                        if (k8sEntities.pod == undefined || k8sEntities.container == undefined)
+                            throw new Error("No replica selected.");
+                        let execArgs = contentOptions;
+                        execArgs.tty = false; // and we want a run-once behavior so the ws closes after the command completes.
+                        yield this.runExec(context, execArgs, k8sEntities);
+                        break;
+                    case (AssetContentType.config):
+                        if (context.replica == undefined)
+                            throw new Error("No replica selected.");
+                        if (k8sEntities.pod == undefined || k8sEntities.container == undefined)
+                            throw new Error("No replica selected.");
+                        let cfgInput = contentOptions;
+                        if (!cfgInput.rootPathName.startsWith("/"))
+                            cfgInput.rootPathName = "/".concat(cfgInput.rootPathName);
+                        let cfgExec = { tty: false, command: ["cat", cfgInput.rootPathName] };
+                        yield this.runExec(context, cfgExec, k8sEntities);
+                        break;
+                    case (AssetContentType.env):
+                        if (context.replica == undefined)
+                            throw new Error("No replica selected.");
+                        if (k8sEntities.pod == undefined || k8sEntities.container == undefined)
+                            throw new Error("No replica selected.");
+                        let envArgs = { tty: false, command: "env" };
+                        yield this.runExec(context, envArgs, k8sEntities);
+                        break;
+                    case (AssetContentType.status):
+                        // await this.watchEvents(context, k8sEntities.namespace, replicas);
+                        yield this.watchStatus_NEW(context, k8sEntities.namespace, replicas);
+                        // await this.watchStatus(context, k8sEntities.namespace, replicas);
+                        // await this.watchReplicaSet(context, k8sEntities.namespace);
+                        // await this.showStatus(context, k8sEntities.namespace, replicas);
+                        break;
+                    default:
+                        this.logger.debug(`Content type ${contentType} is not yet supported.`, [context, contentType, contentOptions]);
+                        this._ui.userMessage(`Content type ${contentType} is not yet supported.`);
+                }
+                return;
+            }
+            catch (err) {
+                throw (err);
+            }
+        });
+    }
+    getKubeConfig(context) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Retrieve cluster connection specs
+            let res = yield this.genRelayClient.Call.getClusterConnectionSpecs({
+                enterprise: context.enterprise,
+                environment: context.environment,
+                cabinet: context.cabinet
+            });
+            if (res.error)
+                throw res.error;
+            if (res.output == undefined || _.isEmpty(res.output)) {
+                this.log(`Failed loading cluster spec: ${res.message}.`);
+                throw new Error(`Failed loading cluster spec: ${res.message}.`);
+            }
+            // Create the k8s client
+            let k8sConfig = new client_node_1.KubeConfig();
+            k8sConfig.loadFromString(res.output);
+            return k8sConfig;
+        });
+    }
+    getK8sClient(context, kube) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let k8sConfig = kube !== null && kube !== void 0 ? kube : (yield this.getKubeConfig(context));
+            let theirApi = k8sConfig.makeApiClient(k8s.CoreV1Api);
+            return theirApi;
+        });
+    }
+    /** Gets the cluster cnxn specs from the relay, then makes the k8s call from the cli.
+     *
+     * Throws any errors. */
+    fetchReplicas(context, namespace, k8sClient) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let theirApi = k8sClient !== null && k8sClient !== void 0 ? k8sClient : yield this.getK8sClient(context);
+                // Fetch from the cluster
+                let podResult = yield theirApi.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, `${codiac_constants_1.CodiacLabels.LABEL_ASSET_NAME}=${context.asset}`);
+                let replicas = podResult.body.items;
+                // let replicas = _.orderBy(podResult.body.items, p => p.metadata?.labels?.assetVersion, 'desc');  // NOTE: this isnt a semantic version sort
+                try {
+                    // Might need a semver.coerce() in here...
+                    replicas = replicas.sort((a, b) => { var _a, _b, _c, _d, _e, _f; return semver.rcompare((_c = (_b = (_a = a.metadata) === null || _a === void 0 ? void 0 : _a.labels) === null || _b === void 0 ? void 0 : _b.assetVersion) !== null && _c !== void 0 ? _c : "", (_f = (_e = (_d = b.metadata) === null || _d === void 0 ? void 0 : _d.labels) === null || _e === void 0 ? void 0 : _e.assetVersion) !== null && _f !== void 0 ? _f : ""); }); // removes semvers so they can be sorted uniquely
+                }
+                catch (err) {
+                    replicas = _.orderBy(replicas, p => { var _a, _b, _c; return (_c = (_b = (_a = p.metadata) === null || _a === void 0 ? void 0 : _a.labels) === null || _b === void 0 ? void 0 : _b.assetVersion) !== null && _c !== void 0 ? _c : ""; }); // TODO: we need this ALSO sorted by replica set (ie: name or labels["pod-template-hash"])
+                }
+                return replicas;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    // protected async watchEvents(context: AssetReplicaContext, namespace: string, replicas?: k8s.V1Pod[] | undefined): Promise<void> {
+    //   // let selector = `${CodiacLabels.LABEL_ASSET_NAME}=${context.asset}`;
+    //   let selector = `app=${context.asset}`;
+    //   let creds = await this.getKubeConfig(context);
+    //   let k8sClient = creds.makeApiClient(k8s.EventsV1Api);
+    //   let watcher = new Watch(creds);
+    //   watcher.watch(
+    //     '/apis/events.k8s.io/v1/namespaces/{namespace}/events', 
+    //   )
+    //   let res = await k8sClient.listNamespacedEvent(namespace, undefined, undefined, undefined, undefined, selector,
+    //     undefined, undefined, undefined, undefined, true, undefined);
+    // }
+    watchStatus_NEW(context, namespace, replicas) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // let selector = `${CodiacLabels.LABEL_ASSET_NAME}=${context.asset}`;
+            let selector = `app=${context.asset}`;
+            let kube = yield this.getKubeConfig(context);
+            let k8sClient = yield this.getK8sClient(context);
+            (0, log_update_wrapper_1.logUpdate)(`Watching ${this._styler.hilite(context.asset)} in ${context.environment}/${context.cabinet}... (ctrl-c to quit)`);
+            log_update_wrapper_1.logUpdate.done();
+            (0, log_update_wrapper_1.logUpdate)(`...empty...`);
+            // This approach DOES return what's different in the cached list, 
+            // but doesnt stream updates from the cluster - it only runs a first request,
+            // meaning you need to call this repeatedly - this looks not fully-baked...?
+            let informer = (0, client_node_1.makeInformer)(kube, `/api/v1/namespaces/${namespace}/pods`, () => k8sClient.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector)
+            // () => k8sClient.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector, undefined, undefined, undefined, undefined, true),
+            // selector
+            );
+            // informer.on('add', (obj: k8s.V1Pod) => { console.log(`Added: ${obj.metadata!.name}`); });
+            // informer.on('update', (obj: k8s.V1Pod) => { console.log(`Updated: ${obj.metadata!.name}`); });
+            informer.on('change', (obj) => {
+                // console.log(`Changed: ${obj.metadata!.name}`);
+                let canvas = { table: "", curver: "" };
+                let replicas = informer.list(namespace);
+                if (replicas.length > 0) {
+                    for (let pod of replicas) {
+                        this.renderReplicaStatusRow(pod, canvas);
+                    }
+                }
+                else {
+                    canvas.table = "(no instances found)";
+                }
+                log_update_wrapper_1.logUpdate.clear();
+                (0, log_update_wrapper_1.logUpdate)(canvas.table);
+            });
+            // informer.on('delete', (obj: k8s.V1Pod) => { console.log(`Deleted: ${obj.metadata!.name}`); });
+            informer.on('error', (err) => {
+                if (err.statusCode === 401) {
+                    // TODO: reach out to the relay to refresh the user token in the kubeconfig. 
+                    log_update_wrapper_1.logUpdate.clear();
+                    (0, log_update_wrapper_1.logUpdate)(`Authentication error; please refresh your credentials.`);
+                }
+                else {
+                    log_update_wrapper_1.logUpdate.clear();
+                    console.error(err);
+                }
+                // Restart informer after 5sec
+                setTimeout(() => {
+                    informer.start();
+                }, 5000);
+            });
+            informer.start();
+            // let watch: boolean = true;
+            // listNamespacedPod() with "watch" just floats out into space with no return
+            // let podResult = await k8sClient.listNamespacedPod(namespace, undefined, undefined, undefined, undefined,
+            //   `${CodiacLabels.LABEL_ASSET_NAME}=${context.asset}`, undefined, undefined, undefined, undefined, watch);
+            // while (podResult) {
+            //   logUpdate(`${podResult.body.items.length} pods returned`); // Thanks, nice and ambiguous; lets give them something actionable here instead.
+            // }
+        });
+    }
+    watchReplicaSet(context, namespace, replicaSets) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let k8sConfig = (yield this.getKubeConfig(context));
+            let k8sClient = k8sConfig.makeApiClient(k8s.AppsV1Api);
+            // let selector = `${CodiacLabels.LABEL_ASSET_NAME}=${context.asset}`;
+            let selector = `app=${context.asset}`;
+            let watch = true;
+            do {
+                let content = "";
+                log_update_wrapper_1.logUpdate.clear();
+                try {
+                    let podResult = yield k8sClient.listNamespacedReplicaSet(namespace, undefined, undefined, undefined, undefined, selector);
+                    let output = podResult.body.items;
+                    for (let item of output) {
+                        if (item.status) {
+                            content = content.concat(`${(_b = (_a = item.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unnamed"}  ${(_c = item.status.availableReplicas) !== null && _c !== void 0 ? _c : 0}/${item.status.replicas}`, "\n");
+                        }
+                        else {
+                            content = content.concat(`no status for ${(_e = (_d = item.metadata) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : "unnamed"}`, "\n");
+                        }
+                    }
+                }
+                catch (err) {
+                    content = content.concat(`Error ${(_f = err.name) !== null && _f !== void 0 ? _f : ""} ${(_g = err.message) !== null && _g !== void 0 ? _g : ""}`, "\n");
+                }
+                (0, log_update_wrapper_1.logUpdate)(content);
+                yield this.unblockAndSleep(0.5);
+            } while (watch);
+        });
+    }
+    watchStatus(context, namespace, replicas) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let watch = true;
+            let k8sClient = yield this.getK8sClient(context);
+            let pods = replicas;
+            let spinChars = ["|", "/", "-", "\\"];
+            let spinIndex = -1;
+            (0, log_update_wrapper_1.logUpdate)(`Status for ${context.asset} in ${context.environment}/${context.cabinet}... (ctrl-c to quit)`);
+            log_update_wrapper_1.logUpdate.done();
+            do {
+                // await this.showStatus(context, namespace, pods, k8sClient);
+                spinIndex++;
+                if (spinIndex >= spinChars.length)
+                    spinIndex = 0;
+                let spinner = spinChars[spinIndex];
+                // TODO: trap failures here and if status currently exists, render the error and leave the existing
+                let table = "";
+                try {
+                    pods = pods !== null && pods !== void 0 ? pods : yield this.fetchReplicas(context, namespace, k8sClient);
+                    if (pods && pods.length > 0) {
+                        log_update_wrapper_1.logUpdate.clear();
+                        let curver = ""; // current asset version being listed 
+                        // let deployed = res.successes[0].currentVersion.deployed;
+                        for (let replica of pods) {
+                            let replicaName = (_b = (_a = replica.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unnamed";
+                            let podHash = ((_c = replica.metadata) === null || _c === void 0 ? void 0 : _c.labels) ? (_d = replica.metadata) === null || _d === void 0 ? void 0 : _d.labels["pod-template-hash"] : undefined;
+                            let replicaId = podHash ? replicaName.slice(replicaName.indexOf(podHash)) : replicaName;
+                            let assetVersion = ((_e = replica.metadata) === null || _e === void 0 ? void 0 : _e.labels) ? (_f = replica.metadata) === null || _f === void 0 ? void 0 : _f.labels[codiac_constants_1.CodiacLabels.LABEL_ASSET_VERSION] : undefined;
+                            // Version separator
+                            if (assetVersion !== undefined && assetVersion !== curver) {
+                                curver = assetVersion;
+                                table = table.concat(`${spinner} ${assetVersion}`, "\n");
+                            }
+                            // Each replica
+                            if (replica.status) {
+                                let state = this.renderPodState(replica);
+                                let condition = this.renderCondition(replica);
+                                let restarts = (replica.status.containerStatuses && replica.status.containerStatuses.length > 0) ? replica.status.containerStatuses[0].restartCount : 0;
+                                table = table.concat(`  ${replicaId}) ${state} ${condition} started (${replica.status.startTime}) ${restarts} restarts\n`); // , deployed (${deployed})`)
+                            }
+                        }
+                    }
+                    else {
+                        table = table.concat(`No running instances found.`);
+                    }
+                }
+                catch (err) {
+                    table = table.concat(`Error refreshing... ${(_g = err.message) !== null && _g !== void 0 ? _g : err.name}\n`);
+                }
+                (0, log_update_wrapper_1.logUpdate)(table);
+                pods = undefined;
+                yield this.unblockAndSleep(0.5);
+            } while (watch);
+        });
+    }
+    /** Mutates canvas */
+    renderReplicaStatusRow(replica, canvas) {
+        var _a, _b, _c, _d, _e, _f;
+        let replicaName = (_b = (_a = replica.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unnamed";
+        let podHash = ((_c = replica.metadata) === null || _c === void 0 ? void 0 : _c.labels) ? (_d = replica.metadata) === null || _d === void 0 ? void 0 : _d.labels["pod-template-hash"] : undefined;
+        let replicaId = podHash ? replicaName.slice(replicaName.indexOf(podHash)) : replicaName;
+        let assetVersion = ((_e = replica.metadata) === null || _e === void 0 ? void 0 : _e.labels) ? (_f = replica.metadata) === null || _f === void 0 ? void 0 : _f.labels[codiac_constants_1.CodiacLabels.LABEL_ASSET_VERSION] : undefined;
+        // Version separator
+        if (assetVersion !== undefined && assetVersion !== canvas.curver) {
+            canvas.curver = assetVersion;
+            canvas.table = canvas.table.concat(`${assetVersion}`, "\n");
+        }
+        // Each replica
+        if (replica.status) {
+            let state = this.renderPodState(replica);
+            let condition = this.renderCondition(replica);
+            let restarts = (replica.status.containerStatuses && replica.status.containerStatuses.length > 0) ? replica.status.containerStatuses[0].restartCount : 0;
+            canvas.table = canvas.table.concat(`  ${replicaId}) ${state} ${condition} started (${replica.status.startTime}) ${restarts} restarts\n`); // , deployed (${deployed})`)
+        }
+    }
+    renderCondition(replica) {
+        var _a;
+        let cond = "";
+        if (replica.status) {
+            if (((_a = replica.status) === null || _a === void 0 ? void 0 : _a.conditions) && replica.status.conditions.length > 0) {
+                let latestCond = _.orderBy(replica.status.conditions, x => x.lastTransitionTime, "desc")[0];
+                cond = latestCond.type;
+                if (latestCond.reason) {
+                    cond = cond.concat(" (", latestCond.reason, ")");
+                }
+                if (latestCond.message) {
+                    // TODO: Revisit;  message is prob too much info to jam into a cli output line.
+                    cond = cond.concat(" ('", latestCond.message, "')");
+                }
+                cond = cond.concat(` since (${latestCond.lastTransitionTime})`);
+            }
+        }
+        return cond;
+    }
+    renderPodState(replica) {
+        var _a, _b, _c, _d;
+        let state = "[no status found]";
+        if ((_a = replica.metadata) === null || _a === void 0 ? void 0 : _a.deletionTimestamp) {
+            state = "Terminating";
+        }
+        else if (replica.status) {
+            state = "";
+            // Pod phase
+            if (replica.status.phase) {
+                state = replica.status.phase;
+            }
+            if (replica.status.reason) {
+                state = state.concat(" (", replica.status.reason, ")");
+            }
+            if (replica.status.message) {
+                state = state.concat(" ('", replica.status.message, "')");
+            }
+            // container state
+            if (replica.status.containerStatuses && replica.status.containerStatuses.length > 0) {
+                let ctrStatus = replica.status.containerStatuses[0];
+                // state = state.concat("  ", JSON.stringify(ctrStatus.state), "\n");
+                if ((_b = ctrStatus.state) === null || _b === void 0 ? void 0 : _b.waiting) {
+                    if (ctrStatus.state.waiting.reason) {
+                        state = state.concat(" (", ctrStatus.state.waiting.reason, ")");
+                    }
+                    if (ctrStatus.state.waiting.message) {
+                        state = state.concat(" ('", ctrStatus.state.waiting.message, "')");
+                    }
+                }
+                else if ((_c = ctrStatus.state) === null || _c === void 0 ? void 0 : _c.terminated) {
+                    if (ctrStatus.state.terminated.reason) {
+                        state = state.concat(" (", ctrStatus.state.terminated.reason, ")");
+                    }
+                    if (ctrStatus.state.terminated.message) {
+                        state = state.concat(" (", ctrStatus.state.terminated.message, ")");
+                    }
+                }
+                else if ((_d = ctrStatus.state) === null || _d === void 0 ? void 0 : _d.running) {
+                }
+            }
+        }
+        return state;
+    }
+    unblockAndSleep(durationInSecs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                setTimeout(() => resolve(), durationInSecs * 1000);
+            });
+        });
+    }
+    /** Fetches pods if not already provided. */
+    showStatus(context, namespace, replicas, k8sApi) {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let k8sClient = k8sApi !== null && k8sApi !== void 0 ? k8sApi : yield this.getK8sClient(context);
+                let pods = replicas !== null && replicas !== void 0 ? replicas : yield this.fetchReplicas(context, namespace, k8sClient);
+                if (pods && pods.length > 0) {
+                    // let deployed = res.successes[0].currentVersion.deployed;
+                    console.log(`Status for ${context.asset} ${(pods.length > 0) ? " instances" : ""} running in ${context.environment}/${context.cabinet}`);
+                    for (let replica of pods) {
+                        let replicaName = (_b = (_a = replica.metadata) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unnamed";
+                        if (((_c = replica.status) === null || _c === void 0 ? void 0 : _c.conditions) && replica.status.conditions.length > 0) {
+                            let latestCond = _.orderBy(replica.status.conditions, x => x.lastTransitionTime, "desc")[0];
+                            console.log(`${replicaName} ${latestCond.type} since (${latestCond.lastTransitionTime}) started (${replica.status.startTime}) ${replica.status.containerStatuses[0].restartCount} restarts`); // , deployed (${deployed})`)
+                        }
+                        else {
+                            console.log("Condition not available"); // Thanks, nice and ambiguous; lets give them something actionable here instead.
+                        }
+                    }
+                }
+                else {
+                    this._ui.userMessage(`No running instances found.`);
+                }
+                return;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    showLogs(context, logOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                // SHOW LOGS
+                let req = Object.assign(Object.assign({}, context), { logOptions: logOptions });
+                let cnxnResult = yield this.genRelayClient.Call.getLogStreamSpecs(req);
+                if (cnxnResult.error)
+                    throw cnxnResult.error;
+                if (cnxnResult.output == undefined)
+                    throw new Error(`Failed  without error getting log stream connection specs.`);
+                const logStream = new stream.PassThrough();
+                logStream.on("data", (chunk) => {
+                    // use write rather than console.log to prevent double line feed
+                    process.stdout.write(chunk);
+                });
+                let streamer = new LogStreamer(this.logger);
+                let requestOptions = cnxnResult.output;
+                // Deserialize from strings into Buffers after their trip over the wire
+                if (cnxnResult.output.ca)
+                    requestOptions.ca = Buffer.from(cnxnResult.output.ca);
+                else
+                    this.logger.warn(`Cluster connection specs retrieved for log streaming did not have a ca.`);
+                if (cnxnResult.output.cert)
+                    requestOptions.cert = Buffer.from(cnxnResult.output.cert);
+                else
+                    this.logger.warn(`Cluster connection specs retrieved for log streaming did not have a cert.`);
+                if (cnxnResult.output.key)
+                    requestOptions.key = Buffer.from(cnxnResult.output.key);
+                else
+                    this.logger.warn(`Cluster connection specs retrieved for log streaming did not have a key.`);
+                streamer.go(requestOptions, logStream); // shouldn't we be awaiting this?
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    /**
+     * @param context Fully qualified path, in terms of Codiac entities, to identify a single replica of an asset in a cabinet.
+     * @param execArgs Parameters identifying the ultimate command to run and the console behavior.
+     * @param K8sEntities The identifying names of the relevant kubernetes objects, corresponding to the asset replica context, that fully qualify the desired container. */
+    runExec(context, execArgs, k8sEntities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let k8sCnxnResult = yield this.genRelayClient.Call.getClusterConnectionSpecs(context);
+                if (k8sCnxnResult.error)
+                    throw k8sCnxnResult.error;
+                if (k8sCnxnResult.output === undefined || _.isEmpty(k8sCnxnResult.output))
+                    throw new Error(`Retrieval of cluster connection spec failed without error.`);
+                let spec = k8sCnxnResult.output;
+                let kc = new k8s.KubeConfig();
+                kc.loadFromString(spec);
+                // ======================================================================================================
+                // We have to resume here because the console keystrokes are not getting through, 
+                // even though a POC running just the exec (without all the other ui code we're running)
+                // doesnt have the input problem.
+                // 
+                // TODO:  Find out why we need this stdin resumed. 
+                //        Most likely because it was piped into an spawned child process that has since ended.
+                // 
+                process.stdin.resume(); // Somehwere we probably lost track of a stdin
+                // 
+                // 
+                // ======================================================================================================
+                const exec = new k8s.Exec(kc);
+                const ws = yield exec.exec(k8sEntities.namespace, k8sEntities.pod, k8sEntities.container, execArgs.command, process.stdout, process.stderr, process.stdin, execArgs.tty, (status) => {
+                    // tslint:disable-next-line:no-console
+                    // console.log("Exited with status:");
+                    // // tslint:disable-next-line:no-console
+                    this.logger.debug(`Executed terminal cmd. Status: ${status.status} ${status.reason}`, JSON.stringify(status, null, 2));
+                });
+                ws.onopen = function open() {
+                    process.stdout.write("connected");
+                };
+                ws.onclose = function close(evt) {
+                    // process.stdout.write("disconnected");
+                    process.exit(evt.code);
+                    return;
+                };
+                ws.onmessage = this.routeK8sWebSocketMessage;
+                //  function incoming(msg: any) {
+                //   let buf = Buffer.from(msg.data);
+                //   // The k8s client prefixes the buffer with the stream number at position 0...
+                //   let streamNumBuf = buf.readInt8();
+                //   let payload = buf.toString('utf8', 1);  // <-- start at pos 1 to skip the stream number.
+                //   switch (streamNumBuf) {
+                //     case WebSocketHandler.StdoutStream /* 1 */:
+                //       process.stdout.write(payload);
+                //       break;
+                //     case WebSocketHandler.StderrStream /* 2 */:
+                //       process.stderr.write(`ERROR: ` + payload);
+                //       break;
+                //     case WebSocketHandler.StatusStream /* 3 */:
+                //       let k8sStatus = JSON.parse(payload) as V1Status;
+                //       process.stdout.write(`STATUS: ${k8sStatus.status}: ${k8sStatus.message}`);
+                //       break;
+                //     default:
+                //       process.stderr.write(`feedback on ${streamNumBuf}`)
+                //   }
+                //   return;
+                // };
+                // This never gets hit.  Instead, onmessage gets hit with a message designated for stderr stream.
+                ws.onerror = function error(err) {
+                    process.stdout.write(`Error: ${err.message}`);
+                    ws.close();
+                };
+                // Gotta do a process.exit(code) to give the control back.
+                // THese dont fire
+                // ws.once('exit', (code) => process.exit(code));
+                // ws.once('end', (code) => process.stdout.write("end event fired"));
+                return;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    /** Parses the stream number from the incoming message,
+     * and writes the data to the designated target stream.
+     *
+     * (The k8s client prefixes the buffer with the stream number at position 0)
+     */
+    routeK8sWebSocketMessage(msg) {
+        var _a;
+        let buf = Buffer.from(msg.data);
+        // The k8s client prefixes the buffer with the stream number at position 0...
+        let streamNumBuf = buf.readInt8();
+        let payload = buf.toString('utf8', 1); // <-- start at pos 1 to skip the stream number.
+        switch (streamNumBuf) {
+            case web_socket_handler_1.WebSocketHandler.StdoutStream /* 1 */:
+                process.stdout.write(payload);
+                break;
+            case web_socket_handler_1.WebSocketHandler.StderrStream /* 2 */:
+                process.stderr.write(`ERROR: ` + payload);
+                break;
+            case web_socket_handler_1.WebSocketHandler.StatusStream /* 3 */:
+                let k8sStatus = JSON.parse(payload);
+                if (((_a = k8sStatus.status) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "failure") {
+                    if (k8sStatus.reason !== "NonZeroExitCode") {
+                        process.stdout.write(`STATUS: ${k8sStatus.status}: ${k8sStatus.message}`);
+                    }
+                }
+                break;
+            default:
+                process.stderr.write(`feedback on ${streamNumBuf}`);
+        }
+        return;
+    }
+}
+exports.default = AssetView;
+AssetView.description = 'Renders a selected type of content for an asset';
+AssetView.aliases = ['asset:monitor', "asset:mon", "asset:get"];
+AssetView.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    enterprise: core_1.Flags.string({ char: 'e', description: 'The name of the enterprise containing the asset being viewed.' }),
+    asset: core_1.Flags.string({ char: 'a', description: 'The name of the asset to view.' }),
+    environment: core_1.Flags.string({ char: 'n', description: 'The name of the environment in which the cabinet resides.' }),
+    cabinet: core_1.Flags.string({ char: 'c', description: 'The name of the cabinet from which the content is to be drawn.' }),
+    replica: core_1.Flags.string({ char: 'r', description: 'The name of one of the asset instances currently running in the cabinet.' }),
+    type: core_1.Flags.string({ char: 't', options: [...Object.keys(AssetContentType)], description: 'The type of content to retrieve.' }),
+    terminal: core_1.Flags.string({ options: ["bash", "sh"], description: 'Command used to start the terminal (defaults to "bash")' }),
+    logsFollow: core_1.Flags.boolean({ char: 'f', default: false, description: '(requires type=logs) Follow (aka watch, tail, stream) the output.' }),
+    logsTail: core_1.Flags.integer({ char: 'l', default: 10, description: '(requires type=logs) Lines of recent logs to include in the output.  Enter -1 to include the entire log history stored in the container.' }),
+    configFile: core_1.Flags.string({ char: 'F', description: '(requires type=config) The root pathname to the config file to fetch.' }),
+    silent: core_1.Flags.boolean({ exclusive: ["echo", "toscript"], description: 'Non-Interactive mode; executes without any user interaction and fails on any missing or invalid arguments.' }),
+    echo: core_1.Flags.boolean({ exclusive: ["toscript", "silent"], description: 'Echo interaction mode; renders the equivalent non-interactive cli command for future use before final execution.' }),
+    toscript: core_1.Flags.boolean({ exclusive: ["echo", "silent"], description: 'Toscript interaction mode; renders the equivalent non-interactive cli command WITHOUT any execution.' }),
+    takeDefaults: core_1.Flags.boolean({ exclusive: ["silent"], description: "Prevents prompting for confirmation on parameters that were passed in or were set to default values." })
+    // tty: Flags.boolean({ char: 'i', default: false, description: '(requires type=exec) Specifies an interactive console session.' })
+};
+AssetView.strict = false; // disables argument validation so we can support variable-length arguments.
+AssetView.args = {
+    cmd: core_1.Args.string({ description: '(requires type=exec) command and its space-separated arguments to run in the target replica.' })
+};
+class ExecArgs {
+    constructor(command, tty = true) {
+        this.command = command;
+        this.tty = tty;
+    }
+}
+exports.ExecArgs = ExecArgs;
+class ConfigFileArgs {
+    constructor(rootPathName) {
+        this.rootPathName = rootPathName;
+    }
+}
+exports.ConfigFileArgs = ConfigFileArgs;
+class TermArgs {
+    /**
+     *
+     * @param terminalStartup The type of terminal to open.  This command may change depending on what terminal or command shell types are available in the image.
+     */
+    constructor(terminalStartup) {
+        this.terminalStartup = terminalStartup;
+    }
+}
+exports.TermArgs = TermArgs;
+/** Idnetifies a container, in a pod, in a namespace, in a cluster. */
+class K8sContainerRef {
+    constructor(namespace, podName, 
+    /** This should be optional. When there's only one container in a pod,
+     * we should be able to derive this from the pod spec. */
+    containerName) {
+        this.namespace = namespace;
+        this.podName = podName;
+        this.containerName = containerName;
+    }
+}
+exports.K8sContainerRef = K8sContainerRef;
+class LogStreamer {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    go(requestOptions, stream) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const req = request(requestOptions, (error, response, body) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else if (response.statusCode !== 200) {
+                        this.logger.detail(`Error connecting to log stream`, body);
+                        let details;
+                        try {
+                            const k8sStatus = client_node_1.ObjectSerializer.deserialize(JSON.parse(body), 'V1Status');
+                            details = `${k8sStatus.status}${k8sStatus.reason ? " (" + k8sStatus.reason + ")" : ""} ${k8sStatus.message}`;
+                        }
+                        catch (_a) {
+                            details = "See cli log for details.";
+                        }
+                        reject(new Error(`Error connecting to log stream. ${details}`));
+                    }
+                }).on('response', (response) => {
+                    if (response.statusCode === 200) {
+                        req.pipe(stream);
+                        resolve(req);
+                    }
+                });
+            });
+        });
+    }
+}
+exports.LogStreamer = LogStreamer;
+//# sourceMappingURL=view.js.map