@zohocorporation/vault-cli 1.1.2

package/README.md

@@ -0,0 +1,16 @@
+# ZohoVault CLI
+
+Steps to get CLI locally
+
+- Run `npm install --registry http://cm-npmregistry` to get dependency packages in package.json. The npm packages present in cm-npmregistry are approved, and others should be approved by legal team.
+- Run `npm run setup` to set up the developer environment.
+- Run `npm run dev` to compile the code and watch for current changes 
+- Run `npm run build` to build zv.cjs file
+- For generating binaries based on the os, run one of the following commands:
+    - Windows: `npm run pkg:win`
+    - Linux: `npm run pkg:lin`
+    - MacOS: `npm run pkg:mac`
+    - Linux-arm: `npm run pkg:lin-arm`
+    - Mac-arm: `npm run pkg:mac-arm`
+    The binary will be present in `bundle/<os>/`
+- For generating all five binaries run `npm run pkg`. 

package/out/commands/add/add.const.js

@@ -0,0 +1,6 @@
+export var AddOpts;
+(function (AddOpts) {
+    AddOpts["CATEGORY_ID"] = "--category-id";
+    AddOpts["FILE"] = "--file";
+})(AddOpts || (AddOpts = {}));
+//# sourceMappingURL=add.const.js.map

package/out/commands/add/add.types.js

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

package/out/commands/add/add.util.js

@@ -0,0 +1,35 @@
+import { AddOpts } from "./add.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case AddOpts.CATEGORY_ID:
+            return "categoryId";
+        case AddOpts.FILE:
+            return "file";
+        default:
+            return "";
+    }
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.ADD in opts)) {
+        return {};
+    }
+    const res = {};
+    const { add } = opts;
+    for (const key in add) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (add.hasOwnProperty(tKey)) {
+            res[mkey] = add[tKey];
+        }
+    }
+    return res;
+};
+export const getAddDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=add.util.js.map

package/out/commands/download/download.const.js

@@ -0,0 +1,6 @@
+export var DownloadOpts;
+(function (DownloadOpts) {
+    DownloadOpts["PASSWORD_ID"] = "--password-id";
+    DownloadOpts["DIR"] = "--dir";
+})(DownloadOpts || (DownloadOpts = {}));
+//# sourceMappingURL=download.const.js.map

package/out/commands/download/download.types.js

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

package/out/commands/download/download.utils.js

@@ -0,0 +1,35 @@
+import { DownloadOpts } from "./download.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case DownloadOpts.PASSWORD_ID:
+            return "passwordId";
+        case DownloadOpts.DIR:
+            return "dir";
+        default:
+            return "";
+    }
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.DOWNLOAD in opts)) {
+        return {};
+    }
+    const res = {};
+    const { download } = opts;
+    for (const key in download) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (download.hasOwnProperty(tKey)) {
+            res[mkey] = download[tKey];
+        }
+    }
+    return res;
+};
+export const getDownloadDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=download.utils.js.map

package/out/commands/generate-password/generate-password.const.js

@@ -0,0 +1,12 @@
+export var GeneratePasswordOpts;
+(function (GeneratePasswordOpts) {
+    GeneratePasswordOpts["USE_PASSWORD_POLICY"] = "--use-password-policy";
+    GeneratePasswordOpts["POLICY_ID"] = "--policy-id";
+    GeneratePasswordOpts["MAX_LENGTH"] = "--max-length";
+    GeneratePasswordOpts["INCLUDE_UPPER_CASE"] = "--include-upper-case";
+    GeneratePasswordOpts["INCLUDE_LOWER_CASE"] = "--include-lower-case";
+    GeneratePasswordOpts["SPECIAL_CHARACTER_COUNT"] = "--special-character-count";
+    GeneratePasswordOpts["INCLUDE_NUMBERS"] = "--include-numbers";
+    GeneratePasswordOpts["EXCLUDE_CHARACTER"] = "--exclude-character";
+})(GeneratePasswordOpts || (GeneratePasswordOpts = {}));
+//# sourceMappingURL=generate-password.const.js.map

package/out/commands/generate-password/generate-password.types.js

