@zohocorporation/vault-cli 1.1.2

package/out/commands/login/login.utils.js

@@ -0,0 +1,307 @@
+import { Logger } from "../../js/logger/index.js";
+import { accessSync, constants } from "node:fs";
+import { lstatSync } from "node:fs";
+import { getOS } from "../../util/index.util.js";
+import { Configuration } from "../../util/configuration.util.js";
+import { LoginOpts } from "./login.types.js";
+import chalk from "chalk";
+import { Utilities } from "../../util/index.util.js";
+import { spawn } from "child_process";
+import Vault from "../../js/crypto/index.js";
+import { encryptString } from "../../util/encryptionutil/encryption.uitl.js";
+import { insertToTable, getZvDB } from "../../util/dbutils/db.utils.js";
+import { DC, OS } from "../../util/consts.util.js";
+import { TransferLoader } from "../../util/loader/transfer.loader.js";
+import { select } from "@inquirer/prompts";
+import { API_DOMAIN_TO_DC } from "./login.const.js";
+export const header = {
+    "User-Agent": "CLI/1.0.1 (" + getOS() + ")" //No I18N
+};
+export const setHeaders = (key, value) => {
+    header[key] = value;
+};
+export const isValidDC = (dc) => {
+    if (typeof dc !== "string") {
+        return false;
+    }
+    return ["us", "eu", "au", "in", 'com.cn'].includes(dc);
+};
+export const accessFolder = (path) => {
+    try {
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+};
+export const isValidPath = async (path) => {
+    return new Promise((resolve, _) => {
+        path = typeof path === "string" ? path.trim() : "";
+        if (typeof path !== "string" || path === "") {
+            resolve(false);
+        }
+        const isDirectory = lstatSync(path).isDirectory();
+        if (!isDirectory) {
+            Logger.error("Not a valid directory");
+            resolve(false);
+        }
+        resolve(accessFolder(path));
+    });
+};
+export const checkValidDC = (dc) => {
+    return new Promise((resolve, reject) => {
+        if (isValidDC(dc)) {
+            resolve(true);
+        }
+        else {
+            reject(false);
+            console.log("Invalid DC value entered. The following are the valid list of DCs: US | EU | IN | AU | COM.CN");
+            process.exit(0);
+        }
+    });
+};
+export const checkConfigPath = (path) => {
+    return new Promise(async (resolve, reject) => {
+        const isValid = await isValidPath(path);
+        if (path !== undefined && !isValid) {
+            reject(new Error("Invalid ConfigPath entered. Please specify a valid path and try again.")); //No I18N
+        }
+        resolve(isValid);
+    });
+};
+export const getDeviceCodeAndLink = (configObj) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const response = await configObj.generateLinkForDeviceCode();
+            if ((response).hasOwnProperty("error")) {
+                reject(response.error);
+            }
+            const { data: { device_code, verification_uri_complete } } = response;
+            resolve({ device_code, verification_uri_complete });
+        }
+        catch (error) {
+            reject(new Error("Cannot generate device code and link"));
+        }
+    });
+};
+export const openUrl = (url) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const platform = getOS();
+            if (platform == OS.WINDOWS) {
+                spawn('cmd', ['/c', 'start', url], { stdio: 'ignore', detached: true });
+                resolve(true);
+                return;
+            }
+            spawn('open', [url]);
+            resolve(true);
+            return;
+        }
+        catch (err) {
+        }
+        resolve(false);
+    });
+};
+export const promptUserWithRetry = async (url) => {
+    const answer = await select({
+        message: `open ${url} in default browser?`,
+        choices: [
+            { name: 'Yes', value: true },
+            { name: 'No', value: false }
+        ],
+        default: true,
+    });
+    if (answer) {
+        await openUrl(url);
+        return undefined;
+    }
+    console.log("Copy and paste the URL displayed below in your browser address bar and hit Enter. You will be prompted to log in to your Zoho account if you haven't already. Grant the necessary permissions to access Vault: "); //No I18N
+    console.log(chalk.greenBright.bold.underline(url));
+    console.log("\n");
+    return undefined;
+};
+// export const promptUserToGiveConsent = async (url: string): Promise<undefined> => {
+//     return new Promise((resolve, reject) => {
+//         confirm(
+//             {
+//                 message: `open ${url} in default browser`,
+//                 default: true,
+//             }
+//         ).then(async (answer) => {
+//             if (answer) {
+//                 const res = await openUrl(url);
+//                 if (res) {
+//                     resolve(undefined);
+//                     return;
+//                 }
+//             }
+//             console.log("Copy and paste the URL displayed below in your browser address bar and hit Enter. You will be prompted to log in to your Zoho account if you haven't already. Grant the necessary permissions to access Vault: "); //No I18N
+//             console.log(chalk.greenBright.bold.underline(url));
+//             console.log("\n");
+//             resolve(undefined);
+//         })
+//             .catch((error) => {
+//                 reject(undefined);
+//             })
+//     })
+// }
+export const authenticateUser = (deviceCode, configObj) => {
+    console.log("Please wait once granted necessary permission. Authenticating your Zoho account");
+    return new Promise(async (resolve, reject) => {
+        try {
+            let refreshTokenResp = await configObj.generateRefreshToken(deviceCode);
+            const { data } = refreshTokenResp;
+            if (data.hasOwnProperty("error") && data.error === 'other_dc') {
+                const dc = data.user_location;
+                configObj.setDC(dc);
+                refreshTokenResp = await configObj.generateRefreshToken(deviceCode);
+            }
+            resolve(data);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(new Error("Unable to process your request. Please try again later"));
+        }
+    });
+};
+export const resolvePendingRequest = (data, configObj, deviceCode) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            let time = 1000;
+            while (data.hasOwnProperty("error") && (data.error !== 'access_denied')) { //No I18N
+                await Utilities.sleep(time);
+                let refreshTokenResp = await configObj.generateRefreshToken(deviceCode);
+                data = refreshTokenResp.data;
+                if (data.hasOwnProperty('error') && data.error === 'other_dc') {
+                    let dc = data.user_location;
+                    configObj.setDc(dc);
+                    refreshTokenResp = await configObj.generateRefreshToken(deviceCode);
+                    data = refreshTokenResp.data;
+                }
+                else if (data.hasOwnProperty('error') && data.error === 'slow_down') {
+                    time = time + 200;
+                }
+                if (data.hasOwnProperty("error") && data.error === 'access_denied') {
+                    reject(new Error("Device Request Access Denied, terminating the authentication process"));
+                }
+            }
+            resolve(data);
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+};
+export const getLanguage = (status, data) => {
+    if (status === "Success") {
+        const { operation } = data;
+        const { Details: { language } } = operation;
+        return language;
+    }
+    return "en";
+};
+export const getUserLanguage = (configObj, accessToken) => {
+    setHeaders("Authorization", `Zoho-oauthtoken ${accessToken}`);
+    return new Promise(async (resolve, reject) => {
+        try {
+            let resp = await configObj.getUserLanguage();
+            const { data } = resp;
+            const { operation: { result: { status } } } = data;
+            resolve(getLanguage(status, data));
+        }
+        catch (err) {
+            reject(new Error("Problem fetching your preferred language. Please try again."));
+        }
+    });
+};
+export const createConfigObject = (refresh_token, access_token, masterkey) => {
+    const configObj = { refresh_token, access_token, masterkey };
+    return JSON.stringify(configObj);
+};
+export const isValidString = (str) => {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    if (str.trim() !== '') {
+        return true;
+    }
+    return false;
+};
+export const createEncryptedConfigurationObject = async (refresh_token, access_token, lang, date, dc, masterKey, zuid) => {
+    const credentials = await encryptString(createConfigObject(refresh_token, access_token, masterKey));
+    const language = await encryptString(lang);
+    const createdtime = await encryptString(date.toString());
+    const workspace = generateWorkspaceHash();
+    const dcEnc = await encryptString(dc);
+    const hasmasterkey = false.toString();
+    const defaults = await encryptString(Vault.Base64_encode('{}'));
+    let encZuid = await encryptString(zuid);
+    return { workspace, credentials, language, createdtime, dc: dcEnc, hasmasterkey, defaults, zuid: encZuid };
+};
+export const resolveDC = (api_domain) => {
+    return API_DOMAIN_TO_DC[api_domain] ?? DC.US;
+};
+export const getUserConsentAndCreateConfig = (dc) => {
+    return new Promise(async (resolve, reject) => {
+        let loader = new TransferLoader();
+        try {
+            const configObj = new Configuration(dc);
+            const res = await getDeviceCodeAndLink(configObj);
+            const { device_code, verification_uri_complete } = res;
+            await promptUserWithRetry(verification_uri_complete);
+            loader.load();
+            let respData = await authenticateUser(device_code, configObj);
+            respData = await resolvePendingRequest(respData, configObj, device_code);
+            const { access_token, refresh_token, api_domain } = respData;
+            // Resolve the user's actual DC from the api_domain in the token response
+            const resolvedDc = api_domain ? resolveDC(api_domain) : dc;
+            if (resolvedDc !== dc) {
+                loader.stop();
+                console.log(chalk.yellowBright(`Your account belongs to the ${resolvedDc.toUpperCase()} datacenter, but you logged in to the ${dc.toUpperCase()} datacenter.`));
+                console.log(chalk.yellowBright(`Please login again with: zv login --dc ${resolvedDc}`));
+                reject(new Error(`DC mismatch: expected ${dc}, got ${resolvedDc}. Please login with --dc ${resolvedDc}`));
+                return;
+            }
+            const language = await getUserLanguage(configObj, access_token);
+            const credentials = await createEncryptedConfigurationObject(refresh_token, access_token, language, Date.now(), resolvedDc, '', '');
+            const db = getZvDB();
+            insertToTable(db, credentials);
+            loader.stop();
+            console.log("You are now logged in to your Zoho account");
+            resolve(true);
+        }
+        catch (error) {
+            loader.stop();
+            reject(error);
+        }
+    });
+};
+export const generateWorkspaceHash = () => {
+    const path = process.cwd();
+    return Vault.hash(path);
+};
+export const getKey = (key) => {
+    switch (key) {
+        case LoginOpts.DC:
+            return "dc";
+        default:
+            return "";
+    }
+};
+export const constructDefaultOpts = (opts) => {
+    if (!('login' in opts)) {
+        return {};
+    }
+    const res = {};
+    const { login } = opts;
+    for (const key in login) {
+        const tkey = key;
+        const mkey = getKey(tkey);
+        if (login.hasOwnProperty(key)) {
+            res[mkey] = login[tkey];
+        }
+    }
+    return res;
+};
+//# sourceMappingURL=login.utils.js.map

