@sava-info-systems/api-maker-with-extensions 1.0.0-alpha

package/src/tools/install_utils/InstallFromWeb.js

@@ -0,0 +1,1636 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Upload to : https://images.apimaker.dev/prod/am-cloud/am-init-scripts
+const fs = require("fs");
+const path = require("path");
+const child_process = require("child_process");
+const loading = require("loading-cli");
+const colors = require("colors-cli");
+const os = require("os");
+const mongodb = require("mongodb");
+const ioredis_1 = require("ioredis");
+const JSON5 = require("json5");
+const { NumberPrompt, Input, BooleanPrompt } = require('enquirer');
+const isDefaultInstallation = process.argv.indexOf('--default') >= 0;
+class InstallFromWeb {
+    constructor() {
+        this.characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789';
+        this.swapSize = 0;
+        this.isDocker = false;
+        this.CADDY_FILE_NAME = 'Caddyfile';
+        this.mongo = {
+            port: 0,
+            username: '',
+            password: '',
+        };
+        this.redis = {
+            port: 0,
+            password: '',
+        };
+        this.am = {
+            port: 0,
+            wsPort: 0,
+            portOriginal: 38246,
+            portOriginalWS: 38245,
+            passCommunication: '',
+            passJWT: '',
+            passDBEncryptDecrypt: '',
+            // for secondary server
+            secondary: {
+                serverName: '',
+                connectionStrings: {
+                    mongodb: '',
+                    redisInternal: '',
+                    redisExternal: '',
+                },
+            },
+        };
+        this.config = {
+            IP: '',
+            installSSL: false,
+            beHost: '',
+            beWSHost: '',
+            feHost: '',
+            // skip some installations
+            oldEnvExists: false,
+            installMongo: true,
+            installRedis: true,
+            // calculated properties from caddyFile
+            fullUrlOfBE: '',
+            fullUrlOfWS: '',
+            fullUrlOfFE: '',
+            startAMCommand: '',
+            stopAMCommand: '',
+            installType: EInstallationType.PRIMARY,
+        };
+        this.envFileD = {}; // env file data parsed in JSON.
+        this.os = {
+            Ubuntu20: false,
+            Ubuntu22: false,
+            Ubuntu23: false,
+            Ubuntu24: false,
+        };
+        // </editor-fold>
+    }
+    async main() {
+        try {
+            this.registerProcessHooks();
+            await this.isPrimaryOrSecondaryServer();
+            // Set and validate system
+            await this.printFlagsInfo();
+            await this.isRootUserProvided();
+            await this.setHome();
+            await this.setNodeHome();
+            await this.isUbuntu();
+            await this.isAVXSupported();
+            await this.isDiskSizeEnough();
+            await this.loadExistingEnvironments();
+            await this.getIPAddressOfServer();
+            await this.wantToInstallSSL();
+            await this.setSwapPartition();
+            await this.createDefaultDirectories();
+            await this.isDockerInstalled();
+            // Get user inputs in advance
+            if (this.config.installType === EInstallationType.PRIMARY)
+                await this.installInPrimaryServer();
+            else if (this.config.installType === EInstallationType.SECONDARY)
+                await this.installInSecondaryServer();
+            console.log('\n');
+            console.log('❤️  Thank you for using API Maker, Enjoy !! ❤️');
+            console.log('\n');
+            process.exit(0); // Need to exit because one promise of caddy is not done yet.
+        }
+        catch (e) {
+            console.error(e);
+            process.exit(1);
+        }
+    }
+    async installInPrimaryServer() {
+        await this.getSSLHosts(); // IP is used in this
+        await this.getMongoInputsFromUser();
+        await this.getRedisInputsFromUser();
+        await this.getAPIMakerUserInputs();
+        // Begin installation
+        await this.aptUpdate();
+        await this.installMake();
+        await this.installD2DiagramLibrary();
+        await this.installDockerIfNotInstalled();
+        await this.installFreshMongoDB();
+        await this.installFreshRedis();
+        await this.printPostInstallCommands();
+        await this.userExecutedMongoCommand();
+        await this.installOracleClient();
+        const calculatedStrings = await this.calculateMongoAndRedisConnectionStrings();
+        await this.writeEnvFileInConfigDirectory('primary', calculatedStrings.mongoDBConnectionString, calculatedStrings.redisConnectionStringInternal, calculatedStrings.redisConnectionStringExternal);
+        await this.syncEnvDataInFrontend();
+        // Start processes
+        await this.startAPIMakerBackendProcess();
+        this.calculateURLs();
+        // Caddy server & it's file processing.
+        await this.stopCaddy(true);
+        await this.sleep(2000);
+        await this.isPort80Free();
+        await this.installCaddyIfNotInstalled();
+        await this.writeCaddyFile();
+        await this.restartCaddy();
+        await this.startPM2ProcessOnRestart();
+        await this.printPM2ProcessList();
+        // Print section
+        this.printAllSetupConfigurations();
+        this.printEndpointSummary();
+        this.printDefaultUsers();
+        this.printStartAndStopCommands();
+    }
+    async installInSecondaryServer() {
+        await this.getSSLHosts(); // IP is used in this
+        await this.getAPIMakerUserInputs();
+        // Begin installation
+        await this.aptUpdate();
+        await this.installMake();
+        await this.installD2DiagramLibrary();
+        await this.installDockerIfNotInstalled();
+        await this.installOracleClient();
+        await this.writeEnvFileInConfigDirectory(this.am.secondary.serverName, this.am.secondary.connectionStrings.mongodb, this.am.secondary.connectionStrings.redisInternal, this.am.secondary.connectionStrings.redisExternal);
+        // Start processes
+        await this.startAPIMakerBackendProcess();
+        this.calculateURLs();
+        // Caddy server & it's file processing.
+        await this.stopCaddy(true);
+        await this.sleep(2000);
+        await this.isPort80Free();
+        await this.installCaddyIfNotInstalled();
+        await this.writeCaddyFile();
+        await this.restartCaddy();
+        await this.startPM2ProcessOnRestart();
+        await this.printPM2ProcessList();
+        // Print section
+        this.printAllSetupConfigurations();
+        this.printEndpointSummary();
+        this.printStartAndStopCommands();
+        this.printSecondaryServerAttachInformation();
+    }
+    registerProcessHooks() {
+        // eslint-disable-next-line n/handle-callback-err
+        process.on('unhandledRejection', (error, promise) => {
+            // console.log('Oh Lord! We forgot to handle a promise rejection here: ', promise);
+            // console.log('The error was: ', error);
+            // console.log(error);
+        });
+        // eslint-disable-next-line n/handle-callback-err
+        process.on('uncaughtException', function (error, origin) {
+            // console.log(error);
+        });
+    }
+    async loadExistingEnvironments() {
+        const envPath = path.join(this.HOME, 'config', '.env');
+        if (fs.existsSync(envPath)) {
+            this.config.oldEnvExists = true;
+            const dotenv = require('dotenv');
+            this.envFileD = dotenv.parse(fs.readFileSync(envPath, { encoding: 'utf8' }));
+            console.log(`🔶  Using existing environment variable settings from : ${envPath}`);
+        }
+    }
+    async printFlagsInfo() {
+        if (isDefaultInstallation)
+            console.log(`🟦  Default Installation selected`);
+    }
+    async setHome() {
+        this.HOME = (await this.runCommandSilent(`echo $HOME`, '/')).trim();
+        console.log(`✅  HOME : ${this.HOME}`);
+    }
+    async setNodeHome() {
+        const fullNodePath = (await this.runCommandSilent(`which node`, '/')).trim();
+        this.NODE_HOME = path.dirname(fullNodePath.trim());
+        console.log(`✅  NODE_HOME : ${this.NODE_HOME}`);
+    }
+    async isUbuntu() {
+        const output = await this.runCommandSilent(`cat /etc/os-release`, '/');
+        if (output.indexOf('VERSION_ID="22') >= 0) {
+            console.log(`✅  Ubuntu 22`);
+            this.os.Ubuntu22 = true;
+        }
+        else if (output.indexOf('VERSION_ID="23') >= 0) {
+            this.os.Ubuntu23 = true;
+            console.log(`✅  Ubuntu 23`);
+        }
+        else if (output.indexOf('VERSION_ID="24') >= 0) {
+            // this.os.Ubuntu24 = true;
+            // console.log(`✅  Ubuntu 24`);
+            throw new Error(`❌ Ubuntu 24 is not supported right now. Follow us on X @api_maker for latest updates.`);
+        }
+        else if (output.indexOf('VERSION_ID="20') >= 0) {
+            this.os.Ubuntu20 = true;
+            console.log(`✅  Ubuntu 20`);
+        }
+        else {
+            if (output.indexOf('NAME="Ubuntu"') >= 0) {
+                console.log(`⚠️  [Ubuntu 22 | Ubuntu 20 | Ubuntu 23] not found, but you can try.`);
+                console.log(`👉  If docker installation fails, try installing docker manually and try again.`);
+            }
+            else
+                throw new Error(`❌ Operating System is not Ubuntu.`);
+        }
+    }
+    async isAVXSupported() {
+        const output = await this.runCommandSilent(`cat /proc/cpuinfo`, '/');
+        if (output.toLowerCase().indexOf('avx') >= 0)
+            console.log(`✅  AVX Supported`);
+        else
+            console.log(`⚠️  AVX is not supported. It is required by MongoDB`);
+    }
+    /**
+     * df -hP
+     * ---- Output ----
+     * Filesystem      Size  Used Avail Use% Mounted on
+     * tmpfs            96M  1.2M   95M   2% /run
+     * /dev/sda         25G  8.2G   15G  36% /
+     * tmpfs           479M     0  479M   0% /dev/shm
+     * tmpfs           5.0M     0  5.0M   0% /run/lock
+     * tmpfs            96M  4.0K   96M   1% /run/user/0
+     * overlay          25G  8.2G   15G  36% /var/lib/docker/overlay2/cfc9fc672e96ac1ab40940bb4eaef996362a7c77713296f62dac58f2b7dc570d/merged
+     * overlay          25G  8.2G   15G  36% /var/lib/docker/overlay2/83a4b1be8586d950f818f6e8fb1db7d7aa4095c1827cd4b00ee437f6c905b82a/merged
+     */
+    async isDiskSizeEnough() {
+        try {
+            const output = await this.runCommandSilent(`df -hP`, '/');
+            const lines = output.split('\n');
+            for (const line of lines) {
+                const words = line.split(' ').map(w => (w || '').trim()).filter(w => !!w);
+                const lastWord = words[words.length - 1];
+                if (lastWord === '/') {
+                    const totalDiskSize = Number(words[1].replace('G', ''));
+                    if (totalDiskSize >= 20)
+                        console.log(`✅  Disk size is good enough : ${words[1]}`);
+                    else
+                        console.log(`✴️  Disk size is not good enough : ${words[1]}`);
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            console.log(`✴️  Please make sure disk size is greater than 20GB`);
+            // console.log(e);
+        }
+    }
+    async isRootUserProvided() {
+        const output = await this.runCommandSilent(`whoami`, '/');
+        if (output.indexOf('root') >= 0)
+            console.log(`✅  Root user provided`);
+        else
+            throw new Error(`❌  Please provide root user.`);
+    }
+    async isPrimaryOrSecondaryServer() {
+        const prompt = new Input({
+            message: ' Is this primary[P]|secondary[S] server (P|S)?',
+            initial: 'P',
+            validate: (userInput) => {
+                const upper = (userInput || '').toUpperCase();
+                if (upper === 'P') {
+                    this.config.installType = EInstallationType.PRIMARY;
+                    return true;
+                }
+                else if (upper === 'S') {
+                    this.config.installType = EInstallationType.SECONDARY;
+                    return true;
+                }
+                else
+                    return 'P = Primary,  S = Secondary';
+            },
+        });
+        await prompt.run();
+    }
+    async getIPAddressOfServer() {
+        let getIPAddress;
+        try {
+            getIPAddress = await this.runCommandSilent(`curl -s https://ipinfo.io/ip`, '/');
+            getIPAddress = getIPAddress.trim();
+            if (this.isValidIpAddress(getIPAddress)) {
+                this.config.IP = getIPAddress;
+                // return; // Do not return. Take it from user also because for some severs it can be value of gateway IP address.
+            }
+        }
+        catch (e) {
+        }
+        const prompt = new Input({
+            message: ' Please enter public IP address of this server',
+            initial: getIPAddress,
+            validate: (userInput) => {
+                if (this.isValidIpAddress(userInput))
+                    return true;
+                else
+                    return 'Please provide valid IP address.';
+            },
+        });
+        this.config.IP = await prompt.run();
+    }
+    async wantToInstallSSL() {
+        const prompt = new BooleanPrompt({
+            message: ' Do you want to install SSL?',
+            initial: false,
+        });
+        this.config.installSSL = await prompt.run();
+    }
+    async wantToInstallMongoDB() {
+        const prompt = new BooleanPrompt({
+            message: ' Do you want to re-install MongoDB?',
+            initial: false,
+        });
+        this.config.installMongo = await prompt.run();
+    }
+    async wantToInstallRedis() {
+        const prompt = new BooleanPrompt({
+            message: ' Do you want to re-install Redis?',
+            initial: false,
+        });
+        this.config.installRedis = await prompt.run();
+    }
+    async getSSLHosts() {
+        if (!this.config.installSSL)
+            return;
+        const promptBE = new Input({
+            message: ' Please enter domain for backend',
+            validate: async (userInput) => {
+                return await this.getValidHostFromUser(userInput);
+            },
+        });
+        this.config.beHost = await promptBE.run();
+        const promptWS = new Input({
+            message: ' Please enter domain for backend WebSocket',
+            validate: async (userInput) => {
+                return await this.getValidHostFromUser(userInput);
+            },
+        });
+        this.config.beWSHost = await promptWS.run();
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            const promptFE = new Input({
+                message: ' Please enter domain for frontend admin panel',
+                validate: async (userInput) => {
+                    return await this.getValidHostFromUser(userInput);
+                },
+            });
+            this.config.feHost = await promptFE.run();
+        }
+    }
+    // <editor-fold desc="Set swap partition">
+    async setSwapPartition() {
+        const MIN_SWAP_SIZE = 2000 * os.cpus().length;
+        const output = await this.runCommandSilent(`free --mebi`, '/');
+        const currentSwapSize = this.getSwapMemorySizeFromCommandOutput(output);
+        if (currentSwapSize <= MIN_SWAP_SIZE) {
+            const prompt = new NumberPrompt({
+                message: ' Please enter swap size',
+                initial: MIN_SWAP_SIZE,
+                validate: (userInput) => {
+                    if (userInput < MIN_SWAP_SIZE)
+                        return `Minimum swap size should be ${MIN_SWAP_SIZE}`;
+                    return true;
+                },
+            });
+            const userSwapSize = isDefaultInstallation ? MIN_SWAP_SIZE : await prompt.run();
+            this.showLoading(`Setting swap partition of size ${MIN_SWAP_SIZE}...`);
+            // Just in case old swap is running, so stop it and create new one.
+            try {
+                await this.runCommandSilent(`swapoff /var/swap.img`, '/');
+            }
+            catch (e) {
+            }
+            await this.runCommandSilent([
+                `cd /var`,
+                `touch swap.img`,
+                `chmod 600 swap.img`,
+                `dd if=/dev/zero of=/var/swap.img bs=1024k count=${userSwapSize + 200}`,
+                `mkswap /var/swap.img`,
+                `swapon /var/swap.img`,
+                `echo "/var/swap.img none swap sw 0 0" >> /etc/fstab`,
+            ].join('\n'), '/');
+            this.hideLoading();
+            this.swapSize = userSwapSize;
+            console.log(`✅  Swap size set to ${userSwapSize}`);
+        }
+        else {
+            this.swapSize = currentSwapSize;
+            console.log(`✅  Swap size is ${currentSwapSize}`);
+        }
+    }
+    // Duplicate code
+    getSwapMemorySizeFromCommandOutput(output) {
+        const lines = output.split('\n');
+        let totalSwap = 0;
+        for (let line of lines) {
+            line = (line || '').trim().toLowerCase();
+            if (line.startsWith('swap')) {
+                const lineSections = line.split(' ');
+                let index = 0;
+                for (const section of lineSections) {
+                    if (!section)
+                        continue;
+                    if (index === 1) {
+                        totalSwap += Number(section.trim());
+                        break;
+                    }
+                    index++;
+                }
+            }
+        }
+        return totalSwap;
+    }
+    // </editor-fold>
+    async createDefaultDirectories() {
+        await fs.promises.mkdir(path.join(this.HOME, 'config'), { recursive: true });
+        await fs.promises.mkdir(path.join(this.HOME, 'logs'), { recursive: true });
+        await fs.promises.mkdir(path.join(this.HOME, 'docker-data'), { recursive: true });
+    }
+    async isDockerInstalled() {
+        try {
+            const dockerVersion = await this.runCommandSilent(`docker --version`, '/');
+            console.log(`✅  Docker found : ${dockerVersion.trim()}`);
+            this.isDocker = true;
+            return;
+        }
+        catch (e) {
+        }
+        this.isDocker = false;
+    }
+    async aptUpdate() {
+        try {
+            this.showLoading('apt update...');
+            await this.runCommandSilent(`apt update`, '/');
+            this.hideLoading();
+            console.log(`✅  apt update`);
+        }
+        catch (e) {
+        }
+    }
+    async installMake() {
+        try {
+            const makeVersion = await this.runCommandSilent(`make -version`, '/');
+            console.log(`✅  Make : ${makeVersion.trim().split('\n')[0]}`);
+        }
+        catch (e) {
+            this.showLoading('Installing make...');
+            await this.runCommandSilent(`apt-get install -y make`, '/');
+            const makePath = await this.runCommandSilent(`which make`, '/');
+            this.hideLoading();
+            console.log(`✅  make installed on path: ${makePath.trim()}`);
+        }
+    }
+    async installD2DiagramLibrary() {
+        try {
+            const d2LibVersion = await this.runCommandSilent(`d2 --version`, '/');
+            console.log(`✅  D2 : ${d2LibVersion.trim()}`);
+        }
+        catch (e) {
+            this.showLoading('Installing D2...');
+            await this.runCommandSilent(`curl -fsSL https://d2lang.com/install.sh | sh -s --`, '/');
+            const d2Path = await this.runCommandSilent(`which d2`, '/');
+            this.hideLoading();
+            console.log(`✅  D2 diagram library installed on path: ${d2Path.trim()}`);
+        }
+    }
+    async installDockerIfNotInstalled() {
+        try {
+            const dockerVersion = await this.runCommandSilent(`docker --version`, '/');
+            console.log(`✅  ${dockerVersion.trim()}`);
+            const dockerComposeVersion = await this.runCommandSilent(`docker-compose --version`, '/');
+            console.log(`✅  ${dockerComposeVersion.trim()}`);
+        }
+        catch (e) {
+            this.showLoading('Installing Docker...');
+            if (this.os.Ubuntu20) {
+                await this.runCommandSilent([
+                    `apt-get install -y apt-transport-https ca-certificates curl software-properties-common`,
+                    `curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -`,
+                    `add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"`,
+                    `apt-get install -y docker-ce docker-compose`,
+                ].join('\n'), '/');
+            }
+            else {
+                // if (this.os.Ubuntu22 || this.os.Ubuntu23 || this.os.Ubuntu24)
+                await this.runCommandSilent([
+                    `for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do apt-get remove $pkg; done`,
+                    `apt-get update`,
+                    `apt-get install -y ca-certificates curl gnupg`,
+                    `install -m 0755 -d /etc/apt/keyrings`,
+                    `curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor --batch --yes -o /etc/apt/keyrings/docker.gpg`,
+                    `chmod a+r /etc/apt/keyrings/docker.gpg`,
+                    `echo \\`,
+                    `"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \\`,
+                    `$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \\`,
+                    `tee /etc/apt/sources.list.d/docker.list > /dev/null`,
+                    `apt-get update`,
+                    `apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-compose`,
+                ].join('\n'), '/');
+            }
+            this.hideLoading();
+            console.log(`✅  Docker installed`);
+        }
+    }
+    // <editor-fold desc="MongoDB Installation">
+    async getMongoInputsFromUser() {
+        if (this.config.oldEnvExists && this.envFileD[EInstallEnv.am__mongo_db_connection]) {
+            await this.wantToInstallMongoDB();
+        }
+        if (!this.config.installMongo) {
+            console.log(`👍  MongoDB install skipped. Old connection string will be used. Data will not lost.`);
+            return;
+        }
+        if (this.isDocker) {
+            try {
+                await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/mongodb_api_maker.yml stop`, '/');
+                console.log(`✅  MongoDB container stopped`);
+            }
+            catch (e) {
+            }
+        }
+        if (!isDefaultInstallation)
+            console.log(`———— #MongoDB Section ————`);
+        this.mongo.port = await this.getMongoPortFromUser();
+        this.mongo.username = await this.getMongoUsernameFromUser();
+        this.mongo.password = await this.getMongoPasswordFromUser();
+        if (!isDefaultInstallation)
+            console.log(`——————————————————————————`);
+    }
+    async installFreshMongoDB() {
+        if (!this.config.installMongo)
+            return;
+        console.log(`⏳  MongoDB Installing...`);
+        const oldDataFolder = path.join(this.HOME, 'docker-data', 'mongodb_api_maker');
+        this.showLoading('Installing MongoDB');
+        await this.writeMongoDBKeyFile();
+        await this.writeDCFileForMongoDB(this.mongo.port, this.mongo.username, this.mongo.password);
+        await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/mongodb_api_maker.yml stop`, '/');
+        await this.runCommandSilent(`rm -rf ${oldDataFolder}`, '/');
+        await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/mongodb_api_maker.yml up -d`, '/');
+        this.hideLoading();
+        console.log(`   ✔ [Remove] : ${oldDataFolder}`);
+        console.log(`✅  MongoDB Installed`);
+    }
+    async writeMongoDBKeyFile() {
+        const keyFilePath = path.join(this.HOME, 'config', 'keyfile');
+        await fs.promises.writeFile(keyFilePath, [
+            '3ZlDTasYgr9tvXxcoZqeZkyWuhmPlssi1bLdVU+95+tintw007UY4THzRuV/yzMm',
+            'BOGl40q+JTJ6f8TXCjBwJT+nid9OoqoGAczoFqAjlAayuY4Qmv8Iv38XEJHAAx/U',
+            'WC/HTCOodCHo9YBBYQ68uSTVzx47Nyp/z+CR3b1f9rA0hX9zkm/H3B96Vu7lhkJ1',
+            '1wxpRlQ8udj2LrcZ0cAuMDCcuGDsa5Nydg3OEHs4PHzdIdDm+LB2YavsOGEyM422',
+            'vPXH7pX1VAag1Br1CMmJijegau83SLJZN875TC+sWelKjH7nb1i/nWqsabThpnIu',
+            'wpb+pl5vvJGxq21qZysz/8ZT7YgD6FMJoTMdFw6+MAXe0OiHlZUW5m6DPs9VL9wa',
+            'CJXyU97UULmxHTUO4+7MoxwoGL/59vspgytBOpXRrOlnAepbLDOwTK4jyz3cfx1P',
+            '6xqdctgDAuDLp3yqK/GovpWxTHaWlSaqgqMfiqZptwWUR08uhzx9SI6buqr1lWrz',
+            'SkFLQICOZ+Cjdb845/grloftBS1zDNflgLgY75Wzut8X6swEFebfyA3HRNOLh7pm',
+            '4fEGNTf3OnwAhDj18y943NfVyKlb57Tl33rAj0xDsb2ku+Ug71xOjkdrTtKczczD',
+            'rsVUWtyiMieN1oivO9Ss1e/bbHfTyUlqfNlXSo4wqVS6wqnPQOYX6JeSPowvYdf4',
+            'J1D/iSiPlqKiy28T/KUq+h04VMCCJUFW6a87yRczT1lp4F5bWzhzY6Of3ebok9hS',
+            '/KlYm4/uegDFMC+Rd/EWaagGwgL5KBHbvkgGz65uOxlTVJzGiZngKUrs8RmIlOXH',
+            'SynnwFHUP7jSUAedZjxlWkt9b7U5rSXAPnFhhW4QNoeccnrqcJcS2lQQA8wSD6ur',
+            '2jo73kLVAcesAAoZ8jNBZxQOO7y4/9m7v5zCj0VJ2BIrCtwqEYUtCuMH06JkecCU',
+            'DBm/m13f7WpUd2mvZk6ULc/D8n03',
+        ].join('\n'), { encoding: 'utf8' });
+        console.log(`    ✔ [Write] : ${keyFilePath}`);
+    }
+    async writeDCFileForMongoDB(mongoPort, mongoUsername, mongoPassword) {
+        const mongodbDCFilePath = path.join(this.HOME, 'config', 'mongodb_api_maker.yml');
+        await fs.promises.writeFile(mongodbDCFilePath, [
+            `version: "3.7"`,
+            `services:`,
+            `    mongodb_api_maker:`,
+            `        image: mongo:6.0.2`,
+            `        container_name: mongodb_api_maker`,
+            `        restart: always`,
+            `        environment: # Not working without username and pass. So keep it.`,
+            `            - MONGO_INITDB_ROOT_USERNAME=${mongoUsername}`,
+            `            - MONGO_INITDB_ROOT_PASSWORD=${mongoPassword}`,
+            `            - MONGO_REPLICA_SET_NAME=rs0`,
+            `        volumes:`,
+            `            - ${this.HOME}/docker-data/mongodb_api_maker/data:/data/db`,
+            `            - ./keyfile:/opt/keyfile`,
+            `        ports:`,
+            `            - ${mongoPort}:27017`,
+            `        entrypoint:`,
+            `            - bash`,
+            `            - -c`,
+            `            - |`,
+            `                chmod 400 /opt/keyfile`,
+            `                chown 999:999 /opt/keyfile`,
+            `                exec docker-entrypoint.sh $$@`,
+            `        command: "mongod --bind_ip_all --keyFile /opt/keyfile --replSet rs0 --quiet"`,
+            `        logging:`,
+            `            driver: "json-file"`,
+            `            options:`,
+            `                max-size: "5m"`,
+            `                max-file: "3"`,
+            ``,
+        ].join('\n'), { encoding: 'utf8' });
+        console.log(`    ✔ [Write] : ${mongodbDCFilePath}`);
+    }
+    async getMongoPortFromUser() {
+        const defaultMongoPort = 38248;
+        const prompt = new NumberPrompt({
+            message: ' Please enter MongoDB port',
+            initial: defaultMongoPort,
+            validate: async (userInput) => {
+                if (userInput < 2000)
+                    return 'Port should be greater than 2000-60000';
+                else if (userInput > 60000)
+                    return 'Port should be between 2000-60000';
+                const isPortFree = await this.isGivenPortFree(userInput);
+                if (isPortFree)
+                    return true;
+                else
+                    return `Port ${userInput} is not free.`;
+            },
+        });
+        return isDefaultInstallation ? defaultMongoPort : await prompt.run();
+    }
+    async getMongoUsernameFromUser() {
+        const defaultMongoUser = 'api_maker_user';
+        const prompt = new Input({
+            message: ' Please enter MongoDB username',
+            initial: defaultMongoUser,
+            validate: (userInput) => {
+                if (userInput.length < 4)
+                    return 'Username length should be between 4-32';
+                else if (userInput.length > 32)
+                    return 'Username length should be between 4-32';
+                return true;
+            },
+        });
+        return isDefaultInstallation ? defaultMongoUser : await prompt.run();
+    }
+    async getMongoPasswordFromUser() {
+        const mongoPass = this.getRandomString(20);
+        const prompt = new Input({
+            message: ' Please enter MongoDB password',
+            initial: mongoPass,
+            validate: (userInput) => {
+                if (userInput.length < 4)
+                    return 'Password length should be between 4-32';
+                else if (userInput.length > 32)
+                    return 'Password length should be between 4-32';
+                if (this.isAlphaNumericalValidPass(userInput))
+                    return true;
+                return 'Password can only contain [a-z, A-Z, 0-9, _], special characters creates issue in setup automation process.';
+            },
+        });
+        return isDefaultInstallation ? mongoPass : await prompt.run();
+    }
+    // </editor-fold>
+    // <editor-fold desc="Redis Installation">
+    async getRedisInputsFromUser() {
+        if (this.config.oldEnvExists && this.envFileD[EInstallEnv.am__redisInternal]) {
+            await this.wantToInstallRedis();
+        }
+        if (!this.config.installRedis) {
+            console.log(`👍  Redis install skipped. Old connection string will be used. Data will not lost.`);
+            return;
+        }
+        if (this.isDocker) {
+            try {
+                await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/redis_api_maker.yml stop`, '/');
+                console.log(`✅  Redis container stopped`);
+            }
+            catch (e) {
+            }
+        }
+        if (!isDefaultInstallation)
+            console.log(`———— #Redis Section ——————`);
+        this.redis.port = await this.getRedisPortFromUser();
+        this.redis.password = await this.getRedisPasswordFromUser();
+        if (!isDefaultInstallation)
+            console.log(`——————————————————————————`);
+    }
+    async installFreshRedis() {
+        if (!this.config.installRedis)
+            return;
+        console.log(`⏳  Redis Installing...`);
+        const oldDataFolder = path.join(this.HOME, 'docker-data', 'redis_api_maker');
+        this.showLoading('Installing Redis');
+        await this.writeDCFileForRedis(this.redis.port, this.redis.password);
+        await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/redis_api_maker.yml stop`, '/');
+        await this.runCommandSilent(`rm -rf ${oldDataFolder}`, '/');
+        await this.runCommandSilent(`docker-compose --project-name api_maker -f ${this.HOME}/config/redis_api_maker.yml up -d`, '/');
+        this.hideLoading();
+        console.log(`   ✔ [Remove] : ${oldDataFolder}`);
+        console.log(`✅  Redis Installed`);
+    }
+    async getRedisPortFromUser() {
+        const defaultRedisPort = 7479;
+        const prompt = new NumberPrompt({
+            message: ' Please enter Redis port',
+            initial: defaultRedisPort,
+            validate: async (userInput) => {
+                if (userInput < 2000)
+                    return 'Port should be greater than 2000-60000';
+                else if (userInput > 60000)
+                    return 'Port should be between 2000-60000';
+                else if (this.mongo.port === userInput)
+                    return 'It should not be same as MongoDB port.';
+                const isPortFree = await this.isGivenPortFree(userInput);
+                if (isPortFree)
+                    return true;
+                else
+                    return `Port ${userInput} is not free.`;
+            },
+        });
+        return isDefaultInstallation ? defaultRedisPort : await prompt.run();
+    }
+    async getRedisPasswordFromUser() {
+        const redisPass = this.getRandomString(20);
+        const prompt = new Input({
+            message: ' Please enter Redis password',
+            initial: redisPass,
+            validate: (userInput) => {
+                if (userInput.length < 4)
+                    return 'Password length should be between 4-32';
+                else if (userInput.length > 32)
+                    return 'Password length should be between 4-32';
+                if (this.isAlphaNumericalValidPass(userInput))
+                    return true;
+                return 'Password can only contain [a-z, A-Z, 0-9, _], special characters creates issue in setup automation process.';
+            },
+        });
+        return isDefaultInstallation ? redisPass : await prompt.run();
+    }
+    async writeDCFileForRedis(redisPort, redisPassword) {
+        const redisDCFilePath = path.join(this.HOME, 'config', 'redis_api_maker.yml');
+        await fs.promises.writeFile(redisDCFilePath, [
+            `version: "3.7"`,
+            `networks:`,
+            `    redis_api_maker-network:`,
+            `        driver: bridge`,
+            `services:`,
+            `    redis_api_maker:`,
+            `        image: 'redis:7.0.5-alpine'`,
+            `        restart: always`,
+            `        container_name: redis_api_maker`,
+            `        environment:`,
+            `            - REDIS_PORT_NUMBER=${redisPort}`,
+            `        ports:`,
+            `            - '${redisPort}:6379'`,
+            `        command: redis-server --loglevel warning --requirepass ${redisPassword}`,
+            `        volumes:`,
+            `            - ${this.HOME}/docker-data/redis_api_maker:/data`,
+            `        networks:`,
+            `            - redis_api_maker-network`,
+            `        logging:`,
+            `            driver: "json-file"`,
+            `            options:`,
+            `                max-size: "5m"`,
+            `                max-file: "3"`,
+            ``,
+        ].join('\n'), { encoding: 'utf8' });
+        console.log(`    ✔ [Write] : ${redisDCFilePath}`);
+    }
+    // </editor-fold>
+    async printPostInstallCommands() {
+        if (!this.config.installMongo)
+            return;
+        const mongoContainerID = (await this.runCommandSilent(`docker ps -aqf "name=mongodb_api_maker"`, '/')).trim();
+        console.log(`\n\n`);
+        console.log(`👉 Run below 3 commands in separate terminal.`);
+        console.log(`——————————————————————————————————————————————————————————————————————————————————————`);
+        console.log(colors.cyan(`docker exec -it ${mongoContainerID} /bin/bash # Go inside docker container`));
+        console.log(colors.green(`mongosh -u ${this.mongo.username} -p ${this.mongo.password} # Go inside mongo shell`));
+        console.log(`——————————————————————————————————————————————————————————————————————————————————————`);
+        console.log(colors.yellow([
+            `rs.initiate({`,
+            `    _id : "rs0",`,
+            `    members: [`,
+            `        { _id: 0, host: "127.0.0.1:27017" }`,
+            `    ]`,
+            `});`,
+            `db.getSiblingDB("admin").updateUser(`,
+            `    "${this.mongo.username}",`,
+            `    {`,
+            `        customData: {},`,
+            `        roles: [`,
+            `            { "role": "root", "db": "admin" },`,
+            `            { "role": "readAnyDatabase", "db": "admin" },`,
+            `            { "role": "readWriteAnyDatabase", "db": "admin" },`,
+            `            { "role": "userAdminAnyDatabase", "db": "admin" },`,
+            `            { "role": "dbAdminAnyDatabase", "db": "admin" },`,
+            `            { "role": "backup", "db": "admin" },`,
+            `            { "role": "restore", "db": "admin" },`,
+            `            { "role": "clusterAdmin", "db": "admin" },`,
+            `            { "role": "clusterManager", "db": "admin" },`,
+            `            { "role": "clusterMonitor", "db": "admin" },`,
+            `            { "role": "hostManager", "db": "admin" },`,
+            `            { "role": "dbAdmin", "db": "admin" },`,
+            `            { "role": "dbOwner", "db": "admin" },`,
+            `            { "role": "userAdmin", "db": "admin" },`,
+            `        ],`,
+            `    }`,
+            `);`,
+        ].join('\n')));
+        console.log(`——————————————————————————————————————————————————————————————————————————————————————`);
+        console.log(`\n\n`);
+    }
+    async userExecutedMongoCommand() {
+        if (!this.config.installMongo)
+            return;
+        const prompt = new Input({
+            message: ` Type 'done' once above commands executed in separate terminal`,
+            initial: '',
+            validate: (userInput) => {
+                userInput = userInput.trim().toUpperCase();
+                if (userInput !== 'DONE')
+                    return `Please type 'done' once you execute above commands in separate terminal.`;
+                return true;
+            },
+        });
+        return await prompt.run();
+    }
+    async installOracleClient() {
+        if (fs.existsSync(`/opt/oracle/instantclient/ojdbc8.jar`)) {
+            console.log(`👍  Oracle Client Exists`);
+            return;
+        }
+        this.showLoading('Oracle Client Installing...');
+        await this.runCommandSilent([
+            `apt-get -yq install unzip`,
+            `apt-get -yq install make`,
+            ``,
+            `# Install oracledb prerequisites`,
+            `rm -rf /opt/oracle`,
+            `mkdir -p /opt/oracle`,
+            `cd /opt/oracle`,
+            `wget -q https://images.apimaker.dev/prod/am-cloud/binaries/oracle-clients/21.8.0/instantclient-basic-linuxx64.zip`,
+            `unzip instantclient-basic-linuxx64.zip`,
+            `apt-get install -y libaio1=0.3.112-13build1`,
+            `sh -c "echo /opt/oracle/instantclient > /etc/ld.so.conf.d/oracle-instantclient.conf"`,
+            `ldconfig`,
+        ].join('\n'), '/');
+        this.hideLoading();
+        console.log(`✅  Oracle Client Installed`);
+    }
+    // <editor-fold desc="Write .env file">
+    async getAPIMakerUserInputs() {
+        // Stop AM BE process if exists
+        try {
+            await this.runCommandSilent(`pm2 delete api_maker_be`, '/');
+        }
+        catch (e) {
+        }
+        if (!isDefaultInstallation)
+            console.log(`———— #API Maker Section ———`);
+        this.am.port = await this.getAPIMakerBackendPort();
+        this.am.wsPort = await this.getAPIMakerWSPort();
+        this.am.passCommunication = await this.getPassCommunication();
+        this.am.passJWT = await this.getPassJWT();
+        this.am.passDBEncryptDecrypt = await this.getPassDBEncryptDecrypt();
+        if (this.config.installType === EInstallationType.SECONDARY) {
+            this.am.secondary.serverName = await this.getSecondaryServerName();
+            this.am.secondary.connectionStrings.mongodb = await this.getSecondaryMongoDBConnectionString();
+            this.am.secondary.connectionStrings.redisInternal = await this.getSecondaryRedisInternalConnectionString();
+            this.am.secondary.connectionStrings.redisExternal = await this.getSecondaryRedisExternalConnectionString();
+        }
+        if (!isDefaultInstallation)
+            console.log(`——————————————————————————`);
+    }
+    async calculateMongoAndRedisConnectionStrings() {
+        let mongoDBConnectionString;
+        let redisConnectionStringInternal;
+        let redisConnectionStringExternal;
+        if (this.config.installMongo) {
+            mongoDBConnectionString = `mongodb://${this.mongo.username}:${this.mongo.password}@127.0.0.1:${this.mongo.port}/api_maker_db?authSource=admin&replicaSet=rs0&directConnection=true`;
+        }
+        else
+            mongoDBConnectionString = this.envFileD[EInstallEnv.am__mongo_db_connection];
+        if (this.config.installRedis) {
+            redisConnectionStringInternal = `{"nodes": [{port:${this.redis.port}, host:"127.0.0.1", pass: "${this.redis.password}"}]}`;
+            redisConnectionStringExternal = `{"nodes": [{port:${this.redis.port}, host:"127.0.0.1", pass: "${this.redis.password}"}], redisValueExpireInSeconds: 7200, maxCharsResToCache: 1000000}`;
+        }
+        else {
+            redisConnectionStringInternal = this.envFileD[EInstallEnv.am__redisInternal];
+            redisConnectionStringExternal = this.envFileD[EInstallEnv.am__redisExternal];
+        }
+        return {
+            mongoDBConnectionString,
+            redisConnectionStringInternal,
+            redisConnectionStringExternal,
+        };
+    }
+    async writeEnvFileInConfigDirectory(serverName, mongoDBConnectionString, redisConnectionStringInternal, redisConnectionStringExternal) {
+        const BE_HOST_PORT = this.config.installSSL ? `https://${this.config.beHost}` : `http://${this.config.IP}:${this.am.port}`;
+        const envFilePath = path.join(this.HOME, 'config', '.env');
+        let fullExternalString = ``;
+        if (redisConnectionStringExternal)
+            fullExternalString = `am__redisExternal='${redisConnectionStringExternal}'`;
+        await fs.promises.writeFile(envFilePath, [
+            `# You can set environment variables in this file to override package.json "am" object values.`,
+            `# Docs Link : https://www.npmjs.com/package/dotenv/v/16.0.3`,
+            ``,
+            `# Do not remove below environment variables.`,
+            `NODE_PRESERVE_SYMLINKS=1`,
+            `NODE_ENV=production`,
+            ``,
+            `# API Maker admin panel frontend will try to connect to backend on this host and "am__port" will be appended automatically.`,
+            `BE_HOST_PORT="${BE_HOST_PORT}" # 👈 http://127.0.0.1:38246 or https://example.com`,
+            ``,
+            `# Required environment variables. You can set them in package.json also and remove from here.`,
+            `am__serverName=${serverName} # To go inside the object in package.json am, you can use "__" double underscore.`,
+            `am__processTitle=api_maker_be`,
+            `am__port=${this.am.portOriginal}`,
+            `am__wsPort=${this.am.portOriginalWS}`,
+            `am__cpuCount=AUTO`,
+            `am__mongo_db_connection="${mongoDBConnectionString}"`,
+            `am__redisInternal='${redisConnectionStringInternal}'`,
+            `${fullExternalString}`,
+            `am__passCommunication="${this.am.passCommunication}"`,
+            `am__passJWT="${this.am.passJWT}"`,
+            `am__passDBEncryptDecrypt="${this.am.passDBEncryptDecrypt}" # 👈 Set this random of 32 characters, it is used to encrypt/decrypt database & repository data.`,
+            ``,
+        ].join('\n'), { encoding: 'utf8' });
+        console.log(`✅  Env file written to ${envFilePath}`);
+    }
+    async getAPIMakerBackendPort() {
+        const defaultAMBEPort = 8080;
+        const prompt = new NumberPrompt({
+            message: ' Please enter port number to run API Maker backend service',
+            initial: defaultAMBEPort,
+            validate: async (userInput) => {
+                if (userInput < 2000)
+                    return 'Port should be greater than 2000-60000';
+                else if (userInput > 60000)
+                    return 'Port should be between 2000-60000';
+                else if (this.mongo.port === userInput)
+                    return 'It should not be same as MongoDB port.';
+                else if (this.redis.port === userInput)
+                    return 'It should not be same as Redis port.';
+                const isPortFree = await this.isGivenPortFree(userInput);
+                if (isPortFree)
+                    return true;
+                else
+                    return `Port ${userInput} is not free.`;
+            },
+        });
+        return isDefaultInstallation ? defaultAMBEPort : await prompt.run();
+    }
+    async getAPIMakerWSPort() {
+        const defaultWSPort = 8081;
+        const prompt = new NumberPrompt({
+            message: ' Please enter port number to run API Maker backend WebSocket service',
+            initial: defaultWSPort,
+            validate: async (userInput) => {
+                if (userInput < 2000)
+                    return 'Port should be greater than 2000-60000';
+                else if (userInput > 60000)
+                    return 'Port should be between 2000-60000';
+                else if (this.mongo.port === userInput)
+                    return 'It should not be same as MongoDB port.';
+                else if (this.redis.port === userInput)
+                    return 'It should not be same as Redis port.';
+                else if (this.am.port === userInput || this.am.portOriginal === userInput || this.am.portOriginalWS === userInput)
+                    return 'It should not be same as API Maker backend service port.';
+                const isPortFree = await this.isGivenPortFree(userInput);
+                if (isPortFree)
+                    return true;
+                else
+                    return `Port ${userInput} is not free.`;
+            },
+        });
+        return isDefaultInstallation ? defaultWSPort : await prompt.run();
+    }
+    async getPassCommunication() {
+        let passCommunication;
+        let appendText = '';
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            passCommunication = this.envFileD[EInstallEnv.am__passCommunication] || this.getRandomString(20);
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            passCommunication = this.envFileD[EInstallEnv.am__passCommunication];
+            appendText = ' (Use value of primary server)';
+        }
+        const prompt = new Input({
+            message: ` Please provide passCommunication${appendText}`,
+            initial: passCommunication,
+            validate: (userInput) => {
+                if (userInput.length < 20)
+                    return 'Minimum length should be 20';
+                if (this.isAlphaNumericalValidPass(userInput))
+                    return true;
+                return 'Password can only contain [a-z, A-Z, 0-9, _], special characters creates issue in setup automation process.';
+            },
+        });
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            return isDefaultInstallation ? passCommunication : await prompt.run();
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            return await prompt.run();
+        }
+    }
+    async getPassJWT() {
+        let passJWT;
+        let appendText = '';
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            passJWT = this.envFileD[EInstallEnv.am__passJWT] || this.getRandomString(20);
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            passJWT = this.envFileD[EInstallEnv.am__passJWT];
+            appendText = ' (Use value of primary server)';
+        }
+        const prompt = new Input({
+            message: ` Please provide passJWT${appendText}`,
+            initial: passJWT,
+            validate: (userInput) => {
+                if (userInput.length < 20)
+                    return 'Minimum length should be 20';
+                if (this.isAlphaNumericalValidPass(userInput))
+                    return true;
+                return 'Password can only contain [a-z, A-Z, 0-9, _], special characters creates issue in setup automation process.';
+            },
+        });
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            return isDefaultInstallation ? passJWT : await prompt.run();
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            return await prompt.run();
+        }
+    }
+    async getPassDBEncryptDecrypt() {
+        let passDB;
+        let appendText = '';
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            passDB = this.envFileD[EInstallEnv.am__passDBEncryptDecrypt] || this.getRandomString(32);
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            passDB = this.envFileD[EInstallEnv.am__passDBEncryptDecrypt];
+            appendText = ' (Use value of primary server)';
+        }
+        const prompt = new Input({
+            message: ` Please provide passDBEncryptDecrypt 32 chars${appendText}`,
+            initial: passDB,
+            validate: (userInput) => {
+                if (userInput.length !== 32)
+                    return 'Length should be 32 characters';
+                if (this.isAlphaNumericalValidPass(userInput))
+                    return true;
+                return 'Password can only contain [a-z, A-Z, 0-9, _], special characters creates issue in setup automation process.';
+            },
+        });
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            return isDefaultInstallation ? passDB : await prompt.run();
+        }
+        else if (this.config.installType === EInstallationType.SECONDARY) {
+            return await prompt.run();
+        }
+    }
+    async getSecondaryServerName() {
+        const serverName = this.envFileD[EInstallEnv.am__serverName];
+        const prompt = new Input({
+            message: ` Please provide secondary server name`,
+            initial: serverName || 'Secondary_1',
+            validate: (userInput) => {
+                if (!userInput || userInput.length < 2)
+                    return 'Please provide valid server name.';
+                return true;
+            },
+        });
+        return isDefaultInstallation ? serverName : await prompt.run();
+    }
+    async getSecondaryMongoDBConnectionString() {
+        const mongoConnectionString = this.envFileD[EInstallEnv.am__mongo_db_connection];
+        const prompt = new Input({
+            message: ` Please provide API Maker's mongodb connection string`,
+            initial: mongoConnectionString,
+            validate: async (userInput) => {
+                return await this.validateMongoDBConnectionString(userInput);
+            },
+        });
+        return isDefaultInstallation ? mongoConnectionString : await prompt.run();
+    }
+    async getSecondaryRedisInternalConnectionString() {
+        const internalRedisConnectionString = this.envFileD[EInstallEnv.am__redisInternal];
+        const prompt = new Input({
+            message: ` Please provide API Maker's internal redis connection string`,
+            initial: internalRedisConnectionString,
+            validate: async (userInput) => {
+                return await this.canConnectToRedis(userInput);
+            },
+        });
+        return isDefaultInstallation ? internalRedisConnectionString : await prompt.run();
+    }
+    async getSecondaryRedisExternalConnectionString() {
+        const internalRedisConnectionString = this.envFileD[EInstallEnv.am__redisExternal];
+        const prompt = new Input({
+            message: ` Please provide External redis connection string (Optional)`,
+            initial: internalRedisConnectionString,
+            validate: async (userInput) => {
+                return await this.canConnectToRedis(userInput);
+            },
+        });
+        return isDefaultInstallation ? internalRedisConnectionString : await prompt.run();
+    }
+    // </editor-fold>
+    async syncEnvDataInFrontend() {
+        await globalData.SetEnvInFrontend.main(globalData.appRoot, path.join(this.HOME, 'config', '.env'));
+    }
+    async startAPIMakerBackendProcess() {
+        this.showLoading('Starting API Maker backend...');
+        const nodeProcessSizeShouldBe = this.getNodejsMaxOldSpaceValue();
+        // Start command duplicate // Stop command duplicate
+        this.config.stopAMCommand = `${this.NODE_HOME}/pm2 delete api_maker_be`;
+        this.config.startAMCommand = `cd ${globalData.appRoot} && export PATH=${this.NODE_HOME}:/opt/oracle/instantclient:$PATH && ${this.NODE_HOME}/pm2 -a start main.js --node-args="--max-old-space-size=${nodeProcessSizeShouldBe}" --name api_maker_be --log "${this.HOME}/logs/api_maker_be.txt" --log-date-format 'DD-MM-YYYY HH:mm:ss Z' -- --envPath=${this.HOME}/config/.env`;
+        await this.runCommandSilent([
+            `cd ${globalData.appRoot}`,
+            `${this.NODE_HOME}/pm2 kill`,
+            `rm -rf ${this.HOME}/.pm2`,
+            `${this.NODE_HOME}/pm2 --version || ${this.NODE_HOME}/npm install -g pm2@5.3.0`,
+            `export PATH=${this.NODE_HOME}:/opt/oracle/instantclient:$PATH`,
+            this.config.stopAMCommand,
+            `rm -rf ${this.HOME}/logs/api_maker_be.txt`,
+            this.config.startAMCommand,
+        ].join('\n'), '/');
+        this.hideLoading();
+        console.log(`🚀  API Maker backend process started.`);
+    }
+    async isPort80Free() {
+        const isPort80FreeOut = await this.isGivenPortFree(80);
+        if (isPort80FreeOut)
+            console.log(`✅  Port 80 is available.`);
+        else {
+            try {
+                await this.runCommandSilent(`caddy version`, '/');
+                await this.stopCaddy(false);
+            }
+            catch (e) {
+            }
+            const isPort80FreeOutTemp = await this.isGivenPortFree(80);
+            if (!isPort80FreeOutTemp)
+                throw new Error(`❌ Port 80 is not free.`);
+            else
+                console.log(`✅  Port 80 is available.`);
+        }
+    }
+    async installCaddyIfNotInstalled() {
+        try {
+            const caddyVersionOutput = await this.runCommandSilent(`caddy version`, '/');
+            console.log(`✅  ${caddyVersionOutput.trim()}`);
+        }
+        catch (e) {
+            this.showLoading('Installing Caddy...');
+            await this.runCommandSilent([
+                `apt-get install -y debian-keyring=2021.12.24`,
+                `apt-get install -y debian-archive-keyring=2021.1.1ubuntu2`,
+                `apt-get install -y apt-transport-https=2.4.8`,
+                ``,
+                `curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor --batch --yes -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg`,
+                `curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list`,
+                `apt update -yq`,
+                ``,
+                `apt-get install -y caddy=2.6.4`,
+            ].join('\n'), '/');
+            this.hideLoading();
+            console.log(`✅  Caddy installed`);
+        }
+    }
+    calculateURLs() {
+        // They are used to print at the end.
+        if (this.config.installSSL) {
+            this.config.fullUrlOfBE = `https://${this.config.beHost}`;
+            this.config.fullUrlOfWS = `https://${this.config.beWSHost}`;
+        }
+        else {
+            this.config.fullUrlOfBE = `http://${this.config.IP}:${this.am.port}`;
+            this.config.fullUrlOfWS = `http://${this.config.IP}:${this.am.wsPort}`;
+        }
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            if (this.config.installSSL)
+                this.config.fullUrlOfFE = `https://${this.config.feHost}`;
+            else
+                this.config.fullUrlOfFE = `http://${this.config.IP}:80`;
+        }
+    }
+    /**
+     * Installation process overrides Caddyfile.
+     *
+     * Get JSON from caddyfile using below tool
+     * https://caddapto.vercel.app/
+     *
+     * caddy adapt —config Caddyfile —adapter Caddyfile
+     *  -- It will print JSON output of Caddyfile.
+     *  caddy adapt --config /path/to/Caddyfile --pretty
+     *
+     */
+    async writeCaddyFile() {
+        const caddyFilePath = path.join(this.HOME, 'config', this.CADDY_FILE_NAME);
+        let feSection = [];
+        const secondaryBackends = await this.getExistingSecondaryServers(this.am.portOriginal);
+        const secondaryBackendsWS = await this.getExistingSecondaryServers(this.am.portOriginalWS);
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            feSection = [
+                `${this.config.fullUrlOfFE} {`,
+                `    root * ${globalData.appRoot}/dist`,
+                `    file_server`,
+                `    encode zstd gzip`,
+                `    try_files {path} /`,
+                `}`,
+            ];
+        }
+        await fs.promises.writeFile(caddyFilePath, [
+            ``,
+            `{`,
+            `    # Disable admin API`,
+            `    admin off`,
+            ``,
+            `    log {`,
+            `        level ERROR`,
+            `        output discard`,
+            `    }`,
+            `}`,
+            ``,
+            `${this.config.fullUrlOfBE} {`,
+            `    reverse_proxy 127.0.0.1:${this.am.portOriginal} ${secondaryBackends}`,
+            `}`,
+            ``,
+            `${this.config.fullUrlOfWS} {`,
+            `    reverse_proxy 127.0.0.1:${this.am.portOriginalWS} ${secondaryBackendsWS}`,
+            `}`,
+            ``,
+            ...feSection,
+            ``,
+            ``,
+        ].join('\n'), { encoding: 'utf8' });
+        console.log(`    ✔ [Write] : ${caddyFilePath}`);
+        if (secondaryBackends)
+            console.log(`        ✔ [Secondary Servers BE] : ${secondaryBackends}`);
+        if (secondaryBackends)
+            console.log(`        ✔ [Secondary Servers WS] : ${secondaryBackendsWS}`);
+    }
+    async getExistingSecondaryServers(port) {
+        const caddyFilePath = path.join(this.HOME, 'config', this.CADDY_FILE_NAME);
+        let secondaryServers = '';
+        const reverseProxyLine = `reverse_proxy 127.0.0.1:${port}`;
+        if (fs.existsSync(caddyFilePath)) {
+            const content = fs.readFileSync(caddyFilePath, { encoding: 'utf8' });
+            const lines = content.split('\n');
+            for (const line of lines) {
+                if (line.indexOf(reverseProxyLine) >= 0) {
+                    secondaryServers = line.replace(reverseProxyLine, '').trim();
+                }
+            }
+        }
+        return secondaryServers;
+    }
+    async restartCaddy() {
+        const caddyConfigPath = path.join(this.HOME, 'config', this.CADDY_FILE_NAME);
+        await this.stopCaddy(false);
+        // caddy run --config caddyfile.json // this is working fine for json file no need to pass jsonc adapter.
+        this.runCommandSilent([
+            `/usr/bin/caddy start --config ${caddyConfigPath}`,
+        ].join('\n'), '/').then();
+        console.log(`✅  ${caddyConfigPath}`);
+    }
+    async stopCaddy(printStopLog) {
+        try {
+            await this.runCommandSilent([
+                `/usr/bin/caddy stop > /dev/null`,
+                `/usr/bin/systemctl stop caddy > /dev/null`,
+                `pkill caddy`,
+            ].join('\n'), '/');
+            await this.sleep(2000);
+            if (printStopLog)
+                console.log(`✅  Caddy service stopped and ports released.`);
+        }
+        catch (e) {
+        }
+    }
+    async startPM2ProcessOnRestart() {
+        await this.runCommandSilent([
+            `export PATH=${this.NODE_HOME}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin`,
+            `${this.NODE_HOME}/pm2 startup`,
+            `systemctl enable pm2-root`,
+            `${this.NODE_HOME}/pm2 save`,
+        ].join('\n'), '/');
+    }
+    async printPM2ProcessList() {
+        const pm2List = await this.runCommandSilent([
+            `${this.NODE_HOME}/pm2 list`,
+        ].join('\n'), '/');
+        console.log('');
+        console.log(pm2List);
+    }
+    printAllSetupConfigurations() {
+        console.log('\n');
+        console.log(colors.cyan(`———— # Setup Configurations (Saved in ${this.HOME}/config/.env file) ————`));
+        let onlyPrimaryFields = {};
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            onlyPrimaryFields = {
+                'MongoDB Port': this.mongo.port,
+                'MongoDB Username': this.mongo.username,
+                'MongoDB Password': this.mongo.password,
+                'Redis Port': this.redis.port,
+                'Redis Password': this.redis.password,
+                'AM Frontend Port': this.config.installSSL ? '443' : '80',
+            };
+        }
+        console.table({
+            'Installation Directory': globalData.appRoot,
+            'Config Directory': `${this.HOME}/config`,
+            'Logs Directory': `${this.HOME}/logs`,
+            'Docker Data Directory': `${this.HOME}/docker-data`,
+            '—————————————————————————————': `—————————————————————————————`,
+            IP: this.config.IP,
+            ...onlyPrimaryFields,
+            'AM Port': this.am.port,
+            'AM WebSocket Port': this.am.wsPort,
+            'Pass Communication': this.am.passCommunication,
+            'Password JWT': this.am.passJWT,
+            'Password DB Encrypt Decrypt': this.am.passDBEncryptDecrypt,
+        });
+    }
+    printEndpointSummary() {
+        console.log('');
+        console.log(colors.cyan('———— # Important URLs ————'));
+        const parsedUrl = new URL(this.config.fullUrlOfWS);
+        let onlyPrimaryFields = {};
+        if (this.config.installType === EInstallationType.PRIMARY) {
+            onlyPrimaryFields = {
+                'Frontend Admin Panel': this.config.fullUrlOfFE,
+            };
+        }
+        console.table({
+            ...onlyPrimaryFields,
+            'Backend APIs': this.config.fullUrlOfBE,
+            'Backend WebSocket endpoint': this.config.installSSL ? `wss://${parsedUrl.hostname}` : `ws://${parsedUrl.hostname}:${this.am.wsPort}`,
+        });
+    }
+    printDefaultUsers() {
+        console.log('\n');
+        console.log(colors.cyan('———— # Default User Credentials ————'));
+        console.table({
+            'root@root.com': `R00t_123456789`,
+            'admin@admin.com': `Admin_123456789`,
+        });
+    }
+    printStartAndStopCommands() {
+        console.log('\n');
+        console.log(colors.cyan('———— # Commands to start/stop API Maker processes ————'));
+        console.log('————————————————————————————————————————————————————————————————');
+        console.log(`[START] : ${this.config.startAMCommand}`);
+        console.log('');
+        console.log(`[STOP] : ${this.config.stopAMCommand}`);
+        console.log('————————————————————————————————————————————————————————————————');
+    }
+    printSecondaryServerAttachInformation() {
+        let beHostPort, wsHostPort;
+        if (this.config.installSSL) {
+            beHostPort = `${this.config.beHost}:${this.am.portOriginal}`;
+            wsHostPort = `${this.config.beWSHost}:${this.am.portOriginalWS}`;
+        }
+        else {
+            beHostPort = `${this.config.IP}:${this.am.portOriginal}`;
+            wsHostPort = `${this.config.IP}:${this.am.portOriginalWS}`;
+        }
+        const caddyConfigPath = path.join(this.HOME, 'config', this.CADDY_FILE_NAME);
+        const caddyStartCommand = `/usr/bin/caddy start --config ${caddyConfigPath}`;
+        const caddyStartCommandForeground = `/usr/bin/caddy run --config ${caddyConfigPath}`;
+        console.log('\n');
+        console.log(colors.red('———— # Attach secondary server to primary server ————'));
+        console.log('————————————————————————————————————————————————————————————————');
+        console.log(`👉  You can directly hit APIs of this secondary server.`);
+        console.log(`    Although if you want to keep one endpoint for all APIs, modify one line in "~/config/Caddyfile" of primary server as below.`);
+        console.log(`[CHANGE] : "reverse_proxy 127.0.0.1:38246" -> "reverse_proxy 127.0.0.1:38246 __all_secondary_servers_list__"`);
+        console.log(`[CHANGE] : "reverse_proxy 127.0.0.1:38245" -> "reverse_proxy 127.0.0.1:38245 __all_secondary_servers_ws_list__"`);
+        console.log(colors.yellow(`———————————— Example ————————————`));
+        console.log(`[Ex 1] : "reverse_proxy 127.0.0.1:38246" -> "reverse_proxy 127.0.0.1:38246 ${beHostPort} example1.com:38246 172.105.48.196:38246"`);
+        console.log(`[Ex 2] : "reverse_proxy 127.0.0.1:38245" -> "reverse_proxy 127.0.0.1:38245 ${wsHostPort} example1.com:38245 172.105.48.196:38245"`);
+        console.log(colors.yellow(`———————————— Caddy stop & start commands to run in primary server ————————————`));
+        console.log(`# Caddy server stop commands `);
+        console.log(`/usr/bin/caddy stop > /dev/null`);
+        console.log(`/usr/bin/systemctl stop caddy > /dev/null`);
+        console.log(`pkill caddy`);
+        console.log(`# Caddy server start commands`);
+        console.log(`${caddyStartCommand}`);
+        console.log(`# ${caddyStartCommandForeground}`);
+        console.log('————————————————————————————————————————————————————————————————');
+    }
+    // <editor-fold desc="Utility Functions">
+    showLoading(text) {
+        this.load = loading(colors.green(` ${text}`)).start();
+    }
+    hideLoading() {
+        this.load.stop();
+    }
+    runCommandSilent(runCommand, workingDir) {
+        return new Promise((resolve, reject) => {
+            if (runCommand) {
+                const options = {};
+                if (workingDir)
+                    options.cwd = workingDir;
+                child_process.exec(runCommand, options, (error, stdout, stderr) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else if (stderr) {
+                        resolve(undefined);
+                    }
+                    else {
+                        resolve(stdout);
+                    }
+                });
+            }
+            else
+                resolve(undefined);
+        });
+    }
+    async download(url) {
+        const response = await fetch(url);
+        return response.text();
+    }
+    ;
+    getRandomString(size) {
+        let result = '';
+        const charactersLength = this.characters.length;
+        for (let i = 0; i < size; i++)
+            result += this.characters.charAt(Math.floor(Math.random() * charactersLength));
+        return result;
+    }
+    isAlphaNumericalValidPass(userInput) {
+        const strRegex = /^[a-z0-9_A-Z]+$/i;
+        return strRegex.test(userInput);
+    }
+    isValidIpAddress(ipaddress) {
+        return /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ipaddress);
+    }
+    isGivenPortFree(port) {
+        return new Promise((resolve) => {
+            const net = require('net');
+            const server = net.createServer();
+            server.once('error', function () {
+                resolve(false);
+            });
+            server.once('listening', function () {
+                server.close();
+                resolve(true);
+            });
+            server.listen(port);
+        });
+    }
+    async getValidHostFromUser(userInput) {
+        if (this.isValidIpAddress(userInput))
+            return 'Host should not be IP address. It should be domain name.';
+        if (userInput.startsWith('https')) {
+            const urlTemp = new URL(userInput);
+            return `Please provide domain name without protocol. ex: ${urlTemp.hostname}`;
+        }
+        const pingError = `"ping -c 1 ${userInput}" should point to this "${this.config.IP}" IP address.`;
+        try {
+            const pingOutput = await this.runCommandSilent(`ping -c 1 ${userInput}`, '/');
+            if (pingOutput.indexOf(this.config.IP) >= 0)
+                return true;
+            else
+                return pingError;
+        }
+        catch (e) {
+            return pingError;
+        }
+    }
+    async sleep(millis) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, millis);
+        });
+    }
+    /**
+     * MB = bytes/(1024 * 1024)
+     * Get value in MB
+     */
+    getNodejsMaxOldSpaceValue() {
+        const cpuCount = os.cpus().length;
+        const memory = os.totalmem(); // It is multiplied by 1024.
+        const memoryForOneCpu = Math.ceil(memory / cpuCount);
+        const calculatedValue = Math.ceil(((75 * memoryForOneCpu) / 100) / (1024 * 1024));
+        if (calculatedValue <= 800)
+            return 1024;
+        else
+            return calculatedValue;
+    }
+    async validateMongoDBConnectionString(connString) {
+        try {
+            const client = await mongodb.MongoClient.connect(connString, {});
+            return true;
+        }
+        catch (e) {
+            return e.message; // It is working fine with address not found error.
+        }
+    }
+    // Duplicate : canConnectToRedis
+    canConnectToRedis(connString) {
+        const connectionObj = JSON5.parse(connString);
+        return new Promise((resolve) => {
+            let resolved = false;
+            const tempResolve = (value) => {
+                if (resolved)
+                    return;
+                else {
+                    resolved = true;
+                    resolve(value);
+                }
+            };
+            try {
+                let redisConnection;
+                if (connectionObj.nodes?.length > 1) {
+                    const commonClusterOptions = { clusterRetryStrategy: this.getRetryStrategySilent };
+                    redisConnection = new ioredis_1.default.Cluster(connectionObj.nodes, {
+                        enableOfflineQueue: false,
+                        enableReadyCheck: false,
+                        ...commonClusterOptions,
+                    });
+                }
+                else if (connectionObj.nodes?.length === 1) {
+                    redisConnection = new ioredis_1.default({
+                        port: connectionObj?.nodes?.[0]?.port,
+                        host: connectionObj?.nodes?.[0]?.host,
+                        password: connectionObj?.nodes?.[0]?.pass,
+                        autoResendUnfulfilledCommands: false,
+                        retryStrategy: this.getRetryStrategy,
+                        reconnectOnError() {
+                            return false;
+                        },
+                        enableReadyCheck: false,
+                    });
+                }
+                else
+                    tempResolve('Invalid details provided for redis connection.');
+                redisConnection.on('error', (e) => {
+                    tempResolve(e.message);
+                    this.closeRedisConnection(redisConnection);
+                });
+                redisConnection.on('connect', (input) => {
+                    if (connectionObj?.nodes?.[0]?.pass) {
+                        redisConnection.auth(connectionObj?.nodes?.[0]?.pass, (err, res) => {
+                            if (err) {
+                                tempResolve(err.message);
+                                this.closeRedisConnection(redisConnection);
+                            }
+                            else {
+                                tempResolve(true);
+                                this.closeRedisConnection(redisConnection);
+                            }
+                        });
+                    }
+                    else {
+                        tempResolve(true);
+                        this.closeRedisConnection(redisConnection);
+                    }
+                });
+            }
+            catch (e) {
+                tempResolve(e.message);
+            }
+        });
+    }
+    // Duplicate : canConnectToRedis
+    closeRedisConnection(redisConn) {
+        try {
+            redisConn.quit();
+            redisConn.disconnect();
+            redisConn.removeAllListeners('error');
+            redisConn.removeAllListeners('connect');
+        }
+        catch (e) {
+        }
+    }
+    // Duplicate : canConnectToRedis
+    getRetryStrategy(times) {
+        console.log(`[${new Date().toISOString()}] Redis retry attempt ${times}`);
+        return 5000;
+    }
+    // Duplicate : canConnectToRedis
+    getRetryStrategySilent(times) {
+        return 5000;
+    }
+    testEmojiWidth() {
+        console.log(`✴️  Disk size is not good enough`);
+        console.log(`✅  Disk size is good enoug`);
+        console.log(`❌  Please provide root user.`);
+        console.log(`☑️  Redis install skipped. Old connection st`);
+        console.log(`👍  Redis install skipped. Old connection st`);
+        console.log(`⚠️  [Ubuntu 22 | Ubuntu 20 | Ubuntu 23] not found, but you can try.`);
+        console.log(`👉  If docker installation fails, try installing docker manually and try again.`);
+        console.log(`🟦  Default Installation selected`);
+        console.log(`🚀  API Maker backend process started.`);
+        console.log('❤️  Thank you for using API Maker, Enjoy !! ❤️');
+        console.log(`🖇️  Secondary server installation type.`);
+    }
+}
+var EInstallEnv;
+(function (EInstallEnv) {
+    EInstallEnv["am__serverName"] = "am__serverName";
+    EInstallEnv["am__mongo_db_connection"] = "am__mongo_db_connection";
+    EInstallEnv["am__redisInternal"] = "am__redisInternal";
+    EInstallEnv["am__redisExternal"] = "am__redisExternal";
+    EInstallEnv["am__passCommunication"] = "am__passCommunication";
+    EInstallEnv["am__passJWT"] = "am__passJWT";
+    EInstallEnv["am__passDBEncryptDecrypt"] = "am__passDBEncryptDecrypt";
+    // Do not use below because user inputs are in Caddyfile, and we are not reading that.
+    // am__port = 'am__port',
+    // am__wsPort = 'am__wsPort',
+})(EInstallEnv || (EInstallEnv = {}));
+var EInstallationType;
+(function (EInstallationType) {
+    EInstallationType["PRIMARY"] = "PRIMARY";
+    EInstallationType["SECONDARY"] = "SECONDARY";
+})(EInstallationType || (EInstallationType = {}));
+(new InstallFromWeb()).main().then();