@codiac.io/codiac-cli 1.2.175 → 1.2.202

package/dist/commands/asset/helm.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const inquirer = require("inquirer");
+const _ = require("lodash");
+const codiac_domain_1 = require("@codiac.io/codiac-domain");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+const codiac_constants_1 = require("../../codiac-constants");
+const prettify_1 = require("../../prettify");
+const asset_types_enum_1 = require("@codiac.io/codiac-domain/enums/asset-types-enum");
+class AssetHelm extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        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 {
+                    this.bootstrap();
+                    const { args, flags } = yield this.parse(AssetHelm);
+                    this._userCntx = yield this.establishTenantContext(this._userCntx);
+                    let currentEnterprise = (yield this.establishEnterpriseContext(flags.enterprise)).enterprise;
+                    let partial = {};
+                    partial.enterprise = currentEnterprise.code;
+                    partial.name = flags.name;
+                    partial.code = flags.code;
+                    partial.port = flags.port;
+                    if (flags.hasIngress != undefined)
+                        partial.hasIngress = flags.hasIngress;
+                    if (flags.routedWithoutName != undefined)
+                        partial.routedWithoutName = flags.routedWithoutName;
+                    let chart = {};
+                    // REGISTRY
+                    chart.registry = flags.registry;
+                    if (!chart.registry) {
+                        while (!chart.registry || chart.registry == "") {
+                            let regResult = yield inquirer.prompt({ type: 'input', name: 'registry', message: 'chart registry: ', default: chart.registry || codiac_constants_1.DEFAULT_REGISTRY_URL });
+                            chart.registry = regResult.registry;
+                        }
+                    }
+                    // NOTE:  Still unclear as to how the repository name and the chart name are related.
+                    //        Are they just two refs to the same thing, only the repository name is immutable?
+                    //        Can one be derived or looked up given the other?
+                    let repoName = (yield this._ui.prompt("repoName", "Repository", true)); // <--- ! bc "required" flag doesnt translate to the tsc
+                    let registry = new codiac_domain_1.ImageRegistry(repoName, chart.registry, codiac_domain_1.CloudProviderEnum.other, codiac_domain_1.ImageRegistryTypes.helm);
+                    // CHART
+                    let chartFullName = flags.chart;
+                    if (!chartFullName) {
+                        while (!chartFullName || chartFullName == "") {
+                            // TODO: itd be nice to autoselect from registry)
+                            let nameResult = yield inquirer.prompt({ type: 'input', name: 'fullName', message: 'chart name (including scope prefix): ', default: chartFullName || partial.name });
+                            chartFullName = nameResult.fullName;
+                        }
+                        // validate existence
+                    }
+                    let split = chartFullName.split("/");
+                    chart.name = _.last(split) || chartFullName;
+                    if (split.length > 1)
+                        chart.scope = split[0];
+                    partial.image = new codiac_domain_1.Image(chart.name, registry, chart.scope);
+                    // ASSET NAME
+                    if (!partial.name) {
+                        while (!partial.name || partial.name == "") {
+                            // TODO: itd be nice to autoselect from registry)
+                            let assetNameResult = yield inquirer.prompt({ type: 'input', name: 'assetName', message: 'Name for the asset within the enteprise: ', default: partial.name || partial.image.name });
+                            partial.name = assetNameResult.assetName;
+                        }
+                    }
+                    // PORT
+                    let isValid = true; // validate port number for collisions with existing assets in the enterprise
+                    if (!partial.port || !isValid) {
+                        while (!partial.port || !isValid) {
+                            let portResult = yield inquirer.prompt({ type: 'number', name: 'port', message: 'Default port number to assign this asset when deploying to a cabinet: ', default: partial.port });
+                            partial.port = portResult.port;
+                            isValid = true; // TODO:  Validate port number
+                        }
+                    }
+                    // INGRESS
+                    if (partial.hasIngress == undefined) {
+                        let ingressResult = yield inquirer.prompt({ type: 'confirm', name: 'hasIngress', message: 'Allow external requests (aka: has ingress route): ', default: false });
+                        partial.hasIngress = ingressResult.hasIngress;
+                    }
+                    // HOST NAME
+                    if (partial.hasIngress == true) {
+                        while (!partial.code) {
+                            let hostNameResult = yield inquirer.prompt({ type: 'input', name: 'code', message: 'Host name on the inbound domain url: ', default: partial.code || partial.name });
+                            partial.code = hostNameResult.code;
+                        }
+                        let ingressResult = yield inquirer.prompt({ type: 'confirm', name: 'routedWithoutName', message: 'Will this asset be the base ingress against your DNS. eg: true services yourwebsite.com (as root/naked): ', default: false });
+                        partial.routedWithoutName = ingressResult.routedWithoutName;
+                        // TODO:  Three can only be one asset with the option selected.  Unset the others if they set this.
+                    }
+                    if (!partial.code)
+                        partial.code = partial.name;
+                    let candidate = new codiac_domain_1.Asset(partial.enterprise, partial.code, partial.name, partial.image, partial.port || 0, partial.hasIngress, partial.routedWithoutName);
+                    candidate.type = asset_types_enum_1.AssetTypesEnum.helm;
+                    this._ui.userMessage((0, prettify_1.prettify)(candidate));
+                    this._ui.userMessage(`You are about to add this new Helm asset as ${this._styler.bold(this._styler.hilite(candidate.name))} to enterprise ${this._styler.hilite(candidate.enterprise)} [Tenant: ${this._userCntx.currentTenantCode}].`);
+                    let confirmResult = yield this._ui.promptConfirm("confirmCreateAsset", "Continue?", false);
+                    if (confirmResult == true) {
+                        yield this.createAsset(candidate);
+                    }
+                    else {
+                        this._ui.userMessage(`Operation cancelled. No work was done.`);
+                    }
+                    resolve();
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    // reject(err);
+                    resolve();
+                }
+            }));
+        });
+    }
+    createAsset(asset) {
+        return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let result = yield this._codiacApi.Asset.tryCreate(asset);
+                if (result.error)
+                    throw result.error;
+                if (!result.success || !result.output)
+                    throw new Error(`Failed without error creating asset [${asset.name}]: ${result.message}.`);
+                this.logger.notice(`${this._styler.colorGood("SUCCESS!")} Created new Helm asset ${this._styler.bold(this._styler.hilite(asset.name))} in enterprise ${this._styler.bold(this._styler.hilite(asset.enterprise))}.`, result.output);
+                this._ui.userMessage(`${this._styler.colorGood("SUCCESS!")} Created new Helm asset ${this._styler.bold(this._styler.hilite(asset.name))} in enterprise ${this._styler.bold(this._styler.hilite(asset.enterprise))}.`);
+                resolve();
+            }
+            catch (err) {
+                this.logger.error(err, asset);
+                resolve();
+                // reject(err);
+            }
+        }));
+    }
+}
+exports.default = AssetHelm;
+AssetHelm.description = 'Creates a new asset in the given enterprise from an image that exists in a container registry.';
+AssetHelm.aliases = ['asset:new'];
+AssetHelm.dependsOn = ["image", "registry", "name", "code", "enterprise", "port", "hasIngress", "routedWithoutName"];
+AssetHelm.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    chart: core_1.Flags.string({ char: 'i', required: false, description: "The chart name including scope prefix if applicable (eg: '@yourCompany/your-helm-chart')." }),
+    registry: core_1.Flags.string({ char: 'r', required: false, description: "The chart registry in which the chart exists (defaults to docker hub)." }),
+    name: core_1.Flags.string({ char: 'n', required: false, description: "The name to give the enterprise asset (Optional: defaults to the image name without the scope prefix)." }),
+    code: core_1.Flags.string({ char: 'c', required: false, description: "The host name to assign this asset in the domain url.  eg: 'myasset' in 'myasset.your-domain.com' (Optional: defaults to the asset name)." }),
+    enterprise: core_1.Flags.string({ char: 'e', required: false, description: 'The name of the enterprise in which to create this asset. (defaults to the current enterprise context)' }),
+    port: core_1.Flags.integer({ char: 'p', required: false, description: 'The default port to assign the asset when deployed to a cabinet (optional).' }),
+    hasIngress: core_1.Flags.boolean({ char: 'g', required: false, description: 'Declaration that the asset service is to be externally accessible (optional: defaults to false).' }),
+    routedWithoutName: core_1.Flags.boolean({ char: 'o', required: false, description: 'Indicates that this asset will be the base ingress against your DNS. eg: true services yourwebsite.com (as root/naked) (optional: defaults to false).' }),
+    silent: core_1.Flags.boolean({ char: 'y', dependsOn: AssetHelm.dependsOn, required: false, description: `(Optional: defaults to false) Prevents confirmations of user-values that are remembered from prior runs. Requires: ${AssetHelm.dependsOn}` })
+};
+AssetHelm.args = {
+    setting: core_1.Args.string({ description: 'The key for the config setting to add' })
+};
+//# sourceMappingURL=helm.js.map

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