package/out/commands/reset/reset.action.js

@@ -0,0 +1,28 @@
+import { reset } from "../../util/dbutils/db.utils.js";
+import { select } from "@inquirer/prompts";
+import { deleteFromKeyring } from "../../util/keyringutil/keyring.util.js";
+import { KEYRING_ACCOUNT, KEYRING_SERVICE } from "../../util/consts.util.js";
+export const resetAction = () => {
+    select({
+        message: "Confirm reset: ",
+        choices: [
+            { name: 'Yes', value: true },
+            { name: 'No', value: false }
+        ],
+        default: true
+    }).then(async (answer) => {
+        try {
+            await deleteFromKeyring(KEYRING_SERVICE, KEYRING_ACCOUNT);
+        }
+        catch (_) {
+            // Keyring entry may not exist — safe to ignore
+        }
+        if (answer) {
+            await reset();
+            console.log("All Zoho Vault accounts Logged out successfully.");
+        }
+    }).catch(() => {
+        console.log("Operation terminated unexpectedly");
+    });
+};
+//# sourceMappingURL=reset.action.js.map

package/out/commands/reset/reset.help.js

@@ -0,0 +1,8 @@
+const resetHelp = () => {
+    console.log(`
+        Example: 
+        zv reset
+    `);
+};
+export default resetHelp;
+//# sourceMappingURL=reset.help.js.map