@@ -0,0 +1,2 @@
+import { GeneratePasswordOpts } from "./generate-password.const.js";
+//# sourceMappingURL=generate-password.types.js.map

package/out/commands/generate-password/generate-password.utils.js

@@ -0,0 +1,58 @@
+import { GeneratePasswordOpts } from "./generate-password.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case GeneratePasswordOpts.USE_PASSWORD_POLICY:
+            return "usePasswordPolicy";
+        case GeneratePasswordOpts.POLICY_ID:
+            return "policyId";
+        case GeneratePasswordOpts.MAX_LENGTH:
+            return "maxLength";
+        case GeneratePasswordOpts.INCLUDE_UPPER_CASE:
+            return "includeUpperCase";
+        case GeneratePasswordOpts.INCLUDE_LOWER_CASE:
+            return "includeLowerCase";
+        case GeneratePasswordOpts.SPECIAL_CHARACTER_COUNT:
+            return "specialCharacterCount";
+        case GeneratePasswordOpts.INCLUDE_NUMBERS:
+            return "includeNumbers";
+        case GeneratePasswordOpts.EXCLUDE_CHARACTER:
+            return "excludeCharacter";
+        default:
+            return "";
+    }
+};
+export const getVal = (key, generatePassword) => {
+    if ([
+        GeneratePasswordOpts.USE_PASSWORD_POLICY,
+        GeneratePasswordOpts.INCLUDE_LOWER_CASE,
+        GeneratePasswordOpts.INCLUDE_UPPER_CASE,
+        GeneratePasswordOpts.INCLUDE_NUMBERS
+    ].includes(key)) {
+        return true;
+    }
+    return generatePassword[key];
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.GENERATE_PASSWORD in opts)) {
+        return {};
+    }
+    const res = {};
+    const { "generate-password": generatePassword } = opts;
+    for (const key in generatePassword) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (generatePassword.hasOwnProperty(tKey)) {
+            res[mkey] = getVal(tKey, generatePassword);
+        }
+    }
+    return res;
+};
+export const getGenPassDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=generate-password.utils.js.map

package/out/commands/generate-template/generate-template.const.js

@@ -0,0 +1,7 @@
+export var GenerateTemplateOpts;
+(function (GenerateTemplateOpts) {
+    GenerateTemplateOpts["CATEGORY_ID"] = "--category-id";
+    GenerateTemplateOpts["OUT_FILE"] = "--out-file";
+    GenerateTemplateOpts["OUTPUT"] = "--output";
+})(GenerateTemplateOpts || (GenerateTemplateOpts = {}));
+//# sourceMappingURL=generate-template.const.js.map

package/out/commands/generate-template/generate-template.types.js

@@ -0,0 +1,2 @@
+import { GenerateTemplateOpts } from "./generate-template.const.js";
+//# sourceMappingURL=generate-template.types.js.map

package/out/commands/generate-template/generate-template.util.js

@@ -0,0 +1,37 @@
+import { GenerateTemplateOpts } from "./generate-template.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case GenerateTemplateOpts.CATEGORY_ID:
+            return "categoryId";
+        case GenerateTemplateOpts.OUT_FILE:
+            return "outFile";
+        case GenerateTemplateOpts.OUTPUT:
+            return "output";
+        default:
+            return "";
+    }
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.GENERATE_TEMPLATE in opts)) {
+        return {};
+    }
+    const res = {};
+    const { "generate-template": generateTemplate } = opts;
+    for (const key in generateTemplate) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (generateTemplate.hasOwnProperty(tKey)) {
+            res[mkey] = generateTemplate[tKey];
+        }
+    }
+    return res;
+};
+export const getGenTempDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=generate-template.util.js.map

package/out/commands/get/get.const.js

@@ -0,0 +1,8 @@
+export var GetOpts;
+(function (GetOpts) {
+    GetOpts["ID"] = "--password-id";
+    GetOpts["NOT_SAFE"] = "--not-safe";
+    GetOpts["OUT_FILE"] = "--out-file";
+    GetOpts["OUTPUT"] = "--output";
+})(GetOpts || (GetOpts = {}));
+//# sourceMappingURL=get.const.js.map

package/out/commands/get/get.types.js

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

