@zohocorporation/vault-cli 1.1.2

package/out/util/index.util.js

@@ -0,0 +1,341 @@
+import os from "os";
+import { DC, OS, SHARING } from "./consts.util.js";
+import crypto from "crypto";
+import { I18N } from "../js/I18n/index.js";
+import axios from "axios";
+import { Logger, LoggerShutdown } from "../js/logger/index.js";
+import { writeFile } from "fs";
+import chalk from "chalk";
+import convert from "xml-js";
+import { highlight } from "cli-highlight";
+import YamlConverter from "js-yaml";
+import Table from "cli-table3";
+import { getCredentials, getDecryptedCredentials } from "./dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../commands/login/login.utils.js";
+import { getConfig } from "./dev.utils.js";
+import { MODE } from "./consts.util.js";
+export const getOS = () => {
+    const choice = os.platform();
+    switch (choice) {
+        case "win32": return OS.WINDOWS;
+        case "darwin": return OS.MAC;
+        default: return OS.LINUX;
+    }
+};
+// export const isValidReadablePath = (path: string | undefined) => {
+// 	return new Promise((resolve, _) => {
+// 		if (!path || path === "") {
+// 			resolve(false);
+// 		}
+// 		try {
+// 			accessSync(path as string, constants.R_OK);
+// 			resolve(true);
+// 		} catch (err) {
+// 			resolve(false);
+// 		}
+// 	})
+// }
+// export const isValidWritablePath = (path: string | undefined) => {
+// 	return new Promise((resolve, _) => {
+// 		if (!path || path === "") {
+// 			resolve(false);
+// 		}
+// 		try {
+// 			accessSync(path as string, constants.R_OK);
+// 			resolve(true);
+// 		} catch (err) {
+// 			resolve(false);
+// 		}
+// 	})
+// }
+// export const isFileExist = (path: string) => {
+// 	return new Promise((resolve, reject) => {
+// 		try {
+// 			if (existsSync(path)) {
+// 				resolve(true);
+// 				return;
+// 			}
+// 			resolve(false);
+// 		} catch (err) {
+// 			reject(new Error("Error while checking for file"));
+// 		}
+// 	})
+// }
+export const isMasterKeyExist = () => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const data = getCredentials(generateWorkspaceHash());
+            if (!data) {
+                resolve(false);
+                return;
+            }
+            const { hasmasterkey } = data;
+            if (!!hasmasterkey && hasmasterkey === "true") {
+                resolve(true);
+                return;
+            }
+            resolve(false);
+        }
+        catch (err) {
+            reject(new Error("Error while checking for master key"));
+        }
+    });
+};
+export const isConfigurationExist = () => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const data = getCredentials(generateWorkspaceHash());
+            resolve(!!data);
+        }
+        catch (err) {
+            resolve(false);
+            Logger.error(err);
+            // reject(new Error("Error while checking for configuration file"));
+        }
+    });
+};
+export const Utilities = {
+    getAccountsUrl: (dc) => {
+        const data = getConfig();
+        const { MODE: mode, ACCOUNTS_URL } = data;
+        if (mode === MODE.DEVELOPMENT) {
+            return ACCOUNTS_URL;
+        }
+        switch (dc) {
+            case DC.AU: return "https://accounts.zoho.com.au";
+            case DC.EU: return "https://accounts.zoho.eu";
+            case DC.IN: return "https://accounts.zoho.in";
+            case DC.CN: return "https://accounts.zoho.com.cn"; //No I18N
+            default: return "https://accounts.zoho.com";
+        }
+    },
+    sleep: (millis) => {
+        return new Promise(resolve => setTimeout(resolve, millis));
+    },
+    getVaultUrl: (dc) => {
+        const data = getConfig();
+        const { MODE: mode, VAULT_URL } = data;
+        if (mode === MODE.DEVELOPMENT) {
+            return VAULT_URL;
+        }
+        switch (dc) {
+            case DC.AU: return "https://vault.zoho.com.au";
+            case DC.EU: return "https://vault.zoho.eu";
+            case DC.IN: return "https://vault.zoho.in";
+            case DC.CN: return "https://vault.zoho.com.cn"; //No I18N
+            default: return "https://vault.zoho.com";
+        }
+    },
+    generateRandomToken: (n) => {
+        return crypto.randomBytes(n).toString("hex");
+    },
+    isTrusted: async () => {
+        const data = await getDecryptedCredentials(generateWorkspaceHash());
+        if (!data) {
+            return { status: false };
+        }
+        const { credentials: { masterkey } } = data;
+        if (masterkey === "" || masterkey.split(",").length !== 2) {
+            return { status: false };
+        }
+        return { status: true, masterKey: masterkey.split(",")[0] };
+    },
+    // isTrusted: () => {
+    // 	const prefix = ".";
+    // 	const masterKey = readFileSync(prefix + NAME.MASTER_KEY, "utf-8");
+    // 	if (masterKey === "" || masterKey.split(",").length !== 2) {
+    // 		return { status: false };
+    // 	} else {
+    // 		return { status: true, masterKey: masterKey.split(",")[0] };
+    // 	}
+    // },
+    writeToFile: (data, filename) => {
+        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.hasOwnProperty(key)) {
+                acc[key] = [];
+            }
+            acc[key]?.push(obj);
+            return acc;
+        }, {});
+    },
+    getSharingPrivilege: (level) => {
+        if (level === 10) {
+            return SHARING.MANAGE;
+        }
+        else if (level === 20) {
+            return SHARING.AUTOLOGIN;
+        }
+        else if (level === 30) {
+            return SHARING.VIEW;
+        }
+        else {
+            return SHARING.MODIFY;
+        }
+    },
+    // isConfigFolderExist: () => {
+    // 	try {
+    // 		const configFileName = readFileSync(NAME.CONFIGURATION_FILE_NAME);
+    // 		const folderExist = existsSync(configFileName);
+    // 		return folderExist;
+    // 	} catch (err) {
+    // 		return false;
+    // 	}
+    // },
+    isConfigured: () => {
+        try {
+            const data = getCredentials(generateWorkspaceHash());
+            if (!!data) {
+                return true;
+            }
+        }
+        catch (err) {
+            new Error("Error while checking for configuration file");
+        }
+        return false;
+    },
+    getHeader: (arr) => {
+        const header = new Set();
+        for (const item of arr) {
+            Object.keys(item).forEach(key => {
+                header.add(key);
+            });
+        }
+        return Array.from(header);
+    },
+    printTable: (secArr) => {
+        let head = Utilities.getHeader(secArr);
+        const colWidths = [];
+        for (let i = 0; i < head.length; i++) {
+            if (i == 0) {
+                colWidths.push(23);
+            }
+            else {
+                colWidths.push(20);
+            }
+        }
+        let table = new Table({
+            head,
+            style: { head: ['blue', 'bold'], border: ['grey'] },
+            colWidths,
+            wordWrap: true
+        });
+        secArr.forEach((secret) => {
+            const row = head.map(headerKey => secret[headerKey] || '');
+            table.push(row);
+        });
+        console.log(table.toString());
+    },
+    isValidOutFile: (fileName, output) => {
+        if (typeof fileName === 'boolean' || output === undefined || output === "" || fileName === undefined) {
+            return false;
+        }
+        const arr = fileName.split('.');
+        return arr.at(-1) === output;
+    },
+    printAsXML: (obj, outFile, output) => {
+        // 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)));
+        let options = { compact: true, ignoreComment: true, spaces: 4, textKey: '_text' };
+        let result = convert.json2xml(JSON.stringify(processedObj), options);
+        if (Utilities.isValidOutFile(outFile, output)) {
+            Utilities.writeToFile(result, outFile);
+            console.log(chalk.green("File created and stored to location: " + outFile));
+            return;
+        }
+        console.log(highlight(result, { language: "xml", ignoreIllegals: true }));
+    },
+    printAsYAML: (obj, outFile, output) => {
+        const yamlOutPut = YamlConverter.dump(obj);
+        if (Utilities.isValidOutFile(outFile, output)) {
+            Utilities.writeToFile(yamlOutPut, outFile);
+            console.log(chalk.green("File created and stored to location: " + outFile));
+            return;
+        }
+        console.log(highlight(yamlOutPut, { language: "yaml", ignoreIllegals: true }));
+    },
+    printAsJSON: (obj, outFile, output) => {
+        if (Utilities.isValidOutFile(outFile, output)) {
+            Utilities.writeToFile(JSON.stringify(obj), outFile);
+            console.log(chalk.green("File created and stored to location: " + outFile));
+            return;
+        }
+        console.log(highlight(JSON.stringify(obj, null, 4), { language: "json", ignoreIllegals: true }));
+    }
+};
+export const _pull = (headers, 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.util.js.map

package/out/util/keyringutil/keyring.util.js

@@ -0,0 +1,57 @@
+import { Entry } from "@napi-rs/keyring";
+import { Logger } from "../../js/logger/index.js";
+export const writeToKeyring = (data, attr, value) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const entry = new Entry(attr, value);
+            try {
+                entry.deletePassword();
+            }
+            catch (deleteErr) {
+                Logger.error("Failed to delete existing keyring entry:", deleteErr);
+            }
+            entry.setPassword(data);
+            resolve(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(false);
+        }
+    });
+};
+export const readFromKeyring = (attr, value) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const keys = process.env.zv_keys;
+            if (!!keys) {
+                resolve(keys);
+                return;
+            }
+            const entry = new Entry(attr, value);
+            const data = entry.getPassword();
+            if (!!data) {
+                process.env.zv_keys = data;
+            }
+            resolve(data);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(new Error("Failed to read from keyring"));
+        }
+    });
+};
+export const deleteFromKeyring = (attr, value) => {
+    return new Promise((reslove, reject) => {
+        try {
+            const entry = new Entry(attr, value);
+            entry.deletePassword();
+            delete process.env.zv_keys;
+            reslove(true);
+        }
+        catch (err) {
+            Logger.error(err);
+            reject(new Error("Cannot delete from keyring"));
+        }
+    });
+};
+//# sourceMappingURL=keyring.util.js.map

package/out/util/loader/loader.interface.js

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

package/out/util/loader/transfer.loader.js

@@ -0,0 +1,28 @@
+export class TransferLoader {
+    #loaderRef = null;
+    load() {
+        const spinner = {
+            "interval": 100,
+            "frames": [
+                " | ",
+                " / ",
+                " — ",
+                " \\ ",
+            ]
+        };
+        let frameIdx = 0;
+        const res = setInterval(() => {
+            process.stdout.write(`\r${spinner.frames[frameIdx]}`);
+            frameIdx = (frameIdx + 1) % spinner.frames.length;
+        }, spinner.interval);
+        this.#loaderRef = res;
+    }
+    stop() {
+        const loaderRef = this.#loaderRef;
+        if (loaderRef) {
+            clearInterval(loaderRef);
+        }
+        console.log("\n");
+    }
+}
+//# sourceMappingURL=transfer.loader.js.map