package/out/commands/reset/reset.js

@@ -0,0 +1,14 @@
+import { resetAction } from "./reset.action.js";
+import resetHelp from "./reset.help.js";
+export const reset = (program) => {
+    program
+        .command("reset")
+        .description("Logs out all Zoho Vault accounts") //No I18N
+        .on('--help', () => {
+        resetHelp();
+    })
+        .action(() => {
+        resetAction();
+    });
+};
+//# sourceMappingURL=reset.js.map

package/out/commands/reset/reset.utils.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reset.utils.js.map

package/out/commands/search/search.action.js

@@ -0,0 +1,30 @@
+import { showError } from "../../util/print.util.js";
+import { Search } from "../../util/search.util.js";
+import { checkConfigurationAndMasterKey } from "./search.utils.js";
+import { getDecryptedCredentials } from "../../util/dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../login/login.utils.js";
+import { Default } from "../../old/Default.js";
+import { constructDefaultOpts } from "./search.utils.js";
+export const searchAction = async (option) => {
+    try {
+        const { useDefault } = option;
+        if (useDefault) {
+            const def = new Default(undefined, undefined);
+            const options = await def.getDefaults();
+            const defaultOpts = constructDefaultOpts(options);
+            option = { ...option, ...defaultOpts };
+        }
+        const { key, strict, tags, desc, name, verbose, output, outFile, notSafe } = option;
+        await checkConfigurationAndMasterKey();
+        const configData = await getDecryptedCredentials(generateWorkspaceHash());
+        const { dc } = configData;
+        const searchObj = new Search(key, strict, tags, desc, name, verbose, output, outFile, notSafe, undefined, dc);
+        await searchObj.getSecrets();
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            showError(err.message);
+        }
+    }
+};
+//# sourceMappingURL=search.action.js.map