package/out/commands/get/get.utils.js

@@ -0,0 +1,45 @@
+import { GetOpts } from "./get.const.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { Default } from "../../old/Default.js";
+export const getKey = (key) => {
+    switch (key) {
+        case GetOpts.ID:
+            return "passwordId";
+        case GetOpts.NOT_SAFE:
+            return "notSafe";
+        case GetOpts.OUT_FILE:
+            return "outFile";
+        case GetOpts.OUTPUT:
+            return "output";
+        default:
+            return "";
+    }
+};
+export const getValue = (key, get) => {
+    if ([GetOpts.NOT_SAFE].includes(key)) {
+        return true;
+    }
+    return get[key];
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.GET in opts)) {
+        return {};
+    }
+    const res = {};
+    const { get } = opts;
+    for (const key in get) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (get.hasOwnProperty(tKey)) {
+            res[mkey] = getValue(tKey, get);
+        }
+    }
+    return res;
+};
+export const getGetDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=get.utils.js.map

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

@@ -0,0 +1,5 @@
+export var GetDefaultOpts;
+(function (GetDefaultOpts) {
+    GetDefaultOpts["COMMAND"] = "--command";
+})(GetDefaultOpts || (GetDefaultOpts = {}));
+//# sourceMappingURL=get-default.const.js.map

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

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

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

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

package/out/commands/list/list.const.js

@@ -0,0 +1,7 @@
+export var ListOpts;
+(function (ListOpts) {
+    ListOpts["CATEGORY_ID"] = "--category-id";
+    ListOpts["NOT_SAFE"] = "--not-safe";
+    ListOpts["VERBOSE"] = "--verbose";
+})(ListOpts || (ListOpts = {}));
+//# sourceMappingURL=list.const.js.map

package/out/commands/list/list.types.js

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

package/out/commands/list/list.utils.js

@@ -0,0 +1,43 @@
+import { Default } from "../../old/Default.js";
+import { OPTIONS } from "../../util/consts.util.js";
+import { ListOpts } from "./list.const.js";
+export const getKey = (key) => {
+    switch (key) {
+        case ListOpts.CATEGORY_ID:
+            return "categoryId";
+        case ListOpts.NOT_SAFE:
+            return "notSafe";
+        case ListOpts.VERBOSE:
+            return "verbose";
+        default:
+            return "";
+    }
+};
+export const getValue = (key, list) => {
+    if ([ListOpts.NOT_SAFE, ListOpts.VERBOSE].includes(key)) {
+        return true;
+    }
+    return list[key];
+};
+export const constructDefaultOpts = (opts) => {
+    if (!(OPTIONS.LIST in opts)) {
+        return {};
+    }
+    const res = {};
+    const { list } = opts;
+    for (const key in list) {
+        const tKey = key;
+        const mkey = getKey(tKey);
+        if (list.hasOwnProperty(tKey)) {
+            res[mkey] = getValue(tKey, list);
+        }
+    }
+    return res;
+};
+export const getListDefaults = async () => {
+    const def = new Default(undefined, undefined);
+    const options = await def.getDefaults();
+    const defaultOpts = constructDefaultOpts(options);
+    return defaultOpts;
+};
+//# sourceMappingURL=list.utils.js.map

package/out/commands/lock/lock.action.js

@@ -0,0 +1,13 @@
+import { showError } from "../../util/print.util.js";
+import { removeMasterKey } from "./lock.utils.js";
+export const lockAction = async () => {
+    try {
+        await removeMasterKey();
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            showError(err.message);
+        }
+    }
+};
+//# sourceMappingURL=lock.action.js.map

package/out/commands/lock/lock.js

@@ -0,0 +1,10 @@
+import { lockAction } from "./lock.action.js";
+export const lock = (program) => {
+    program
+        .command('lock')
+        .description('Locks your Zoho Vault account')
+        .action(() => {
+        lockAction();
+    });
+};
+//# sourceMappingURL=lock.js.map

package/out/commands/lock/lock.utils.js