@@ -0,0 +1,28 @@
+import { AssetTypesEnum } from '../../apis/codiac-api/contracts';
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+export declare type FlatAsset = {
+    name: string;
+    code: string;
+    image: string;
+    registry: string;
+    registryProvider: string;
+    hasIngress?: boolean | undefined;
+    port: number;
+    enterprise: string;
+    product?: string | undefined;
+    type?: AssetTypesEnum | undefined;
+    routedWithoutName?: boolean | undefined;
+};
+export default class AssetList extends CommandBaseEnterprise {
+    static description: 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 buildAssetListForText;
+    private renderAssetDetails;
+    private buildAssetTree;
+    private FlattenAsset;
+}

package/dist/commands/asset/list.js

@@ -0,0 +1,172 @@
+"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 AssetList extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.bootstrap();
+            const { args, flags } = yield this.parse(AssetList);
+            try {
+                this._userCntx = yield this.establishTenantContext(this._userCntx);
+                let currentEnterprise = (yield this.establishEnterpriseContext()).enterprise;
+                // RETRIEVE 
+                // if ([OutputFormatsEnum.json, OutputFormatsEnum.yaml].includes(outputFormat) === false) this._ui.startSpinner("Retrieving");
+                // let rootMapResult = await this._codiacApi.Call.getRootMap(<RootMapCriteria>{ enterprise: currentEnterprise.code });
+                // let rootMap: RootMap = <RootMap><any>rootMapResult; // readmany rootmap result returns a single entity instead of a list result.
+                // let envCount = 0;
+                // rootMap.enterprises.forEach(e => envCount += e.environments.length);
+                // if ([OutputFormatsEnum.json, OutputFormatsEnum.yaml].includes(outputFormat) === false) this._ui.stopSpinner(`found ${envCount}`);
+                let outputFormat = (_a = render_methods_1.OutputFormatsEnum[flags.output]) !== null && _a !== void 0 ? _a : render_methods_1.OutputFormatsEnum.tree;
+                // RENDER
+                let output = "";
+                switch (outputFormat) {
+                    case render_methods_1.OutputFormatsEnum.json:
+                        // let listForJson: FlatEnviro[] = this.FlattenEnviros(rootMap);
+                        let listForJson = currentEnterprise.assets.map(a => this.FlattenAsset(a));
+                        listForJson = _.sortBy(listForJson, e => e.enterprise, a => { var _a; return (_a = a.product) !== null && _a !== void 0 ? _a : " "; }, c => c.name);
+                        output = JSON.stringify(listForJson, undefined, 2);
+                        this._ui.userMessage(output);
+                        break;
+                    case render_methods_1.OutputFormatsEnum.yaml:
+                        let listForYaml = currentEnterprise.assets.map(a => this.FlattenAsset(a));
+                        listForYaml = _.sortBy(listForYaml, c => c.enterprise, a => { var _a; return (_a = a.product) !== null && _a !== void 0 ? _a : " "; }, c => c.name);
+                        output = YAML.stringify(listForYaml, { indent: 2 });
+                        this._ui.userMessage(output);
+                        break;
+                    case render_methods_1.OutputFormatsEnum.text:
+                        let flatList = currentEnterprise.assets.map(a => this.FlattenAsset(a));
+                        flatList = _.sortBy(flatList, c => c.enterprise, a => { var _a; return (_a = a.product) !== null && _a !== void 0 ? _a : " "; }, c => c.name);
+                        let listForText = this.buildAssetListForText(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 tree = this.buildAssetTree((_c = (_b = currentEnterprise.assets) === null || _b === void 0 ? void 0 : _b.map(a => this.FlattenAsset(a))) !== null && _c !== void 0 ? _c : []);
+                        let out = render.renderStringTree(tree); //, this._ui.userMessage);
+                        this._ui.userMessage(out);
+                        break;
+                }
+                // if ([OutputFormatsEnum.tree].includes(outputFormat)) {
+                //   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, outputFormat);
+                // }
+                return;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    buildAssetListForText(flatList) {
+        try {
+            let listForText = flatList.map(asset => {
+                let output = this._styler.hilite(asset.name);
+                // output = output.concat
+                if (asset.product !== undefined) {
+                    output = asset.product.concat("/", output); // product prefix
+                }
+                output = asset.enterprise.concat("/", output); // enterprise prefix
+                let details = this.renderAssetDetails(asset);
+                output = output.concat(this._styler.dim(` (${details})`));
+                return output;
+            });
+            return listForText;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    renderAssetDetails(asset) {
+        let details = `port: ${asset.port}`;
+        if (asset.hasIngress) {
+            details = details.concat(", HasIngress");
+        }
+        else {
+            details = details.concat(", no ingress");
+        }
+        if (asset.routedWithoutName === true) {
+            details = details.concat(", RoutedWithoutName");
+        }
+        details = details.concat(`, from ${asset.registry}`);
+        return details;
+    }
+    buildAssetTree(assets) {
+        let tree = [];
+        let sorted = _.sortBy(assets, a => a.enterprise, a => a.product, a => a.name);
+        let byProduct = _.groupBy(assets, a => a.product);
+        let entBranch;
+        for (let product of Object.keys(byProduct).sort()) {
+            let prodAssets = byProduct[product];
+            let prodBranch = { text: product };
+            for (let asset of _.sortBy(prodAssets, a => a.name)) {
+                let text = this._styler.hilite(asset.name);
+                let details = this.renderAssetDetails(asset);
+                text = text.concat(this._styler.dim(` (${details})`));
+                let assetBranch = { text: text };
+                if (prodBranch.children === undefined)
+                    prodBranch.children = [];
+                prodBranch.children.push(assetBranch);
+                if (entBranch === undefined) {
+                    entBranch = { text: `Enterprise: ${asset.enterprise}` };
+                }
+            }
+            if (entBranch !== undefined) {
+                if (entBranch.children === undefined)
+                    entBranch.children = [];
+                if (product === "undefined") { // Because: loose assets (not in a product) need to go directly under the enterprise.
+                    if (prodBranch.children) {
+                        entBranch.children.unshift(...prodBranch.children);
+                    }
+                }
+                else {
+                    entBranch.children.push(prodBranch);
+                }
+            }
+        }
+        if (entBranch !== undefined) {
+            tree.push(entBranch);
+        }
+        return tree;
+    }
+    FlattenAsset(a) {
+        let flattened = {
+            name: a.name,
+            code: a.code,
+            enterprise: a.enterprise,
+            hasIngress: a.hasIngress,
+            port: a.port,
+            product: a.product,
+            type: a.type,
+            routedWithoutName: a.routedWithoutName,
+            image: a.image.name,
+            registry: a.image.registry.code,
+            registryProvider: a.image.registry.provider
+        };
+        return flattened;
+    }
+}
+exports.default = AssetList;
+AssetList.description = 'Shows the list of assets in a given enterprise.';
+AssetList.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.' })
+};
+AssetList.args = {};
+//# sourceMappingURL=list.js.map

package/dist/commands/asset/probe/create.d.ts

@@ -0,0 +1,38 @@
+import { CommandBaseEnterprise } from '../../../command-base-enterprise';
+export default class AssetProbeCreate extends CommandBaseEnterprise {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        cmd: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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>;
+        asset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        versions: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        usage: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        delay: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        period: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        predefined: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        exec: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        grpc: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        http: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        socket: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        action: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        execCommand: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        grpcHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        grpcPort: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        httpScheme: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        httpHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        httpPort: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        httpPath: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        httpHeader: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        socketHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        socketPort: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /** @param kvps (in format key=value) */
+    private toDictionary;
+}

package/dist/commands/asset/probe/create.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const codiac_domain_1 = require("@codiac.io/codiac-domain");
+const core_1 = require("@oclif/core");
+const command_base_enterprise_1 = require("../../../command-base-enterprise");
+class AssetProbeCreate 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(AssetProbeCreate);
+            (_a = this._relayContainer) === null || _a === void 0 ? void 0 : _a.ready$.subscribe((ready) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _b, _c, _d, _e, _f, _g, _h, _j;
+                try {
+                    let probe;
+                    // STEP 1: Select the target asset
+                    this._userCntx = yield this.establishTenantContext(this._userCntx);
+                    let enterprise = (yield this.establishEnterpriseContext()).enterprise;
+                    let aCntx = yield this.establishAssetContext(enterprise, true);
+                    let assetName = aCntx[0];
+                    let asset = enterprise.assets.find(a => a.name === assetName); // we're only looking for one.
+                    if (asset === undefined) {
+                        throw new Error(`Could not find asset ${aCntx} in enterprise ${enterprise.code}.`);
+                    }
+                    // STEP 2) assemble the probe
+                    let actionType = codiac_domain_1.ProbeActionTypesEnum.exec;
+                    if (flags.exec)
+                        actionType = codiac_domain_1.ProbeActionTypesEnum.exec;
+                    if (flags.grpc)
+                        actionType = codiac_domain_1.ProbeActionTypesEnum.grpc;
+                    if (flags.http)
+                        actionType = codiac_domain_1.ProbeActionTypesEnum.http;
+                    if (flags.socket)
+                        actionType = codiac_domain_1.ProbeActionTypesEnum.socket;
+                    let probeAction;
+                    if (flags.predefined) {
+                        // Calling out for a predefined Probe action 
+                        probeAction = flags.predefined;
+                    }
+                    else {
+                        // Probe action defined by the command args            
+                        switch (actionType) {
+                            case codiac_domain_1.ProbeActionTypesEnum.exec:
+                                let cmd;
+                                if (args.cmd) {
+                                    cmd = args.cmd;
+                                    let isep = this.argv.indexOf("--");
+                                    if (isep >= 0) {
+                                        if (isep + 1 < this.argv.length) {
+                                            cmd = this.argv.slice(isep + 1);
+                                        }
+                                        else {
+                                            cmd = undefined;
+                                        }
+                                    }
+                                }
+                                probeAction = { actionType: codiac_domain_1.ProbeActionTypesEnum.exec, command: cmd };
+                                break;
+                            case codiac_domain_1.ProbeActionTypesEnum.grpc:
+                                probeAction = { actionType: codiac_domain_1.ProbeActionTypesEnum.grpc, port: flags.grpcPort, service: flags.grpcHost };
+                                break;
+                            case codiac_domain_1.ProbeActionTypesEnum.http:
+                                probeAction = {
+                                    actionType: codiac_domain_1.ProbeActionTypesEnum.http,
+                                    scheme: (_c = (_b = flags.httpScheme) === null || _b === void 0 ? void 0 : _b.toUpperCase()) !== null && _c !== void 0 ? _c : "HTTP",
+                                    host: flags.httpHost,
+                                    port: (_e = (_d = flags.httpPort) !== null && _d !== void 0 ? _d : asset.port) !== null && _e !== void 0 ? _e : 80,
+                                    path: (_f = flags.httpPath) !== null && _f !== void 0 ? _f : "",
+                                    httpHeaders: this.toDictionary((_g = flags.httpHeader) !== null && _g !== void 0 ? _g : [])
+                                };
+                                break;
+                            case codiac_domain_1.ProbeActionTypesEnum.socket:
+                                probeAction = {
+                                    actionType: codiac_domain_1.ProbeActionTypesEnum.socket,
+                                    host: flags.socketHost,
+                                    port: flags.socketPort
+                                };
+                                break;
+                        }
+                    }
+                    let usage = codiac_domain_1.ProbeUsageTypesEnum[flags.usage];
+                    probe = new codiac_domain_1.Probe(enterprise.code, assetName, usage, probeAction);
+                    if (flags.delay)
+                        probe.initialDelaySeconds = flags.delay;
+                    if (flags.period)
+                        probe.periodSeconds = flags.period;
+                    if (flags.versions)
+                        probe.versionRange = flags.versions;
+                    // STEP 3) write it          
+                    this.logger.trace(`Writing new Probe`, probe);
+                    let saved = yield this._codiacApi.Probe.create(probe);
+                    this.logger.trace("Saved probe", saved);
+                    this._ui.userMessage(`${this._styler.colorGood("SUCCESSFUL!")} Created ${(typeof probeAction == 'string') ? `using predefined action [${probeAction}]` : `${probeAction.actionType} action`} as ${probe.type} probe for asset ${asset.name} in ${enterprise.code}.`);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    this._ui.userMessage(`${this._styler.colorCritical("ERROR!")} ${(_h = err.name) !== null && _h !== void 0 ? _h : ""} ${(_j = err.message) !== null && _j !== void 0 ? _j : ""}.`);
+                }
+            }));
+        });
+    }
+    /** @param kvps (in format key=value) */
+    toDictionary(kvps) {
+        let output = [];
+        for (let expr of kvps) {
+            let parts = expr.split("=");
+            if (parts.length === 2) {
+                output.push({ name: parts[0], value: parts[1] });
+            }
+            else if (parts.length === 1) {
+                output.push({ name: parts[0], value: "" });
+            }
+        }
+        return output;
+    }
+}
+exports.default = AssetProbeCreate;
+AssetProbeCreate.description = 'Declares the implementation of a health or readiness probe for an asset.';
+AssetProbeCreate.aliases = ["asset:probe:create"];
+AssetProbeCreate.examples = [
+    `cod probe:create --predefined builtin-heartbeat-file-exists`,
+    `cod probe:create -p 15 --exec --execCommand "cat /app/data/last-heartbeat.json"`,
+    `cod probe:create -n acme -a myapi -u readiness -p 15 --exec --execCommand "cat /app/data/last-heartbeat.json"`,
+    `cod probe:create -n acme -a myapi -u readiness -p 15 --exec --execCommand cat --execCommand /app/data/last-heartbeat.json`,
+    `cod probe:create -n acme -a myapi -u readiness -p 15 --http --httpScheme https --httpHost myapi.acme.com --httpPort 443 --httpPath /diag/heartbeat -h Accept=application/json -h user-agent=MyUserAgent`
+];
+AssetProbeCreate.strict = false; // disables argument validation so we can support variable-length arguments.
+AssetProbeCreate.args = {
+    cmd: core_1.Args.string({ description: '(requires --exec) command and its space-separated arguments to run in the target replica.' })
+};
+AssetProbeCreate.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    enterprise: core_1.Flags.string({ char: 'n', required: false, description: 'The name of the enterprise to which this probe is to apply.' }),
+    asset: core_1.Flags.string({ char: 'a', required: false, description: 'The name of the asset to which this probe is to apply.' }),
+    versions: core_1.Flags.string({ char: 'v', description: 'Asset version range for which this probe is to be used. (optional: defaults to >=latest)' }),
+    usage: core_1.Flags.string({ char: 'u', default: codiac_domain_1.ProbeUsageTypesEnum.readiness, required: true, description: 'The diagnostic purpose the probe will serve.', options: [codiac_domain_1.ProbeUsageTypesEnum.readiness, codiac_domain_1.ProbeUsageTypesEnum.liveness, codiac_domain_1.ProbeUsageTypesEnum.startup] }),
+    delay: core_1.Flags.integer({ char: 'd', default: 0, description: 'The time (in seconds) to wait before the first execution of the probe.' }),
+    period: core_1.Flags.integer({ char: 'p', default: 10, description: 'How often (in seconds) to fire the probe.' }),
+    predefined: core_1.Flags.string({ description: 'Calls out by name for an existing standard or shared probe action.  Use this argument instead of defining the probe action with the exec, grpc, http or socket arguments.', exclusive: ['exec', 'grpc', 'http', 'socket'] }),
+    exec: core_1.Flags.boolean({ description: 'Declares the probe shall be carried out as an executable CLI command. A return code of zero indicates success.  Any nonzero result indicates failure.', exclusive: ['predefined', 'grpc', 'http', 'socket'] }),
+    grpc: core_1.Flags.boolean({ description: 'Declares the probe shall be carried out as a grpc api request.', exclusive: ['predefined', 'exec', 'http', 'socket'] }),
+    http: core_1.Flags.boolean({ description: 'Declares the probe shall be carried out as an http request. Any code greater than or equal to 200 and less than 400 indicates success. Any other code indicates failure.', exclusive: ['predefined', 'exec', 'grpc', 'socket'] }),
+    socket: core_1.Flags.boolean({ description: 'Declares the probe shall be carried out as a TCP Socket request.', exclusive: ['predefined', 'exec', 'grpc', 'http'] }),
+    action: core_1.Flags.string({ char: 'x', description: 'The JSON specification for the probe action itself.  The structure follows the actionType.' }),
+    execCommand: core_1.Flags.string({
+        multiple: true, dependsOn: ['exec'], description: '(For use only with exec) The executable command to run as the probe, as a single string, or as an array of commands and arguments.  If it returns any nonzero result, the probe gets interpreted as a negative/failure.',
+        exclusive: ['grpcHost', 'grpcPort', 'httpScheme', 'httpHost', 'httpPort', 'httpPath', 'httpHeader', 'socketHost', 'socketPort']
+    }),
+    grpcHost: core_1.Flags.string({
+        description: '(For use only with grpc).', dependsOn: ['grpc'],
+        exclusive: ['execCommand', 'httpScheme', 'httpHost', 'httpPort', 'httpPath', 'httpHeader', 'socketHost', 'socketPort']
+    }),
+    grpcPort: core_1.Flags.integer({
+        description: '(For use only with grpc).', dependsOn: ['grpc'],
+        exclusive: ['execCommand', 'httpScheme', 'httpHost', 'httpPort', 'httpPath', 'httpHeader', 'socketHost', 'socketPort']
+    }),
+    httpScheme: core_1.Flags.string({
+        options: ["http", "https"], description: '(For use only with http) The http protocol to use.', dependsOn: ['http'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'socketHost', 'socketPort']
+    }),
+    httpHost: core_1.Flags.string({
+        description: '.', dependsOn: ['http'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'socketHost', 'socketPort']
+    }),
+    httpPort: core_1.Flags.integer({
+        description: '(For use only with http).', dependsOn: ['http'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'socketHost', 'socketPort']
+    }),
+    httpPath: core_1.Flags.string({
+        description: '(For use only with http).', dependsOn: ['http'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'socketHost', 'socketPort']
+    }),
+    httpHeader: core_1.Flags.string({
+        char: 'h', multiple: true, dependsOn: ['http'], description: '(For use only with http) Key value pair (in format x=y) to be used as an http header in an http probe action.',
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'socketHost', 'socketPort']
+    }),
+    socketHost: core_1.Flags.string({
+        description: '(For use only with socket).', dependsOn: ['socket'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'httpScheme', 'httpHost', 'httpPort', 'httpPath', 'httpHeader']
+    }),
+    socketPort: core_1.Flags.integer({
+        description: '(For use only with socket).', dependsOn: ['socket'],
+        exclusive: ['execCommand', 'grpcHost', 'grpcPort', 'httpScheme', 'httpHost', 'httpPort', 'httpPath', 'httpHeader']
+    })
+};
+//# sourceMappingURL=create.js.map

package/dist/commands/asset/recycle.d.ts

@@ -0,0 +1,23 @@
+import "reflect-metadata";
+import { Asset } from '../../apis/codiac-api/contracts';
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+/** 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. */
+export declare const PROMPT_ME_DESIGNATOR = "?";
+export default class AssetRecycle extends CommandBaseEnterprise {
+    static description: string;
+    static dependsOn: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        enterpriseCode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        cabinetName: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        asset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {};
+    run(): Promise<void>;
+    promptForAsset(enterprise: string, assetSearch?: string): Promise<Asset>;
+    private searchVersions;
+}