package/out/commands/search/search.constants.js

@@ -0,0 +1,14 @@
+export var SEARCH;
+(function (SEARCH) {
+    SEARCH["TAGS"] = "tags";
+    SEARCH["DESCRIPTION"] = "description";
+    SEARCH["SECRETNAME"] = "secretname";
+})(SEARCH || (SEARCH = {}));
+export var OUTPUT;
+(function (OUTPUT) {
+    OUTPUT["XML"] = "xml";
+    OUTPUT["YAML"] = "yaml";
+    OUTPUT["JSON"] = "json";
+    OUTPUT["YML"] = "yml";
+})(OUTPUT || (OUTPUT = {}));
+//# sourceMappingURL=search.constants.js.map

package/out/commands/search/search.help.js

@@ -0,0 +1,6 @@
+export const searchHelp = (i18nText) => {
+    console.log(`
+\nExample :\n  zv search -k mail\n  zv search -k "win" \n  zv search -k "win" --name \n  zv search -k "gmail test" --strict\n  zv search -k "win" --name -V\n  zv search -k "win" --name -V --not-safe\n  zv search -k "win" --name -V --output xml\n  zv search -k "win" --name -V --output xml -w output.xml\n` //No I18N
+        + i18nText.getI18nMsg("vault.search.example_note"));
+};
+//# sourceMappingURL=search.help.js.map

package/out/commands/search/search.js

