@codiac.io/codiac-cli 1.2.174 → 1.2.202

package/dist/commands/env/add.d.ts

@@ -0,0 +1,22 @@
+import { ScopeLevel } from '@codiac.io/codiac-relay-contracts';
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+export default class EnvAdd extends CommandBaseEnterprise {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        setting: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        enterprise: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        cabinet: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        setting: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    private _envConfig;
+    run(): Promise<void>;
+    writeSetting_Api(enterprise: string, assetName: string, configName: string, setting: string, scopeLevel: ScopeLevel, scopeName: string, val: any): Promise<void>;
+    writeSettingEnv_local(setting: string, value: any): void;
+    /** Retrieves the list of settings from the env schema that are not yet explicitly declared. */
+    getAvailableSettings(): Promise<string[]>;
+}

package/dist/commands/env/add.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const codiac_relay_contracts_1 = require("@codiac.io/codiac-relay-contracts");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+const codiac_constants_1 = require("../../codiac-constants");
+class EnvAdd extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.bootstrap();
+            const { args, flags } = yield this.parse(EnvAdd);
+            this._ops.getConfigRoot(); // Verify that it's being called from within a defined project.
+            this._userCntx = yield this.establishTenantContext(this._userCntx);
+            let enterprise = (yield this.establishEnterpriseContext()).enterprise;
+            let enterpriseCode = enterprise.code;
+            let aCntx = yield this.establishAssetContext(enterprise, true);
+            // let cab = await this.establishCabinet(flags.cabinet, true);
+            let configName = codiac_constants_1.ENV_CODE_NAME;
+            // 1 Get the list of available built in system settings
+            // stub:
+            this._envConfig = {};
+            let avails = yield this.getAvailableSettings();
+            // Prompt for setting if reqd
+            let setting = (_a = args.setting) !== null && _a !== void 0 ? _a : flags.setting;
+            if (!setting) {
+                // let result = await inquirer.prompt({ type: 'list', name: 'setting', message: 'Setting to add:', choices: avails});
+                setting = (yield this._ui.prompt("settingName", "Name of setting: ", true)); // TODO:  Stop returning undefined when required is true.
+            }
+            // this.log(result.setting);
+            // PROMPT FOR VALUE (if reqd)
+            let val;
+            if (flags.value) {
+                val = flags.value;
+            }
+            else {
+                // TODO: this current value needs to support the scoped value set
+                let currentValue = (this._envConfig) ? this._envConfig[setting] : undefined;
+                let response = yield this._ui.prompt('settingValue', `Value for ${setting}: `, true, currentValue);
+                val = response;
+            }
+            let level;
+            let scopeName;
+            if (flags.enterprise || flags.environment || flags.cabinet) {
+                // WRITE SCOPED TO THE API
+                level = codiac_relay_contracts_1.ScopeLevel.enterprise;
+                scopeName = enterpriseCode;
+                if (flags.enterprise) {
+                    level = codiac_relay_contracts_1.ScopeLevel.enterprise;
+                    scopeName = flags.enterprise;
+                    // TODO: Validate that the enterprise exists
+                }
+                else if (flags.environment) {
+                    level = codiac_relay_contracts_1.ScopeLevel.environment;
+                    scopeName = flags.environment;
+                    // TODO: Validate
+                }
+                else if (flags.cabinet) {
+                    level = codiac_relay_contracts_1.ScopeLevel.cabinet;
+                    scopeName = flags.cabinet;
+                    // TODO: Validate
+                }
+            }
+            // PROMPT FOR SCOPE LEVEL
+            if (!level) {
+                let choices = [
+                    { name: `Anywhere in the ${this._styler.bold(enterpriseCode)} enterprise`, value: codiac_relay_contracts_1.ScopeLevel.enterprise },
+                    { name: `A specific ${this._styler.bold("environment")}`, value: codiac_relay_contracts_1.ScopeLevel.environment },
+                    { name: `A specific ${this._styler.bold("cabinet")}`, value: codiac_relay_contracts_1.ScopeLevel.cabinet },
+                    { name: `Just when running ${this._styler.bold("local")}`, value: "none" }
+                ];
+                let selected = yield this._ui.promptSelect("level", "Scope: Where should this value apply? ", choices);
+                if (selected && selected != "none")
+                    level = codiac_relay_contracts_1.ScopeLevel[selected];
+            }
+            // PROMPT FOR SCOPE
+            if (level && !scopeName) {
+                let choices = [];
+                switch (level) {
+                    case codiac_relay_contracts_1.ScopeLevel.enterprise:
+                        scopeName = enterpriseCode;
+                        break;
+                    case codiac_relay_contracts_1.ScopeLevel.environment:
+                        let resultenvs = yield this._codiacApi.Environment.tryReadMany({ all: true }, { projection: { pathsIncluded: ["code"], pathsExcluded: [] } });
+                        if (resultenvs.error)
+                            throw resultenvs.error;
+                        if (resultenvs.output) {
+                            choices = resultenvs.output.map(e => { return { name: e.code, value: e.code }; });
+                        }
+                        break;
+                    case codiac_relay_contracts_1.ScopeLevel.cabinet:
+                        let resultCabs = yield this._codiacApi.Cabinet.tryReadMany({ enterpriseCode: enterpriseCode }, { projection: { pathsIncluded: ["name"], pathsExcluded: [] } });
+                        if (resultCabs.error)
+                            throw resultCabs.error;
+                        if (resultCabs.output) {
+                            choices = resultCabs.output.map(c => { return { name: c.name, value: c.name }; });
+                        }
+                        break;
+                }
+                if (!scopeName && choices) {
+                    let selected = yield this._ui.promptSelect("scopeName", `Which ${level}? `, choices, true);
+                    scopeName = selected;
+                }
+            }
+            if (level && scopeName) {
+                let assetName = aCntx[0];
+                this.writeSetting_Api(enterpriseCode, assetName, configName, setting, level, scopeName, val);
+            }
+            else {
+                // WRITE UNSCOPED TO LOCAL
+                this.writeSettingEnv_local(setting, val);
+            }
+            this.log(`Applied environment setting "${setting}" = "${val}"`);
+        });
+    }
+    writeSetting_Api(enterprise, assetName, configName, setting, scopeLevel, scopeName, val) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    let cntx = yield this.loadCodiacContext();
+                    // TODO:  Look to enterprise context instead.
+                    // let enterprise = /* this._cfg.enterprise || */ this._projCfg.tenantCode;
+                    // TODO: Look to asset context instead - and if none, fail and call for "$ cod asset:set"
+                    // let assetName = this._projCfg.name;  // this needs to be taken from an image definition.  (AssetBinding[] needs to be added to each ImageExport)
+                    // NOTE:  We could bind a config to an image name,
+                    //        and then allow for an Asset scope to set values on it...
+                    let settingObj = Object.assign({ setting: setting, value: val, targetFile: configName, asset: assetName, enterprise: enterprise, scope: scopeLevel, target: scopeName }, this.createAuditable());
+                    let crit = {
+                        enterprise: settingObj.enterprise,
+                        asset: settingObj.asset,
+                        targetFile: settingObj.targetFile,
+                        scope: scopeLevel,
+                        target: scopeName,
+                        setting: settingObj.setting
+                    };
+                    // TODO:  Replace this with an upsert based on:  enterprise, asset, configName, scopeLevel, scopeName, and setting
+                    let check = yield this._codiacApi.ScopedSetting.tryReadMany(crit);
+                    let resultSetting;
+                    if (check.success && check.output && check.output.length > 0) {
+                        settingObj.id = check.output[0].id;
+                        resultSetting = yield this._codiacApi.ScopedSetting.tryUpdate(settingObj);
+                    }
+                    else {
+                        resultSetting = yield this._codiacApi.ScopedSetting.tryCreate(settingObj);
+                    }
+                    if (resultSetting.success) {
+                        this.logger.notice(`Successfully saved setting [${settingObj.setting}] for ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                        this._ui.userMessage(`Successfully saved setting [${settingObj.setting}] for ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                    }
+                    else if (resultSetting.error) {
+                        this.logger.error(`Error saving setting [${settingObj.setting}]: ${resultSetting.message || ""}; ${resultSetting.error.message || resultSetting.error.stack}; For ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                        this._ui.userMessage(`Error saving setting [${settingObj.setting}]: ${resultSetting.message || ""}; ${resultSetting.error.message || resultSetting.error.stack}; For ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                    }
+                    else {
+                        this.logger.warn(`Failed without error to save setting [${settingObj.setting}]: ${resultSetting.message || ""}; For ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                        this._ui.userMessage(`Failed without error to save setting [${settingObj.setting}]: ${resultSetting.message || ""}; For ${settingObj.scope} [${settingObj.target}] in ${settingObj.enterprise}/${settingObj.asset} config [${settingObj.targetFile}]`);
+                    }
+                    resolve();
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    writeSettingEnv_local(setting, value) {
+        // Consider writing env vars to the ImageExport def in codiac.json
+        // We'll need them when we run the image.
+        console.log(`TODO:  Persist env vars locally:  ${setting}=${value}`);
+        // Write the available setting
+        // if (!this._appConfig) {
+        //   this._appConfig = {};
+        // }
+        // _.set(this._appConfig, setting, value);
+        // // this._appConfig[setting] = val.settingValue;
+        // this._ops.writeConfig(this._appConfig);
+    }
+    /** Retrieves the list of settings from the env schema that are not yet explicitly declared. */
+    getAvailableSettings() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+}
+exports.default = EnvAdd;
+EnvAdd.description = 'Adds a key value pair to the app config';
+// static aliases = ['env:add']
+EnvAdd.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    setting: core_1.Flags.string({ char: 's', required: false, description: "The name of the environment variable to add." }),
+    value: core_1.Flags.string({ char: 'v', required: false, description: "The actual concrete data to be applied as the setting value." }),
+    enterprise: core_1.Flags.string({ char: 'n', exclusive: ["environment", "cabinet"], description: 'The name of the enterprise to which this value is to apply.' }),
+    environment: core_1.Flags.string({ char: 'e', exclusive: ["enterprise", "cabinet"], description: 'The name of the environment to which this value is to apply.' }),
+    cabinet: core_1.Flags.string({ char: 'c', exclusive: ["enterprise", "environment"], description: 'The name of the cabinet to which this value is to apply.' })
+};
+EnvAdd.args = {
+    setting: core_1.Args.string({ description: 'The name of the environment variable to add' })
+};
+//# sourceMappingURL=add.js.map

package/dist/commands/environment/create.d.ts

@@ -0,0 +1,19 @@
+import "reflect-metadata";
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+export default class EnvironmentCreate extends CommandBaseEnterprise {
+    static description: string;
+    static aliases: string[];
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        as: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remember: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        rememberAs: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        unremember: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        withoutdefaults: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/environment/create.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+const core_1 = require("@oclif/core");
+const cli_common_1 = require("../../cli-common");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+const cloud_provider_contextualizer_1 = require("../../uilogic/cloud-provider-contextualizer");
+class EnvironmentCreate extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                this.bootstrap();
+                let params = yield this.parse(EnvironmentCreate);
+                return this.exec.runWithDefaults(params, (args, flags) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        try {
+                            (_a = this._relayContainer) === null || _a === void 0 ? void 0 : _a.ready$.subscribe(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                var _b, _c;
+                                cloud_provider_contextualizer_1.CloudProviderContextualizer.bootstrap(this.ioc);
+                                // TODO:  Ensure that if the projCfg has a tenantCode, that establishTenantContext enforced it with the user authentication.
+                                // THAT IS:  Boot 'em if they're not part of this project's tenant.
+                                this._userCntx = yield this.establishTenantContext(this._userCntx);
+                                let currentEnterprise = (yield this.establishEnterpriseContext()).enterprise;
+                                let enterpriseCode = currentEnterprise.code; // NOTE: We could also pull this from:  this._projUserCfg.enterprise.enterpriseCode;
+                                let partial = {};
+                                // ENTER NAME:
+                                partial.code = (_b = args.name) !== null && _b !== void 0 ? _b : (yield this._ui.prompt("name", "Environment name: ", true));
+                                // validate that it doesnt already exist
+                                let rootMap = yield this.getRootMap(currentEnterprise.code);
+                                let found;
+                                do {
+                                    found = (_c = rootMap.enterprises.find(e => e.name === enterpriseCode)) === null || _c === void 0 ? void 0 : _c.environments.find(e => e.name === partial.code);
+                                    if (found) {
+                                        this._ui.userMessage(`${this._styler.colorWarning("INVALID: ")} An environment with that name already exists in this enterprise.`);
+                                        partial.code = (yield this._ui.prompt("name", "Environment name: ", true, partial.code));
+                                    }
+                                } while (found !== undefined);
+                                // SELECT CLUSTERS:
+                                let choices = rootMap.clusters.map((c, index) => { return { name: `${c.name}  (${c.provider}, ${c.locationName})`, value: index }; });
+                                let selectedIndex = (yield this._ui.promptSelect("cluster", "Cluster to include: ", choices, true));
+                                let clusterNames = [rootMap.clusters[selectedIndex].name];
+                                partial.clusterDefs = yield this._codiacApi.ClusterDef.readMany({ name: { $in: clusterNames } }, { throwNotFound: true });
+                                // Assemble and write
+                                let candidate = Object.assign({ code: partial.code, enterpriseCode: enterpriseCode, subscription: "", sequence: rootMap.clusters.length, clusterDefs: partial.clusterDefs, cabinets: [] }, this.createAuditable());
+                                this._ui.startSpinner(`Creating new environment [${enterpriseCode}/${candidate.code}]...`);
+                                // let result = await relayClient.cabinetCreate(<CabinetScope>{ enterprise: enterpriseCode, cabinet: cabinetName, environment: environment });
+                                let result = yield this._codiacApi.Environment.tryCreate(candidate);
+                                this._ui.stopSpinner("");
+                                if (result.error) {
+                                    this.logger.error(`Error creating environment: ${result.message || ""}; ${result.error.message}`, result.error);
+                                    this._ui.userMessage(`Error creating environment: ${result.message || ""}; ${result.error.message}`);
+                                }
+                                else if (!result.success) {
+                                    this.logger.notice(`Environment creation failed without error.  ${result.message}`);
+                                    this._ui.userMessage(`Environment creation failed without error.  ${result.message}`);
+                                }
+                                else if (result.output) {
+                                    let saved = result.output;
+                                    this.logger.notice(`${this._styler.colorGood("Success!")} Environment [${this._styler.hilite(saved.code)}] created for enterprise [${enterpriseCode}]`);
+                                    this._ui.userMessage(`${this._styler.colorGood("Success!")} Environment [${this._styler.hilite(saved.code)}] created for enterprise [${enterpriseCode}]`);
+                                }
+                            }));
+                        }
+                        catch (err) {
+                            this.handleError(err);
+                            reject(err);
+                        }
+                    }));
+                }));
+            }
+            catch (err) {
+                this.logger.error(`Error parsing arguments: ${err}`);
+                this.logger.debug(err.stack);
+                return new Promise((res, rej) => tslib_1.__awaiter(this, void 0, void 0, function* () { return res(); }));
+                // return new Promise<void>(async (res,rej) => rej(new Error(`Error parsing arguments: ${err}`)));
+            }
+        });
+    }
+}
+exports.default = EnvironmentCreate;
+EnvironmentCreate.description = 'Initializes a cabinet for a given enterprise and environment.  Overwrites any existing if forced, otherwise returns an error if the cabinet already exists.';
+EnvironmentCreate.aliases = ["enviro:create"];
+EnvironmentCreate.args = {
+    name: core_1.Args.string({ required: false, description: 'The name of the environment to create' })
+};
+EnvironmentCreate.flags = Object.assign(Object.assign({}, cli_common_1.commandBase.globalFlags), { help: core_1.Flags.help({ char: 'h' }) });
+//# sourceMappingURL=create.js.map

package/dist/commands/environment/list.d.ts

@@ -0,0 +1,25 @@
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+export declare type FlatEnviro = {
+    name: string;
+    sequence?: number | undefined;
+    enterprise: string;
+    clusters: {
+        name: string;
+        provider: string;
+        locationName: string;
+    }[];
+};
+export default class EnvironmentList extends CommandBaseEnterprise {
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    };
+    static args: {};
+    run(): Promise<void>;
+    private buildEnviroListForText;
+    private buildEnviroClusterDesc;
+    private buildEnviroTree;
+    private FlattenEnviros;
+}

package/dist/commands/environment/list.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const YAML = require("yaml");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+const _ = require("lodash");
+const render = require("../../uilogic/render-methods");
+const render_methods_1 = require("../../uilogic/render-methods");
+class EnvironmentList extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.bootstrap();
+            const { args, flags } = yield this.parse(EnvironmentList);
+            try {
+                this._userCntx = yield this.establishTenantContext(this._userCntx);
+                let currentEnterprise = (yield this.establishEnterpriseContext()).enterprise;
+                let outputFormat = (_a = render_methods_1.OutputFormatsEnum[flags.output]) !== null && _a !== void 0 ? _a : render_methods_1.OutputFormatsEnum.tree;
+                // RETRIEVE 
+                if ([render_methods_1.OutputFormatsEnum.json, render_methods_1.OutputFormatsEnum.yaml].includes(outputFormat) === false)
+                    this._ui.startSpinner("Retrieving");
+                let rootMap = yield this.getRootMap(currentEnterprise.code);
+                let envCount = 0;
+                rootMap.enterprises.forEach(e => envCount += e.environments.length);
+                if ([render_methods_1.OutputFormatsEnum.json, render_methods_1.OutputFormatsEnum.yaml].includes(outputFormat) === false)
+                    this._ui.stopSpinner(`found ${envCount}`);
+                // RENDER
+                let output = "";
+                switch (flags.output) {
+                    case render_methods_1.OutputFormatsEnum.json:
+                        let listForJson = this.FlattenEnviros(rootMap);
+                        listForJson = _.sortBy(listForJson, e => e.enterprise, c => c.name);
+                        output = JSON.stringify(listForJson, undefined, 2);
+                        this._ui.userMessage(output);
+                        break;
+                    case render_methods_1.OutputFormatsEnum.yaml:
+                        let listForYaml = this.FlattenEnviros(rootMap);
+                        listForYaml = _.sortBy(listForYaml, c => c.enterprise, c => c.name);
+                        output = YAML.stringify(listForYaml, { indent: 2 });
+                        this._ui.userMessage(output);
+                        break;
+                    case render_methods_1.OutputFormatsEnum.text:
+                        let flatList = this.FlattenEnviros(rootMap);
+                        flatList = _.sortBy(flatList, c => c.enterprise, c => c.name);
+                        let listForText = this.buildEnviroListForText(flatList);
+                        output = render.renderStringList(listForText);
+                        this._ui.userMessage(output);
+                        break;
+                    // TODO:
+                    // case OutputFormatsEnum.table:
+                    // case OutputFormatsEnum.tsv:
+                    //   break;
+                    case render_methods_1.OutputFormatsEnum.tree:
+                    default:
+                        let envTree = this.buildEnviroTree(rootMap);
+                        let out = render.renderStringTree(envTree); //, this._ui.userMessage);
+                        this._ui.userMessage(out);
+                        break;
+                }
+                // if ([OutputFormatsEnum.tree].includes(flags.output)) {
+                //   let cabTree = this.buildCabinetTree(rootMap);
+                //   let out = this.renderStringTree(cabTree); //, this._ui.userMessage);
+                //   this._ui.userMessage(out);
+                // } else {
+                //   let flatList: FlatCabinet[] = this.FlattenCabinets(rootMap);
+                //   flatList = _.sortBy(flatList, c => c.enterprise, c => c.env, c => c.name)
+                //   this.renderCabinets(flatList, flags.output);
+                // }
+                return;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    buildEnviroListForText(flatList) {
+        try {
+            let listForText = flatList.map(env => {
+                let clusterDesc = this.buildEnviroClusterDesc(env.clusters);
+                return `${env.enterprise}/${this._styler.hilite(env.name)}${this._styler.dim(clusterDesc)}`;
+            });
+            return listForText;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    buildEnviroClusterDesc(clusters) {
+        try {
+            let clusterDesc = "";
+            if (clusters.length > 0) {
+                if (clusters.length === 1) {
+                    // Only 1, show provider and location
+                    clusterDesc = ` ${clusters[0].name} (${clusters[0].provider}, ${clusters[0].locationName})`;
+                }
+                else {
+                    // Many, list providers of clusters
+                    let byProvider = _.groupBy(clusters, c => c.provider);
+                    let delim = "";
+                    for (let provider in byProvider) {
+                        let qty = byProvider[provider].length;
+                        clusterDesc = clusterDesc.concat(delim, `${qty} ${provider}`);
+                        delim = ", ";
+                    }
+                    if (clusterDesc == "")
+                        clusterDesc = ` (${clusterDesc})`;
+                }
+            }
+            return clusterDesc;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    buildEnviroTree(rootMap) {
+        var _a;
+        let tree = [];
+        for (let ent of rootMap.enterprises) {
+            let entBranch = { text: `${ent.name} enterprise:` };
+            for (let env of _.sortBy(ent.environments, e => e.sequence, e => e.name)) {
+                let clusterDesc = this.buildEnviroClusterDesc((_a = env.clusters) !== null && _a !== void 0 ? _a : []);
+                let envBranch = {
+                    text: `${this._styler.hilite(env.name)}${this._styler.dim(clusterDesc)} `
+                };
+                if (entBranch.children === undefined)
+                    entBranch.children = [];
+                entBranch.children.push(envBranch);
+            }
+            tree.push(entBranch);
+        }
+        return tree;
+    }
+    FlattenEnviros(rootMap) {
+        var _a;
+        let flattened = [];
+        for (let ent of rootMap.enterprises) {
+            for (let env of _.sortBy(ent.environments, e => e.sequence, e => e.name)) {
+                flattened.push({
+                    name: env.name,
+                    sequence: env.sequence,
+                    enterprise: ent.name,
+                    clusters: (_a = env.clusters) !== null && _a !== void 0 ? _a : []
+                });
+            }
+        }
+        return flattened;
+    }
+}
+exports.default = EnvironmentList;
+EnvironmentList.description = 'Shows the list of environments.';
+EnvironmentList.aliases = ["enviro:list"];
+EnvironmentList.flags = {
+    output: core_1.Flags.string({ char: 'o', default: render_methods_1.OutputFormatsEnum.tree, description: "format in which to render the data.", options: [render_methods_1.OutputFormatsEnum.json, render_methods_1.OutputFormatsEnum.yaml, render_methods_1.OutputFormatsEnum.tree, render_methods_1.OutputFormatsEnum.text] }),
+    help: core_1.Flags.help({ char: 'h', description: 'Displays the help document for this command.' })
+};
+EnvironmentList.args = {};
+//# sourceMappingURL=list.js.map

package/dist/commands/filestore/capture.d.ts

@@ -0,0 +1,31 @@
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+export declare class PromptDefForString {
+    promptText: string;
+    promptId: string;
+    isValid: (val: string) => boolean;
+    getFromUser: (defaultVal: string | undefined) => Promise<string>;
+    constructor(promptText: string, promptId: string, isValid: (val: string) => boolean, getFromUser: (defaultVal: string | undefined) => Promise<string>);
+}
+export default class FilestoreCapture extends CommandBaseEnterprise {
+    static description: string;
+    static aliases: string[];
+    static dependsOn: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        enterprise: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        providerSubscriptionId: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        resourceGroup: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        storageAccount: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        shareName: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /** Implements the confirm default or prompt for value pattern. */
+    private confirmOrPrompt;
+    private localCache;
+    private promptForSubscription;
+    private createFileStoreDef;
+    /** Facory method for building a FileStoreDef from a fileshare */
+    private buildFileStoreDef;
+}