@@ -0,0 +1,52 @@
+import { isMasterKeyExist } from "../../util/index.util.js";
+import { getCredentials, getZvDB, insertToTable } from "../../util/dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../login/login.utils.js";
+import { decryptString, encryptString } from "../../util/encryptionutil/encryption.uitl.js";
+export const removeMasterKeyFromDB = async () => {
+    const db = getZvDB();
+    return new Promise(async (resolve, reject) => {
+        try {
+            const data = getCredentials(generateWorkspaceHash());
+            if (!data) {
+                resolve(true);
+                return;
+            }
+            const { credentials, hasmasterkey } = data;
+            if (hasmasterkey === "false") {
+                resolve(true);
+                return;
+            }
+            const decryptedCredentials = JSON.parse(await decryptString(credentials));
+            if (!decryptedCredentials) {
+                resolve(true);
+                return;
+            }
+            decryptedCredentials.masterkey = "";
+            data.credentials = await encryptString(JSON.stringify(decryptedCredentials));
+            data.hasmasterkey = "false";
+            insertToTable(db, data);
+            resolve(true);
+        }
+        catch (err) {
+            reject(false);
+        }
+    });
+};
+export const removeMasterKey = () => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const doesMasterKeyExist = await isMasterKeyExist();
+            if (!doesMasterKeyExist) {
+                console.log("Your Zoho Vault session has already been ended.");
+                return;
+            }
+            await removeMasterKeyFromDB();
+            console.log("Your Zoho Vault account is locked");
+            resolve(true);
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+};
+//# sourceMappingURL=lock.utils.js.map

package/out/commands/login/login.action.js

@@ -0,0 +1,22 @@
+import { checkValidDC, getUserConsentAndCreateConfig } from "./login.utils.js";
+import { Default } from "../../old/Default.js";
+import { constructDefaultOpts } from "./login.utils.js";
+export const loginAction = 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 { dc } = option;
+        const dcLowerCase = dc.toLocaleLowerCase();
+        await checkValidDC(dcLowerCase);
+        await getUserConsentAndCreateConfig(dcLowerCase);
+    }
+    catch (err) {
+        console.log("Operation ended unexpectedly while logging in");
+    }
+};
+//# sourceMappingURL=login.action.js.map

package/out/commands/login/login.const.js

@@ -0,0 +1,10 @@
+import { DC } from "../../util/consts.util.js";
+export const API_DOMAIN = {
+    [DC.US]: "https://www.zohoapis.com",
+    [DC.EU]: "https://www.zohoapis.eu",
+    [DC.AU]: "https://www.zohoapis.com.au",
+    [DC.IN]: "https://www.zohoapis.in",
+    [DC.CN]: "https://www.zohoapis.com.cn",
+};
+export const API_DOMAIN_TO_DC = Object.fromEntries(Object.entries(API_DOMAIN).map(([dc, domain]) => [domain, dc]));
+//# sourceMappingURL=login.const.js.map

package/out/commands/login/login.help.js

@@ -0,0 +1,12 @@
+const loginHelp = () => {
+    console.log(`
+    Example :
+    zv login 
+    zv login --dc eu
+    Note:
+      - You can identify DC from the domain you login.
+      - If you login to vault.zoho.eu then you domain is eu.
+  `);
+};
+export default loginHelp;
+//# sourceMappingURL=login.help.js.map

package/out/commands/login/login.js

@@ -0,0 +1,17 @@
+import loginHelp from "./login.help.js";
+import { loginAction } from "./login.action.js";
+export const login = (program) => {
+    program
+        .command("login")
+        .description("Log in to your Zoho Vault account") //No I18N
+        // .option("-p, --config-path [path]", "Path where your configuration details will be stored") //No I18N
+        .option("--dc [loc]", "DC in which your account is located eg: US | EU | IN | AU | COM.CN ", //No I18N
+    "us")
+        .on('--help', () => {
+        loginHelp();
+    })
+        .action(async (options) => {
+        await loginAction(options);
+    });
+};
+//# sourceMappingURL=login.js.map

package/out/commands/login/login.types.js

@@ -0,0 +1,5 @@
+export var LoginOpts;
+(function (LoginOpts) {
+    LoginOpts["DC"] = "--dc";
+})(LoginOpts || (LoginOpts = {}));
+//# sourceMappingURL=login.types.js.map