@contentstack/cli-utilities 0.1.1-beta.1

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFlagDeprecation = exports.configHandler = exports.messageHandler = exports.CLIError = exports.cliux = exports.logger = void 0;
+const tslib_1 = require("tslib");
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return tslib_1.__importDefault(logger_1).default; } });
+var cli_ux_1 = require("./cli-ux");
+Object.defineProperty(exports, "cliux", { enumerable: true, get: function () { return tslib_1.__importDefault(cli_ux_1).default; } });
+var cli_error_1 = require("./cli-error");
+Object.defineProperty(exports, "CLIError", { enumerable: true, get: function () { return tslib_1.__importDefault(cli_error_1).default; } });
+var message_handler_1 = require("./message-handler");
+Object.defineProperty(exports, "messageHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(message_handler_1).default; } });
+var config_handler_1 = require("./config-handler");
+Object.defineProperty(exports, "configHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(config_handler_1).default; } });
+var flag_deprecation_check_1 = require("./flag-deprecation-check");
+Object.defineProperty(exports, "printFlagDeprecation", { enumerable: true, get: function () { return tslib_1.__importDefault(flag_deprecation_check_1).default; } });
+tslib_1.__exportStar(require("./http-client"), exports);

package/lib/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logger.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const winston_1 = tslib_1.__importDefault(require("winston"));
+const message_handler_1 = tslib_1.__importDefault(require("./message-handler"));
+class LoggerService {
+    constructor(name) {
+        this.data = null;
+        this.name = null;
+        const logger = winston_1.default.createLogger({
+            transports: [
+                // new winston.transports.Console(),
+                new winston_1.default.transports.File({
+                    filename: `./logs/${name}.log`,
+                }),
+            ],
+            format: winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.printf((info) => {
+                let stringifiedParam;
+                try {
+                    stringifiedParam = JSON.stringify(info.obj);
+                }
+                catch (error) {
+                    console.log('warning: failed to log the result');
+                }
+                // parse message
+                info.message = message_handler_1.default.parse(info.message);
+                let message = `${LoggerService.dateFormat()}:${name}:${info.level}:${info.message}`;
+                message = info.obj ? message + `:${stringifiedParam}` : message;
+                message = this.data ? message + `:${JSON.stringify(this.data)}` : message;
+                return message;
+            })),
+            // level: (config.get('logger.level') as string) || 'error',
+            level: 'error',
+            silent: true
+            // silent: config.get('logger.enabled') && process.env.CLI_ENV !== 'TEST' ? false : false,
+        });
+        this.logger = logger;
+    }
+    static dateFormat() {
+        return new Date(Date.now()).toUTCString();
+    }
+    init(context) {
+        this.name = (context && context.plugin && context.plugin.name) || 'cli';
+    }
+    set loggerName(name) {
+        this.name = name;
+    }
+    setLogData(data) {
+        this.data = data;
+    }
+    async info(message, param) {
+        if (param) {
+            this.logger.log('info', message, {
+                obj: param,
+            });
+        }
+        else {
+            this.logger.log('info', message);
+        }
+    }
+    async debug(message, param) {
+        if (param) {
+            this.logger.log('debug', message, {
+                obj: param,
+            });
+        }
+        else {
+            this.logger.log('debug', message);
+        }
+    }
+    async error(message, param) {
+        if (param) {
+            this.logger.log('error', message, {
+                obj: param,
+            });
+        }
+        else {
+            this.logger.log('error', message);
+        }
+    }
+    async warn(message, param) {
+        if (param) {
+            this.logger.log('warn', message, {
+                obj: param,
+            });
+        }
+        else {
+            this.logger.log('warn', message);
+        }
+    }
+}
+exports.default = new LoggerService('cli');

package/lib/message-handler.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const cli_error_1 = tslib_1.__importDefault(require("./cli-error"));
+/**
+ * Message handler
+ */
+class Messages {
+    constructor() {
+        this.messages = {};
+    }
+    init(context) {
+        if (!context.messageFilePath) {
+            return;
+        }
+        try {
+            this.messages = JSON.parse(fs_1.default.readFileSync(context.messageFilePath, 'utf-8'));
+        }
+        catch (error) {
+            // create empty messages object if message file is not exist
+            if (error.code === 'ENOENT') {
+                this.messages = {};
+            }
+            else {
+                throw new cli_error_1.default(error.message);
+            }
+        }
+    }
+    parse(messageKey, ...substitutions) {
+        const msg = this.messages[messageKey];
+        if (!msg) {
+            return messageKey;
+        }
+        if (substitutions.length > 0) {
+            const callSite = msg.split('%s');
+            callSite.push('');
+            return String.raw({ raw: callSite }, ...substitutions);
+        }
+        return msg;
+    }
+}
+exports.default = new Messages();

package/lib/selectors/index.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseDeliveryTokenAlias = exports.chooseTokenAlias = exports.chooseLocale = exports.chooseLocales = exports.chooseEnvironment = exports.chooseEnvironments = exports.chooseContentTypes = exports.chooseEntry = exports.chooseContentType = exports.chooseStack = exports.chooseOrganization = void 0;
+const tslib_1 = require("tslib");
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const config_handler_1 = tslib_1.__importDefault(require("../config-handler"));
+const validations_1 = require("./validations");
+const inquirer = require('inquirer');
+inquirer.registerPrompt('search-list', require('inquirer-search-list'));
+inquirer.registerPrompt('search-checkbox', require('inquirer-search-checkbox'));
+const { Command } = require('@contentstack/cli-command');
+function chooseOrganization(client, displayMessage, region, orgUid) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Organizations').start();
+            let { items: organizations } = await client.organization().fetchAll();
+            spinner.stop();
+            let orgMap = {};
+            if (orgUid) {
+                organizations.forEach((org) => {
+                    orgMap[org.uid] = org.name;
+                });
+                if (orgMap[orgUid]) {
+                    resolve({ orgUid: orgUid, orgName: orgMap[orgUid] });
+                }
+                else {
+                    return reject(new Error('The given orgUid doesn\'t exist or you might not have access to it.'));
+                }
+            }
+            else {
+                organizations.forEach((org) => {
+                    orgMap[org.name] = org.uid;
+                });
+                const orgList = Object.keys(orgMap);
+                let inquirerConfig = {
+                    type: 'search-list',
+                    name: 'chosenOrganization',
+                    message: displayMessage || 'Choose an organization',
+                    choices: orgList,
+                    loop: false,
+                    validate: validations_1.shouldNotBeEmpty
+                };
+                inquirer.prompt(inquirerConfig).then(({ chosenOrganization }) => {
+                    resolve({ orgUid: orgMap[chosenOrganization], orgName: chosenOrganization });
+                });
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+exports.chooseOrganization = chooseOrganization;
+function chooseStack(client, organizationId, displayMessage, region) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Stacks').start();
+            let { items: stacks } = await client.stack({ organization_uid: organizationId }).query({ query: {} }).find();
+            spinner.stop();
+            let stackMap = {};
+            stacks.forEach((stack) => {
+                stackMap[stack.name] = stack.api_key;
+            });
+            const stackList = Object.keys(stackMap);
+            let inquirerConfig = {
+                type: 'search-list',
+                name: 'chosenStack',
+                choices: stackList,
+                message: displayMessage || 'Choose a stack',
+                loop: false,
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenStack }) => {
+                resolve({ api_key: stackMap[chosenStack], name: chosenStack });
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseStack = chooseStack;
+function chooseContentType(stackApiKey, displayMessage, region) {
+    return new Promise(async (resolve, reject) => {
+        const command = new Command();
+        command.managementAPIClient = { host: command.cmaHost, authtoken: command.authToken };
+        const client = command.managementAPIClient;
+        try {
+            const spinner = (0, ora_1.default)('Loading Content Types').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let contentTypes = await getAll(client.stack({ api_key: stackApiKey }).contentType());
+            spinner.stop();
+            let contentTypeMap = {};
+            contentTypes.forEach((contentType) => {
+                contentTypeMap[contentType.title] = contentType.uid;
+            });
+            const contentTypeList = Object.keys(contentTypeMap);
+            let inquirerConfig = {
+                type: 'search-list',
+                name: 'chosenContentType',
+                choices: contentTypeList,
+                message: displayMessage || 'Choose a content type',
+                loop: false,
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenContentType }) => {
+                resolve({ uid: contentTypeMap[chosenContentType], title: chosenContentType });
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseContentType = chooseContentType;
+function chooseEntry(contentTypeUid, stackApiKey, displayMessage, region) {
+    return new Promise(async (resolve, reject) => {
+        const command = new Command();
+        command.managementAPIClient = { host: command.cmaHost, authtoken: command.authToken };
+        const client = command.managementAPIClient;
+        try {
+            const spinner = (0, ora_1.default)('Loading Entries').start();
+            let entries = await getAll(client.stack({ api_key: stackApiKey }).contentType(contentTypeUid).entry());
+            spinner.stop();
+            let entryMap = {};
+            entries.forEach((entry) => {
+                entryMap[entry.title] = entry.uid;
+            });
+            const entryList = Object.keys(entryMap);
+            let inquirerConfig = {
+                type: 'search-list',
+                name: 'chosenEntry',
+                choices: entryList,
+                message: displayMessage || 'Choose an entry',
+                loop: false
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenEntry }) => {
+                resolve({ uid: entryMap[chosenEntry], title: chosenEntry });
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseEntry = chooseEntry;
+function chooseContentTypes(stack, displayMessage) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Content Types').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let contentTypes = await getAll(stack.contentType());
+            spinner.stop();
+            let contentTypeMap = {};
+            contentTypes.forEach((contentType) => {
+                contentTypeMap[contentType.title] = contentType.uid;
+            });
+            const contentTypeList = Object.keys(contentTypeMap);
+            let inquirerConfig = {
+                type: 'search-checkbox',
+                name: 'chosenContentTypes',
+                choices: contentTypeList,
+                message: displayMessage || 'Choose a content type',
+                loop: false,
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenContentTypes }) => {
+                let result = chosenContentTypes.map(ct => {
+                    let foo = { uid: contentTypeMap[ct], title: ct };
+                    return foo;
+                });
+                resolve(result);
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseContentTypes = chooseContentTypes;
+function chooseEnvironments(stack, displayMessage) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Environments').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let environments = await getAll(stack.environment());
+            spinner.stop();
+            let environmentMap = {};
+            environments.forEach((environment) => {
+                environmentMap[environment.name] = environment.uid;
+            });
+            const environmentList = Object.keys(environmentMap);
+            let inquirerConfig = {
+                type: 'search-checkbox',
+                name: 'chosenEnvironments',
+                choices: environmentList,
+                message: displayMessage || 'Choose an environment',
+                loop: false,
+                validate: validations_1.shouldNotBeEmpty
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenEnvironments }) => {
+                let result = chosenEnvironments.map(env => {
+                    let foo = { uid: environmentMap[env], name: env };
+                    return foo;
+                });
+                resolve(result);
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseEnvironments = chooseEnvironments;
+function chooseEnvironment(stack, displayMessage) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Environments').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let environments = await getAll(stack.environment());
+            spinner.stop();
+            let environmentMap = {};
+            environments.forEach((environment) => {
+                environmentMap[environment.name] = environment.uid;
+            });
+            const environmentList = Object.keys(environmentMap);
+            let inquirerConfig = {
+                type: 'search-list',
+                name: 'chosenEnvironment',
+                choices: environmentList,
+                message: displayMessage || 'Choose an environment',
+                loop: false,
+                validate: validations_1.shouldNotBeEmpty
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenEnvironment }) => {
+                let result = { uid: environmentMap[chosenEnvironment], name: chosenEnvironment };
+                resolve(result);
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseEnvironment = chooseEnvironment;
+function chooseLocales(stack, displayMessage) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Locales').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let locales = await getAll(stack.locale());
+            spinner.stop();
+            let localeMap = {};
+            locales.forEach((locale) => {
+                localeMap[locale.name] = locale.code;
+            });
+            const localeList = Object.keys(localeMap);
+            let inquirerConfig = {
+                type: 'search-checkbox',
+                name: 'chosenLocales',
+                choices: localeList,
+                message: displayMessage || 'Choose locales',
+                loop: false,
+                validate: validations_1.shouldNotBeEmpty,
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenLocales }) => {
+                let result = chosenLocales.map(locale => {
+                    let foo = { code: localeMap[locale], name: locale };
+                    return foo;
+                });
+                resolve(result);
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseLocales = chooseLocales;
+function chooseLocale(stack, displayMessage) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const spinner = (0, ora_1.default)('Loading Locales').start();
+            // let {items: contentTypes} = await client.stack({api_key: stackApiKey}).contentType().query({include_count: true}).find()
+            let locales = await getAll(stack.locale());
+            spinner.stop();
+            let localeMap = {};
+            locales.forEach((locale) => {
+                localeMap[locale.name] = locale.code;
+            });
+            const localeList = Object.keys(localeMap);
+            let inquirerConfig = {
+                type: 'search-list',
+                name: 'chosenLocale',
+                choices: localeList,
+                message: displayMessage || 'Choose locale',
+                loop: false,
+                validate: validations_1.shouldNotBeEmpty
+            };
+            inquirer.prompt(inquirerConfig).then(({ chosenLocale }) => {
+                let result = { code: localeMap[chosenLocale], name: chosenLocale };
+                resolve(result);
+            });
+        }
+        catch (error) {
+            console.error(error.message);
+        }
+    });
+}
+exports.chooseLocale = chooseLocale;
+function chooseTokenAlias() {
+    return new Promise(async (resolve, reject) => {
+        const tokens = config_handler_1.default.get('tokens');
+        const tokenList = Object.keys(tokens).filter((token) => tokens[token].type === 'management');
+        let inquirerConfig = {
+            type: 'search-list',
+            name: 'chosenToken',
+            choices: tokenList,
+            message: 'Choose an alias to use',
+            loop: false,
+            validate: validations_1.shouldNotBeEmpty,
+        };
+        inquirer.prompt(inquirerConfig).then(({ chosenToken }) => {
+            resolve({ apiKey: tokens[chosenToken].apiKey, token: tokens[chosenToken].token });
+        });
+    });
+}
+exports.chooseTokenAlias = chooseTokenAlias;
+function chooseDeliveryTokenAlias() {
+    return new Promise(async (resolve, reject) => {
+        const tokens = config_handler_1.default.get('tokens');
+        const tokenList = Object.keys(tokens).filter((token) => tokens[token].type === 'delivery');
+        let inquirerConfig = {
+            type: 'search-list',
+            name: 'chosenToken',
+            choices: tokenList,
+            message: 'Choose an alias to use',
+            loop: false,
+            validate: validations_1.shouldNotBeEmpty,
+        };
+        inquirer.prompt(inquirerConfig).then(({ chosenToken }) => {
+            resolve({ apiKey: tokens[chosenToken].apiKey, token: tokens[chosenToken].token });
+        });
+    });
+}
+exports.chooseDeliveryTokenAlias = chooseDeliveryTokenAlias;
+async function getAll(element, skip = 0) {
+    return new Promise(async (resolve) => {
+        let result = [];
+        result = await fetch(element, skip, result);
+        resolve(result);
+    });
+}
+async function fetch(element, skip, accumulator) {
+    return new Promise(async (resolve) => {
+        let queryParams = { include_count: true, skip: skip };
+        let { items: result, count: count } = await element.query(queryParams).find();
+        accumulator = accumulator.concat(result);
+        skip += result.length;
+        if (skip < count)
+            return resolve(await fetch(element, skip, accumulator));
+        return resolve(accumulator);
+    });
+}
+// async function callMe() {
+// 	// let organization = await chooseOrganization()
+// 	// console.log(organization)
+// 	// let stack = await chooseStack(organization.orgUid)
+// 	// console.log(stack)
+// 	// let contentType = await chooseContentType(stack.api_key)
+// 	// console.log(contentType)
+// 	// let entry = await chooseEntry(contentType.uid, stack.api_key)
+// 	// console.log(entry)
+// 	// let entry = await chooseEntry(contentType.uid, stack.api_key)
+// 	// console.log(entry)
+// 	let token = await chooseTokenAlias()
+// 	console.log(token)
+// }
+// callMe()

package/lib/selectors/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/selectors/validations.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNotBeEmpty = void 0;
+function shouldNotBeEmpty(input) {
+    if (input.length === 0)
+        throw new Error('Please enter a valid value');
+    return true;
+}
+exports.shouldNotBeEmpty = shouldNotBeEmpty;

package/messages/auth.json

@@ -0,0 +1,46 @@
+{
+  "CLI_AUTH_LOGIN_ENTER_EMAIL_ADDRESS": "Enter your email address",
+  "CLI_AUTH_LOGIN_ENTER_PASSWORD": "Enter your password",
+  "CLI_AUTH_LOGIN_SUCCESS": "Successfully logged in!!",
+  "CLI_AUTH_LOGIN_FAILED": "Login Error",
+  "CLI_AUTH_LOGIN_DESCRIPTION": "User session login",
+  "CLI_AUTH_LOGIN_FLAG_USERNAME": "User name",
+  "CLI_AUTH_LOGIN_FLAG_PASSWORD": "Password",
+  "CLI_AUTH_LOGIN_SECURITY_CODE_SEND_SUCCESS": "Security code sent to your mobile",
+  "CLI_AUTH_LOGIN_ASK_CHANNEL_FOR_SECURITY_CODE": "Two factor authentication enabled, please select a way to get the security code",
+  "CLI_AUTH_LOGIN_ENTER_SECURITY_CODE": "Please provide the security code",
+  "CLI_AUTH_LOGOUT_CONFIRM": "Are you sure you want to log out?",
+  "CLI_AUTH_LOGOUT_LOADER_START": "Logging out....",
+  "CLI_AUTH_LOGOUT_SUCCESS": "Successfully logged out",
+  "CLI_AUTH_LOGOUT_FAILED": "Error in logout, please login again",
+  "CLI_AUTH_LOGOUT_DESCRIPTION": "User session logout",
+  "CLI_AUTH_LOGOUT_FLAG_FORCE": "Force logging out for skipping the confirmation",
+  "CLI_AUTH_WHOAMI_LOGGED_IN_AS": "You are currently logged in with email",
+  "CLI_AUTH_WHOAMI_FAILED": "Failed to get the current user details",
+  "CLI_AUTH_WHOAMI_DESCRIPTION": "Display current users email address",
+  "CLI_AUTH_TOKENS_ADD_ASK_TOKEN_ALIAS": "Provide alias to store token",
+  "CLI_AUTH_TOKENS_ADD_CONFIRM_ALIAS_REPLACE": "Alias is already exists, do you want to replace?",
+  "CLI_AUTH_TOKENS_ADD_ENTER_API_KEY": "Enter the api key",
+  "CLI_AUTH_TOKENS_ADD_ENTER_TOKEN": "Enter the token",
+  "CLI_AUTH_TOKENS_ADD_ENTER_ENVIRONMENT": "Enter the environment name",
+  "CLI_AUTH_TOKENS_ADD_REPLACE_SUCCESS": "Successfully replaced the token",
+  "CLI_AUTH_TOKENS_ADD_SUCCESS": "Successfully added the token",
+  "CLI_AUTH_TOKENS_ADD_FAILED": "Failed to add the token",
+  "CLI_AUTH_TOKENS_ADD_DESCRIPTION": "Adds management/delivery tokens to your session to use it with further CLI command by default it adds management token if either of management or delivery flags are not set",
+  "CLI_AUTH_TOKENS_ADD_FLAG_DELIVERY_TOKEN": "Set this while saving delivery token",
+  "CLI_AUTH_TOKENS_ADD_FLAG_MANAGEMENT_TOKEN": "Set this while saving management token",
+  "CLI_AUTH_TOKENS_ADD_FLAG_ENVIRONMENT_NAME": "Environment name for delivery token",
+  "CLI_AUTH_TOKENS_REMOVE_SUCCESS": "Token removed successfully !!",
+  "CLI_AUTH_TOKENS_REMOVE_FAILED": "Failed to remove the selected token",
+  "CLI_AUTH_TOKENS_NOT_FOUND": "No tokens are added yet!",
+  "CLI_AUTH_TOKENS_REMOVE_SELECT_TOKEN": "Select tokens to remove",
+  "CLI_AUTH_TOKENS_REMOVE_DESCRIPTION": "Removes selected tokens",
+  "CLI_AUTH_TOKENS_LIST_NO_TOKENS": "No tokens are added. Use auth:tokens:add command to add tokens.",
+  "CLI_AUTH_TOKENS_LIST_FAILED": "Failed to list the tokens",
+  "CLI_AUTH_TOKENS_LIST_DESCRIPTION": "Lists all existing tokens added to the session",
+  "CLI_AUTH_TOKENS_VALIDATION_INVALID_DELIVERY_TOKEN": "Invalid delivery token",
+  "CLI_AUTH_TOKENS_VALIDATION_INVALID_ENVIRONMENT_NAME": "Invalid environment name",
+  "CLI_AUTH_TOKENS_VALIDATION_INVALID_MANAGEMENT_TOKEN": "Invalid management token",
+  "CLI_AUTH_TOKENS_VALIDATION_INVALID_API_KEY": "Invalid api key",
+  "CLI_AUTH_EXIT_PROCESS": "Exiting the process..."
+}

package/messages/config.json

@@ -0,0 +1,9 @@
+{
+    "CLI_CONFIG_SET_REGION_DESCRIPTION": "Set region for CLI",
+    "CLI_CONFIG_SET_REGION_FLAG_D_DESCRIPTION": "Custom host to set for content delivery API, if this flag is added then cma and name flags are required",
+    "CLI_CONFIG_SET_REGION_FLAG_M_DESCRIPTION": "Custom host to set for content management API, , if this flag is added then cda and name flags are required",
+    "CLI_CONFIG_SET_REGION_FLAG_N_DESCRIPTION": "Name for the region, if this flag is added then cda and cma flags are required",
+    "CLI_CONFIG_SET_REGION_DEFAULT": "No argument or custom flag provided. Setting region to default NA",
+    "CLI_CONFIG_GET_REGION_DESCRIPTION": "Get current region set for CLI",
+    "CLI_CONFIG_GET_REGION_NOT_FOUND": "No region found, please set by running command $ csdx config:set:region"
+}

package/messages/core.json

@@ -0,0 +1,6 @@
+{
+    "CLI_CORE_INVALID_CUSTOM_REGION": "Invalid custom region",
+    "CLI_CORE_LOGIN_AGAIN": "Please login to execute the command",
+    "CLI_CORE_NO_REGION_FOUND": "Please set the region",
+    "CLI_CORE_FAILED_UUID_GENERATION": "Failed to generate unique id"
+}