@zohocorporation/vault-cli 1.1.2

package/out/old/index.js

@@ -0,0 +1,580 @@
+import fs from "node:fs";
+import { Logger } from "../js/logger/index.js";
+import axios from "axios";
+import os from "os";
+import crypto from "crypto";
+import Table from "cli-table3";
+import convert from "xml-js";
+import { highlight } from "cli-highlight";
+import inquirer from "inquirer";
+import yamlConverter from "js-yaml";
+import { I18N } from "../js/I18n/index.js";
+import chalk from "chalk";
+import { CREDENTIALS } from "../util/consts.util.js";
+import { Utilities } from "../util/index.util.js";
+import { LoggerShutdown } from "../js/logger/index.js";
+// Accounts endpoints
+export const urlDeviceCode = "/oauth/v3/device/code", urlDeviceToken = "/oauth/v3/device/token", urlGenerateToken = "/oauth/v2/token";
+//Vault endpoints
+export const urlLogin = "/api/json/login", urlSearchSecrets = "/api/rest/json/v1/secrets/searchSecret", urlSecretTypes = "/api/rest/json/v1/secrettypes", urlOrgKey = "/api/rest/json/v1/user/orgkey", urlSecrets = "/api/rest/json/v1/secrets", urlV2Secrets = "/api/rest/json/v2/secrets", //No I18N
+urlPasswordPolicies = "/api/rest/json/v1/passwordPolicies", urlDownloadFile = "/api/rest/json/v1/secrets/downloadfile", urlOldSecrets = "/api/json/secrets", urlSettingsFori18N = "/api/rest/json/v1/settings", //No I18N
+urlFolder = "/api/rest/json/v1/chambers", //No I18N
+urlLicense = "/api/rest/json/v1/license"; //No I18N
+export const client_id = CREDENTIALS.CLIENT_ID, client_secret = CREDENTIALS.CLIENT_SECRET;
+export const masterKeyFName = "masterKey", credentialsFName = "credentials.json", configurationFName = "configuration.txt";
+export let OS = "linux";
+if (os.platform() === "win32") {
+    OS = "windows";
+}
+else if (os.platform() === "darwin") {
+    OS = "mac";
+}
+let headers = { "User-Agent": "CLI/1.1.1 (" + OS + ")", "cliaddonversion": "/1.1.1" }; //No I18N
+export const showError = (msg) => {
+    console.log(`error: ${msg}`);
+};
+export const validReadablePathCheck = (path) => {
+    path = path !== undefined && typeof path === "string" ? path.trim() : "";
+    if (path !== "") {
+        try {
+            fs.accessSync(path, fs.constants.R_OK);
+            return true;
+        }
+        catch (e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+};
+export const validPathCheck = (path) => {
+    path = path !== undefined && typeof path === "string" ? path.trim() : "";
+    if (path === "") {
+        return false;
+    }
+    try {
+        if (fs.lstatSync(path).isDirectory()) {
+            try {
+                fs.accessSync(path, fs.constants.W_OK);
+                return true;
+            }
+            catch (e) {
+                console.log(e);
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    catch (err) {
+        Logger.error(err);
+        return false;
+    }
+};
+const pattern = {
+    URL: /^(http(s?)|((s|t)?)ftp|ssh|file|telnet|nfs)\:\/\/[-.\w]*(\/?)([a-zA-Z0-9\-\.\?\,\:\;\'\/\\\+=&%\$#_@!|~]*)?$/,
+    secretName: /^[0-9a-zA-Z_\-\.\$@\?\,\:\'\/\!\P{InBasicLatin}\s]+$/,
+    XSS: /[<>"+&#%^*\/()\[\]|]/g,
+    cleartextpattern: /[<>"&#%^*\/()\[\]|\+\=]/g
+};
+const validateString = (regex, str) => {
+    let arrMatch = [];
+    let res;
+    while ((res = regex.exec(str))) {
+        let resStr = "" + res;
+        if (arrMatch.indexOf(resStr) === -1) {
+            arrMatch.push(resStr);
+        }
+    }
+    // For IE browser '<' char not showing, so fix added
+    for (let i = 0; i < arrMatch.length; i++) {
+        let resStr = "" + arrMatch[i];
+        if (resStr === "<") {
+            arrMatch[i] = "&lt;";
+        }
+        else if (resStr === "&") {
+            arrMatch[i] = "&amp;";
+        }
+    }
+    return arrMatch.join(",");
+};
+export const Utilites = {
+    getAccountsUrl: (dc) => {
+        return Utilities.getAccountsUrl(dc);
+    },
+    sleep: (millis) => {
+        return new Promise(resolve => setTimeout(resolve, millis));
+    },
+    getVaultUrl: (dc) => {
+        return Utilities.getVaultUrl(dc);
+    },
+    generateRandomToken: (n) => {
+        return crypto.randomBytes(n).toString("hex");
+    },
+    isTrusted: () => {
+        const prefix = ".";
+        const masterKey = fs.readFileSync(prefix + masterKeyFName, "utf-8");
+        if (masterKey === "" || masterKey.split(",").length !== 2) {
+            return { status: false };
+        }
+        else {
+            return { status: true, masterKey: masterKey.split(",")[0] };
+        }
+    },
+    writeToFile: (data, filename) => {
+        fs.writeFile(filename, data, (err) => {
+            if (err !== null) {
+                Logger.error(err);
+            }
+        });
+        //fs.createWriteStream(filename).write(data, 'base64')
+    },
+    groupBy: (objectArray, property) => {
+        return objectArray.reduce((acc, obj) => {
+            const key = obj[property];
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            // Add object to list for given key's value
+            acc[key].push(obj);
+            return acc;
+        }, {});
+    },
+    printTable: (arr) => {
+        let head = Object.keys(arr[0]);
+        let colWidths = [];
+        for (let i = 0; i < head.length; i++) {
+            colWidths.push(20);
+        }
+        let table = new Table({
+            head,
+            style: { "padding-left": 0, "padding-right": 0, head: ['blue', 'bold'], border: ['grey'] }, //No I18N
+            colWidths,
+            wordWrap: true,
+            wrapWords: true
+        });
+        for (let i = 0; i < arr.length; i++) {
+            table.push(Object.values(arr[i]));
+        }
+        console.log(table.toString());
+    },
+    printAsXML: (obj, outFile) => {
+        // Convert empty strings to empty text content to avoid self-closing tags
+        const processObj = (o) => {
+            if (typeof o === 'object' && o !== null) {
+                for (let key in o) {
+                    if (o[key] === '') {
+                        o[key] = { _text: '' };
+                    }
+                    else if (typeof o[key] === 'object' && o[key] !== null) {
+                        processObj(o[key]);
+                    }
+                }
+            }
+            return o;
+        };
+        const processedObj = processObj(JSON.parse(JSON.stringify(obj)));
+        const options = { compact: true, ignoreComment: true, spaces: 4, textKey: '_text' }; //No I18N
+        const xmlOutput = convert.json2xml(processedObj, options);
+        if (outFile !== undefined) {
+            Utilites.writeToFile(xmlOutput, outFile);
+            console.log(chalk.green("File created and stored in location: " + outFile));
+        }
+        else {
+            console.log(highlight(xmlOutput, {
+                language: "xml",
+                ignoreIllegals: true
+            }));
+        }
+    },
+    printAsYML: (obj, outFile) => {
+        const yamlOutput = yamlConverter.dump(obj);
+        if (outFile !== undefined) {
+            Utilites.writeToFile(yamlOutput, outFile);
+            console.log(chalk.green("File created and stored in location: " + outFile));
+        }
+        else {
+            console.log(highlight(yamlOutput, {
+                language: "yaml",
+                ignoreIllegals: true
+            }));
+        }
+    },
+    printAsJSON: (obj, outFile) => {
+        if (outFile !== undefined) {
+            Utilites.writeToFile(JSON.stringify(obj), outFile);
+            console.log(chalk.green("File created and stored in location: " + outFile));
+        }
+        else {
+            console.log(highlight(JSON.stringify(obj, null, 4), {
+                language: "json",
+                ignoreIllegals: true
+            }));
+        }
+    },
+    getSharingPrivilege: (level) => {
+        if (level === 10) {
+            return "MANAGE";
+        }
+        else if (level === 20) {
+            return "AUTOLOGIN";
+        }
+        else if (level === 30) {
+            return "VIEW";
+        }
+        else {
+            return "MODIFY";
+        }
+    },
+    isConfigured: () => {
+        try {
+            if (fs.existsSync(configurationFName) && fs.existsSync('.' + masterKeyFName)) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (e) {
+            Logger.info("Problem while configuring");
+        }
+    },
+    XSSValidatorWithMand: (text) => {
+        let i18nText = new I18N();
+        text = text.trim();
+        if (text === undefined || text === "") {
+            return i18nText.getI18nMsg("vault.XSSValidatorWithMand.emptyField");
+        }
+        const failedChar = validateString(pattern.XSS, text);
+        if (failedChar !== "") {
+            return i18nText.getI18nMsg("vault.XSSValidatorWithMand.invalidChar") + `${new Array([failedChar]).join(" ")}`;
+        }
+        return true;
+    },
+    XSSValidator: (text) => {
+        let i18nText = new I18N();
+        text = text.trim();
+        if (text === "") {
+            return true;
+        }
+        const failedChar = validateString(pattern.XSS, text);
+        if (failedChar !== "") {
+            return i18nText.getI18nMsg("vault.XSSValidator.invalidChar") + `${new Array([failedChar]).join(" ")}`;
+        }
+        return true;
+    },
+    URLValidator: (url) => {
+        let i18nText = new I18N();
+        url = url.trim();
+        if (url !== "" && !pattern.URL.test(url)) {
+            return i18nText.getI18nMsg("vault.URLValidator.URL_invalid");
+        }
+        return true;
+    },
+    trimText: (text) => {
+        return text.trim();
+    },
+    FileValidator: (path) => {
+        let i18nText = new I18N();
+        path = path.trim();
+        if (path !== "") {
+            try {
+                fs.accessSync(path, fs.constants.R_OK);
+                if (fs.statSync(path).size > 2000000) {
+                    return "File size must be less than 2MB";
+                }
+                return true;
+            }
+            catch (e) {
+                Logger.log(e);
+                return i18nText.getI18nMsg("vault.FileValidator.filePath_invalid");
+            }
+        }
+        return true;
+    },
+    mandFileValidator: (path) => {
+        let i18nText = new I18N();
+        path = path.trim();
+        if (path !== "") {
+            try {
+                fs.accessSync(path, fs.constants.R_OK);
+                return true;
+            }
+            catch (e) {
+                Logger.error(e);
+                return i18nText.getI18nMsg("vault.mandFileValidator.filePath_invalid");
+            }
+        }
+        else {
+            return i18nText.getI18nMsg("vault.mandFileValidator.emptyField");
+        }
+    },
+    mandValidator: (text) => {
+        let i18nText = new I18N();
+        text = text.trim();
+        if (text === "") {
+            return i18nText.getI18nMsg("vault.mandValidator.emptyField");
+        }
+        return true;
+    },
+    passwordMandValidator: (pass) => {
+        let i18nText = new I18N();
+        if (pass === "") {
+            return i18nText.getI18nMsg("vault.passwordMandValidator.emptyField");
+        }
+        return true;
+    },
+    selectionPrompt: async (start, end, message) => {
+        let i18nText = new I18N();
+        const ans = await inquirer.prompt({
+            type: "input",
+            name: "sno",
+            message: message,
+            validate: (val) => {
+                if (val >= start && val <= end) {
+                    return true;
+                }
+                return (i18nText.getI18nMsg("vault.selectionPrompt.end_invalid")) + end.toString(); //No I18N
+            }
+        });
+        return ans.sno;
+    },
+    convertFromYAML: (yamlString) => {
+        return yamlConverter.load(yamlString);
+    },
+    convertFromXML: (xmlString) => {
+        return convert.xml2js(xmlString, { compact: true, spaces: 4 });
+    },
+    bytesToHex: (bytes) => {
+        return Array.from(new Uint8Array(bytes), Utilites.getHex, this).join("");
+        //return Array.from(bytes).map(x => Utilites.getHex(x)).join("");
+    },
+    getHex(byte) {
+        return ("0" + (byte).toString(16)).slice(-2);
+    },
+    async importPrivateKey(key) {
+        const encodingUtil = new JsEncodingUtilImpl();
+        const keyBuffer = encodingUtil.base64ToBytes(key);
+        const RSA_PARAMS = {
+            name: "RSA-OAEP", //No I18N
+            hash: "SHA-256" //No I18N
+        };
+        const privateKey = await crypto.webcrypto.subtle.importKey("pkcs8", keyBuffer, RSA_PARAMS, true, ["decrypt"]); //No I18N
+        return privateKey;
+    }
+};
+let JsEncodingFormat;
+(function (JsEncodingFormat) {
+    JsEncodingFormat["HEX"] = "HEX"; //No I18N
+    JsEncodingFormat["BASE64"] = "BASE64"; //No I18N
+    JsEncodingFormat["BASE64_URL"] = "BASE64_URL"; //No I18N
+    JsEncodingFormat["BYTES"] = "BYTES"; //No I18N
+    JsEncodingFormat["ASCII"] = "ASCII"; //No I18N
+})(JsEncodingFormat || (JsEncodingFormat = {}));
+class JsEncodingXToByteUtil {
+    textEncoder = new TextEncoder();
+    getBytes(input) {
+        try {
+            if (input.inputBytes) {
+                if (input.inputBytes instanceof ArrayBuffer) {
+                    return new Uint8Array(input.inputBytes);
+                }
+                return input.inputBytes;
+            }
+            switch (input.from) {
+                case JsEncodingFormat.ASCII:
+                    return this.textEncoder.encode(input.inputString);
+                case JsEncodingFormat.BASE64:
+                    return base64Util.decodeStringToBytes(input.inputString);
+                case JsEncodingFormat.HEX:
+                    return gg.hexUtil.decodeHexStringToBytes(input.inputString);
+                default:
+                    throw ["NEW_CASE", input];
+            }
+        }
+        catch (e) {
+            logError(e, input);
+            throw e;
+        }
+    }
+}
+class Base64Util {
+    alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; //No I18N
+    base64AlphaValueMap = null;
+    encodeBytesToString(bytes) {
+        let i = 0;
+        let ans = "";
+        for (; i + 2 < bytes.length; i += 3) {
+            ans += this.mapBase64C1(bytes[i]);
+            ans += this.mapBase64C2(bytes[i], bytes[i + 1]);
+            ans += this.mapBase64C3(bytes[i + 1], bytes[i + 2]);
+            ans += this.mapBase64C4(bytes[i + 2]);
+        }
+        switch (bytes.length - i) {
+            case 2:
+                ans += this.mapBase64C1(bytes[i]);
+                ans += this.mapBase64C2(bytes[i], bytes[i + 1]);
+                ans += this.mapBase64C3(bytes[i + 1], 0);
+                ans += "=";
+                break;
+            case 1:
+                ans += this.mapBase64C1(bytes[i]);
+                ans += this.mapBase64C2(bytes[i], 0);
+                ans += "==";
+                break;
+        }
+        return ans;
+    }
+    decodeStringToBytes(input) {
+        const alphaValue = this.getBase64AlphaValueMap();
+        const bytes = [];
+        while (input.length % 4 != 0) {
+            input += "=";
+        }
+        let c1 = 0, c2 = 0, c3 = 0, c4 = 0;
+        for (let i = 0; i < input.length; i += 4) {
+            c1 = alphaValue.get(input[i]);
+            c2 = alphaValue.get(input[i + 1]);
+            c3 = alphaValue.get(input[i + 2]);
+            c4 = alphaValue.get(input[i + 3]);
+            bytes.push((c1 << 2) | ((c2 & 48) >> 4));
+            bytes.push(((c2 & 15) << 4) | ((c3 & 60) >> 2));
+            bytes.push(((c3 & 3) << 6) | c4);
+        }
+        for (let i = input.length - 1; i >= 0 && input[i] == "="; i--) {
+            bytes.pop();
+        }
+        return new Uint8Array(bytes);
+    }
+    mapBase64C1(byte) {
+        return this.alphabet[(byte & 252) >> 2];
+    }
+    mapBase64C2(b1, b2) {
+        return this.alphabet[((b1 & 3) << 4) | ((b2 & 240) >> 4)];
+    }
+    mapBase64C3(b1, b2) {
+        return this.alphabet[((b1 & 15) << 2) | ((b2 & 192) >> 6)];
+    }
+    mapBase64C4(byte) {
+        return this.alphabet[byte & 63];
+    }
+    getBase64AlphaValueMap() {
+        if (this.base64AlphaValueMap == null) {
+            const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; //No I18N
+            const map = new Map(Array.from(alphabet, (x, index) => [x, index]));
+            map.set("=", 0);
+            this.base64AlphaValueMap = map;
+        }
+        return this.base64AlphaValueMap;
+    }
+}
+const base64Util = new Base64Util();
+class JsEncodingByteToXUtil {
+    textDecoder = new TextDecoder();
+    convertBytes(bytes, input) {
+        try {
+            switch (input.to) {
+                case JsEncodingFormat.BYTES:
+                    return { outputBytes: bytes };
+                case JsEncodingFormat.BASE64:
+                    return { outputString: base64Util.encodeBytesToString(bytes) };
+                case JsEncodingFormat.ASCII:
+                    return { outputString: this.textDecoder.decode(bytes) };
+                case JsEncodingFormat.BASE64_URL:
+                    return { outputString: this.getBase64Url(base64Util.encodeBytesToString(bytes)) };
+                default:
+                    throw ["NEW_CASE", input];
+            }
+        }
+        catch (e) {
+            logError(e, bytes, input);
+            throw e;
+        }
+    }
+    getBase64Url(text) {
+        return text.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    }
+}
+export class JsEncodingUtilImpl {
+    xToByteUtil = new JsEncodingXToByteUtil();
+    byteToXUtil = new JsEncodingByteToXUtil();
+    convert(input) {
+        try {
+            const bytes = this.xToByteUtil.getBytes(input);
+            return this.byteToXUtil.convertBytes(bytes, input);
+        }
+        catch (e) {
+            throw ["FAILED_TO_ENCODE", input, e];
+        }
+    }
+    bytesToBase64(input) {
+        return this.convert({ from: JsEncodingFormat.BYTES, to: JsEncodingFormat.BASE64, inputBytes: input }).outputString;
+    }
+    bytesToBase64Url(input) {
+        return this.convert({ from: JsEncodingFormat.BYTES, to: JsEncodingFormat.BASE64_URL, inputBytes: input }).outputString;
+    }
+    base64ToBytes(input) {
+        return this.convert({ from: JsEncodingFormat.BASE64, to: JsEncodingFormat.BYTES, inputString: input }).outputBytes;
+    }
+}
+export const setHeaders = (key, val) => {
+    headers[key] = val;
+};
+export const _pull = (URL, data, method) => {
+    const params = new URLSearchParams();
+    let i18nText = new I18N();
+    for (const key in data) {
+        params.append(key, data[key]);
+    }
+    switch (method) {
+        case "POST":
+            return axios.post(URL, params, { headers })
+                .catch(function (e) {
+                Logger.error(e);
+                LoggerShutdown(() => {
+                    if (e.code === 'ENOTFOUND') {
+                        console.log(i18nText.getI18nMsg("vault.error.checkConnectivity"));
+                    }
+                    else {
+                        console.log(i18nText.getI18nMsg("vault.server.errorReaching"));
+                    }
+                    process.exit(1);
+                });
+                throw e;
+            });
+        case "PUT":
+            return axios.put(URL, params, { headers })
+                .catch(function (e) {
+                Logger.error(e);
+                LoggerShutdown(() => {
+                    if (e.code === 'ENOTFOUND') {
+                        console.log(i18nText.getI18nMsg("vault.error.checkConnectivity"));
+                    }
+                    else {
+                        console.log(i18nText.getI18nMsg("vault.server.errorReaching"));
+                    }
+                    process.exit(1);
+                });
+                throw e;
+            });
+        default:
+            return axios.get(URL, { headers, params: params })
+                .catch(function (e) {
+                Logger.error(e);
+                LoggerShutdown(() => {
+                    if (e.code === 'ENOTFOUND') {
+                        console.log(i18nText.getI18nMsg("vault.error.checkConnectivity"));
+                    }
+                    else {
+                        console.log(i18nText.getI18nMsg("vault.server.errorReaching"));
+                    }
+                    process.exit(1);
+                });
+                throw e;
+            });
+    }
+};
+//# sourceMappingURL=index.js.map

package/out/util/configuration.util.js

@@ -0,0 +1,103 @@
+import { Login } from "./login.util.js";
+import { MODE } from "./consts.util.js";
+import { ACCOUNT_ENDPOINTS, CREDENTIALS, VAULT_ENDPOINTS } from "./consts.util.js";
+import { writeFileSync } from "fs";
+import { _pull } from "./index.util.js";
+import { generateWorkspaceHash, header } from "../commands/login/login.utils.js";
+import { Utilities } from "./index.util.js";
+import { getDecryptedCredentials } from "./dbutils/db.utils.js";
+import { getConfig } from "./dev.utils.js";
+import { insertToDB } from "./dbutils/db.utils.js";
+export class Configuration extends Login {
+    constructor(dc) {
+        super(undefined, dc);
+    }
+    setDc(dc) {
+        super.setDC(dc);
+    }
+    setPassPhrase(passphrase) {
+        super.setPassPhrase(passphrase);
+    }
+    // async getConfigFromFile() {
+    // 	const credentialsPath = readFileSync(AME.CONFIGURATION_FILE_NAME, "utf-8");
+    // 	const credentials = JSON.parse(readFileSync(credentialsPath, "utf-8"));
+    // 	this.setDC(credentials.dc);
+    // }
+    generateLinkForDeviceCode() {
+        const scope = "ZohoVault.user.READ,ZohoVault.user.UPDATE,ZohoVault.user.CREATE,ZohoVault.user.DELETE,ZohoVault.secrets.READ,ZohoVault.secrets.UPDATE,ZohoVault.secrets.CREATE,ZohoVault.secrets.DELETE ", //No I18N
+        grant_type = "device_request", //No I18N
+        access_type = "offline"; //No I18N
+        const data = getConfig();
+        let { MODE: mode, CLIENT_ID } = data;
+        if (mode === MODE.PRODUCTION) {
+            CLIENT_ID = CREDENTIALS.CLIENT_ID;
+        }
+        return _pull(header, Utilities.getAccountsUrl(this.getDC()) + ACCOUNT_ENDPOINTS.URL_DEVICE_CODE, { scope, client_id: CLIENT_ID, grant_type, access_type }, "POST" //No I18N
+        );
+    }
+    generateRefreshToken(code) {
+        const grant_type = "device_token"; //No I18N
+        const data = getConfig();
+        let { MODE: mode, CLIENT_ID, CLIENT_SECRET } = data;
+        if (mode === MODE.PRODUCTION) {
+            CLIENT_ID = CREDENTIALS.CLIENT_ID;
+            CLIENT_SECRET = CREDENTIALS.CLIENT_SECRET;
+        }
+        return _pull(header, Utilities.getAccountsUrl(this.getDC()) + ACCOUNT_ENDPOINTS.URL_DEVICE_TOKEN, { code, client_id: CLIENT_ID, grant_type, client_secret: CLIENT_SECRET }, "POST" //No I18N
+        );
+    }
+    getUserLanguage() {
+        return _pull(header, Utilities.getVaultUrl(this.getDC()) + VAULT_ENDPOINTS.URL_SETTINGS_FOR_I18N, undefined, undefined);
+    }
+    writeToFile(data, filename) {
+        writeFileSync(filename, data);
+    }
+    // createMasterKeyFile(passphrase: string, masterKey: string, trust: boolean) {
+    //   this.setPassPhrase(passphrase);
+    //   let tokenKey = this.getKeyForToken();
+    //   if (trust) {
+    //     this.writeToFile(masterKey + "," + tokenKey, '.' + NAME.MASTER_KEY);
+    //   } else {
+    //     this.writeToFile(tokenKey, '.' + NAME.MASTER_KEY);
+    //   }
+    // }
+    insertToDB(data) {
+        insertToDB(data);
+    }
+    insertMasterKeyToDB(passphrase, masterKey, trust, zuid) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (!masterKey) {
+                    return;
+                }
+                this.setPassPhrase(passphrase);
+                let tokenKey = await this.getKeyForToken();
+                const data = await getDecryptedCredentials(generateWorkspaceHash());
+                if (!data) {
+                    return;
+                }
+                const { credentials } = data;
+                if (trust) {
+                    credentials.masterkey = masterKey + "," + tokenKey;
+                    data.hasmasterkey = true;
+                }
+                else {
+                    credentials.masterkey = tokenKey;
+                }
+                credentials.orgkey = '';
+                if (zuid) {
+                    data.zuid = zuid;
+                }
+                this.insertToDB(data);
+                resolve(true);
+            }
+            catch (err) {
+                reject(new Error("Error while inserting master key"));
+            }
+        });
+    }
+    async hasValidLicense() {
+        return _pull(header, Utilities.getVaultUrl(this.getDC()) + VAULT_ENDPOINTS.URL_LICENSE, undefined, undefined);
+    }
+}
+//# sourceMappingURL=configuration.util.js.map