@@ -0,0 +1,26 @@
+import { searchAction } from "./search.action.js";
+import { I18N } from "../../js/I18n/index.js";
+import { searchHelp } from "./search.help.js";
+export const search = (program) => {
+    const i18nText = new I18N();
+    program
+        .command("search")
+        .description(i18nText.getI18nMsg("vault.search.desc"))
+        .option("-k, --key <key>", i18nText.getI18nMsg("vault.search.option_key"), "")
+        .option("-s, --strict", i18nText.getI18nMsg("vault.search.option_strict"), false)
+        // .option("-t, --tags", i18nText.getI18nMsg("vault.search.option_tags"), false)
+        // .option("-d, --desc", i18nText.getI18nMsg("vault.search.option_includeDesc"), false)
+        .option("-n, --name", i18nText.getI18nMsg("vault.search.option_includeName"), false)
+        .option("-V, --verbose", i18nText.getI18nMsg("vault.search.option_verbose"), false)
+        .option("-show --not-safe", i18nText.getI18nMsg("vault.search.option_notSafe"), false)
+        .option("-w, --out-file [path]", i18nText.getI18nMsg("vault.search.option_outFile"))
+        .option("--use-default", "uses default options for search", false)
+        .option("-o , --output [type]", i18nText.getI18nMsg("vault.search.option_output"), "table") //TODO get the default value from some config file
+        .on("--help", () => {
+        searchHelp(i18nText);
+    })
+        .action((option) => {
+        searchAction(option);
+    });
+};
+//# sourceMappingURL=search.js.map

package/out/commands/search/search.types.js

@@ -0,0 +1,16 @@
+import { I18N } from "../../js/I18n/index.js";
+const i18N = new I18N();
+export var SearchOpts;
+(function (SearchOpts) {
+    SearchOpts["KEY"] = "--key";
+    SearchOpts["STRICT"] = "--strict";
+    SearchOpts["TAGS"] = "--tags";
+    SearchOpts["DESC"] = "--desc";
+    SearchOpts["NAME"] = "--name";
+    SearchOpts["VERBOSE"] = "--verbose";
+    SearchOpts["NOTSAFE"] = "--not-safe";
+    SearchOpts["OUT_FILE"] = "--out-file";
+    SearchOpts["USE_DEFAULT"] = "--use-default";
+    SearchOpts["OUTPUT"] = "--output";
+})(SearchOpts || (SearchOpts = {}));
+//# sourceMappingURL=search.types.js.map

package/out/commands/search/search.utils.js

@@ -0,0 +1,61 @@
+import { isConfigurationExist, isMasterKeyExist } from "../../util/index.util.js";
+import { SearchOpts } from "./search.types.js";
+export const checkConfigurationAndMasterKey = () => {
+    return new Promise(async (resolve, reject) => {
+        if (!await isConfigurationExist()) {
+            reject(new Error("You are not logged in to your Zoho account yet. Please log in to your Zoho account using zv login"));
+            return;
+        }
+        if (!await isMasterKeyExist()) {
+            reject(new Error("Please unlock your Zoho Vault account using 'zv unlock' before using other commands"));
+            return;
+        }
+        resolve(true);
+    });
+};
+export const getKey = (key) => {
+    switch (key) {
+        case SearchOpts.KEY:
+            return "key";
+        case SearchOpts.STRICT:
+            return "strict";
+        case SearchOpts.TAGS:
+            return "tags";
+        case SearchOpts.DESC:
+            return "desc";
+        case SearchOpts.NAME:
+            return "name";
+        case SearchOpts.VERBOSE:
+            return "verbose";
+        case SearchOpts.NOTSAFE:
+            return "notSafe";
+        case SearchOpts.OUT_FILE:
+            return "outFile";
+        case SearchOpts.OUTPUT:
+            return "output";
+        default:
+            return "";
+    }
+};
+export const getValue = (key, search) => {
+    if ([SearchOpts.STRICT, SearchOpts.TAGS, SearchOpts.DESC, SearchOpts.NAME, SearchOpts.VERBOSE, SearchOpts.NOTSAFE].includes(key)) {
+        return true;
+    }
+    return search[key];
+};
+export const constructDefaultOpts = (opts) => {
+    if (!('search' in opts)) {
+        return {};
+    }
+    const res = {};
+    const { search } = opts;
+    for (const key in search) {
+        const tkey = key;
+        const mkey = getKey(tkey);
+        if (search.hasOwnProperty(tkey)) {
+            res[mkey] = getValue(tkey, search);
+        }
+    }
+    return res;
+};
+//# sourceMappingURL=search.utils.js.map

package/out/commands/set-default/set-default.const.js

@@ -0,0 +1,6 @@
+export var SetDefaultOpts;
+(function (SetDefaultOpts) {
+    SetDefaultOpts["COMMAND"] = "--command";
+    SetDefaultOpts["CLR"] = "--clear-old-defaults";
+})(SetDefaultOpts || (SetDefaultOpts = {}));
+//# sourceMappingURL=set-default.const.js.map

package/out/commands/set-default/set-default.types.js

@@ -0,0 +1,2 @@
+import { SetDefaultOpts } from "./set-default.const.js";
+//# sourceMappingURL=set-default.types.js.map

package/out/commands/set-default/set-default.utils.js

@@ -0,0 +1,39 @@
+import { SetDefaultOpts } from "./set-default.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case SetDefaultOpts.COMMAND:
+            return "command";
+        default:
+            return "";
+    }
+};
+export const getVal = (key, setDefaults) => {
+    if (key === SetDefaultOpts.CLR) {
+        return true;
+    }
+    return setDefaults[key];
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.GET_DEFAULT in opts)) {
+        return {};
+    }
+    const res = {};
+    const { "set-default": setDefault } = opts;
+    for (const key in setDefault) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (setDefault.hasOwnProperty(tKey)) {
+            res[mkey] = getVal(tKey, setDefault);
+        }
+    }
+    return res;
+};
+export const getDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=set-default.utils.js.map

package/out/commands/unlock/unlock.action.js

@@ -0,0 +1,23 @@
+import { checkConfiguration } from "./unlock.utils.js";
+import { Configuration } from "../../util/configuration.util.js";
+import { isValidLicense } from "./unlock.utils.js";
+import { unlockUser } from "./unlock.utils.js";
+import { getDecryptedCredentials } from "../../util/dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../login/login.utils.js";
+export const unlockAction = async (masterPassword, isTrusted) => {
+    try {
+        await checkConfiguration();
+        const credentials = await getDecryptedCredentials(generateWorkspaceHash());
+        const configObj = new Configuration(credentials.dc);
+        const isvalidLicense = await isValidLicense(configObj);
+        if (!isvalidLicense) {
+            console.log("You do not have access to Zoho Vault CLI. Please check your subscription"); //No I18N
+            throw new Error();
+        }
+        await unlockUser(masterPassword, configObj, !isTrusted);
+    }
+    catch (err) {
+        console.log("Operation ended unexpectedly while unlocking a user");
+    }
+};
+//# sourceMappingURL=unlock.action.js.map

package/out/commands/unlock/unlock.help.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unlock.help.js.map

package/out/commands/unlock/unlock.js

@@ -0,0 +1,12 @@
+import { unlockAction } from "./unlock.action.js";
+export const unlock = (program) => {
+    program
+        .command('unlock') //No I18N
+        .description('Access your Zoho Vault account') //No I18N
+        // .option('-nt --notrust', 'Prompt for the master password to run any command. This option can be enabled when using Zoho Vault on a public or an untrustworthy device.', false) //No I18 
+        .argument('[masterpassword]', 'Zoho Vault Master password') //No I18
+        .action(async (masterpassword, options) => {
+        await unlockAction(masterpassword, false);
+    });
+};
+//# sourceMappingURL=unlock.js.map

package/out/commands/unlock/unlock.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unlock.type.js.map