vpn-split 18.0.19 → 18.0.21

package/lib/vpn-split.backend.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VpnSplit = void 0;
-var tslib_1 = require("tslib");
 //#region imports
-var tnp_core_1 = require("tnp-core");
-var express = require("express");
-var httpProxy = require("http-proxy");
-var tnp_helpers_1 = require("tnp-helpers");
-var tnp_config_1 = require("tnp-config");
-var hostile_backend_1 = require("./hostile.backend");
-var models_1 = require("./models");
-var axios_1 = require("axios");
-var ng2_logger_1 = require("ng2-logger");
-var crypto = require("crypto");
-var dgram = require("dgram"); // <-- For UDP sockets
-var log = ng2_logger_1.Log.create('vpn-split', ng2_logger_1.Level.INFO);
+const tnp_core_1 = require("tnp-core");
+const http = require("http");
+const express = require("express");
+const httpProxy = require("http-proxy");
+const tnp_helpers_1 = require("tnp-helpers");
+const tnp_config_1 = require("tnp-config");
+const hostile_backend_1 = require("./hostile.backend");
+const models_1 = require("./models");
+const axios_1 = require("axios");
+const ng2_logger_1 = require("ng2-logger");
+const crypto = require("crypto");
+const dgram = require("dgram"); // <-- For UDP sockets
+const log = ng2_logger_1.Log.create('vpn-split', ng2_logger_1.Level.INFO);
 //#endregion
 //#region consts
-var GENERATED = '#GENERATED_BY_CLI#';
-var EOL = process.platform === 'win32' ? '\r\n' : '\n';
-var SERVERS_PATH = '/$$$$servers$$$$';
-var HOST_FILE_PATHUSER = (0, tnp_core_1.crossPlatformPath)([
+const GENERATED = '#GENERATED_BY_CLI#';
+const EOL = process.platform === 'win32' ? '\r\n' : '\n';
+const SERVERS_PATH = '/$$$$servers$$$$';
+const HOST_FILE_PATHUSER = (0, tnp_core_1.crossPlatformPath)([
     tnp_core_1.os.userInfo().homedir,
     'hosts-file__vpn-split',
 ]);
-var from = models_1.HostForServer.From;
-var defaultHosts = {
+const from = models_1.HostForServer.From;
+const defaultHosts = {
     'localhost alias': from({
         ipOrDomain: '127.0.0.1',
         aliases: 'localhost',
@@ -43,369 +43,175 @@ var defaultHosts = {
     }),
 };
 //#endregion
-var VpnSplit = /** @class */ (function () {
-    function VpnSplit(portsToPass, hosts, cwd) {
+class VpnSplit {
+    portsToPass;
+    hosts;
+    cwd;
+    //#region getters
+    get hostsArr() {
+        const hosts = this.hosts;
+        return tnp_core_1._.keys(hosts).map(hostName => {
+            const v = hosts[hostName];
+            v.name = hostName;
+            return v;
+        });
+    }
+    get hostsArrWithoutDefault() {
+        return this.hostsArr.filter(f => !f.isDefault);
+    }
+    get serveKeyName() {
+        return 'tmp-' + tnp_config_1.config.file.server_key;
+    }
+    get serveKeyPath() {
+        return tnp_core_1.path.join(this.cwd, this.serveKeyName);
+    }
+    get serveCertName() {
+        return 'tmp-' + tnp_config_1.config.file.server_cert;
+    }
+    get serveCertPath() {
+        return tnp_core_1.path.join(this.cwd, this.serveCertName);
+    }
+    get serveCertChainName() {
+        return 'tmp-' + tnp_config_1.config.file.server_chain_cert;
+    }
+    get serveCertChainPath() {
+        return tnp_core_1.path.join(this.cwd, this.serveCertChainName);
+    }
+    //#endregion
+    //#region fields
+    __hostile;
+    //#endregion
+    //#region singleton
+    static _instances = {};
+    constructor(portsToPass, hosts, cwd) {
         this.portsToPass = portsToPass;
         this.hosts = hosts;
         this.cwd = cwd;
         this.__hostile = new hostile_backend_1.Hostile();
     }
-    Object.defineProperty(VpnSplit.prototype, "hostsArr", {
-        //#region getters
-        get: function () {
-            var hosts = this.hosts;
-            return tnp_core_1._.keys(hosts).map(function (hostName) {
-                var v = hosts[hostName];
-                v.name = hostName;
-                return v;
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "hostsArrWithoutDefault", {
-        get: function () {
-            return this.hostsArr.filter(function (f) { return !f.isDefault; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveKeyName", {
-        get: function () {
-            return 'tmp-' + tnp_config_1.config.file.server_key;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveKeyPath", {
-        get: function () {
-            return tnp_core_1.path.join(this.cwd, this.serveKeyName);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveCertName", {
-        get: function () {
-            return 'tmp-' + tnp_config_1.config.file.server_cert;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveCertPath", {
-        get: function () {
-            return tnp_core_1.path.join(this.cwd, this.serveCertName);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveCertChainName", {
-        get: function () {
-            return 'tmp-' + tnp_config_1.config.file.server_chain_cert;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VpnSplit.prototype, "serveCertChainPath", {
-        get: function () {
-            return tnp_core_1.path.join(this.cwd, this.serveCertChainName);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    VpnSplit.Instance = function () {
-        return tslib_1.__awaiter(this, arguments, void 0, function (_a) {
-            var _b = _a === void 0 ? {} : _a, _c = _b.ports, ports = _c === void 0 ? [80, 443, 4443, 22, 2222, 8180, 8080, 4407, 7999, 9443] : _c, _d = _b.additionalDefaultHosts, additionalDefaultHosts = _d === void 0 ? {} : _d, _e = _b.cwd, cwd = _e === void 0 ? process.cwd() : _e, _f = _b.allowNotSudo, allowNotSudo = _f === void 0 ? false : _f;
-            return tslib_1.__generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0: return [4 /*yield*/, (0, tnp_core_1.isElevated)()];
-                    case 1:
-                        if (!(_g.sent()) && !allowNotSudo) {
-                            tnp_helpers_1.Helpers.error("[vpn-split] Please run this program as sudo (or admin on windows)", false, true);
-                        }
-                        if (!VpnSplit._instances[cwd]) {
-                            VpnSplit._instances[cwd] = new VpnSplit(ports, tnp_core_1._.merge(defaultHosts, additionalDefaultHosts), cwd);
-                        }
-                        return [2 /*return*/, VpnSplit._instances[cwd]];
-                }
-            });
-        });
-    };
+    static async Instance({ ports = [80, 443, 4443, 22, 2222, 8180, 8080, 4407, 7999, 9443], additionalDefaultHosts = {}, cwd = process.cwd(), allowNotSudo = false, } = {}) {
+        if (!(await (0, tnp_core_1.isElevated)()) && !allowNotSudo) {
+            tnp_helpers_1.Helpers.error(`[vpn-split] Please run this program as sudo (or admin on windows)`, false, true);
+        }
+        if (!VpnSplit._instances[cwd]) {
+            VpnSplit._instances[cwd] = new VpnSplit(ports, tnp_core_1._.merge(defaultHosts, additionalDefaultHosts), cwd);
+        }
+        return VpnSplit._instances[cwd];
+    }
     //#endregion
     //#region start server
-    VpnSplit.prototype.startServer = function () {
-        return tslib_1.__awaiter(this, arguments, void 0, function (saveHostInUserFolder) {
-            var _a, _b, portToPassthrough, e_1_1, _c, _d, portToPassthrough, e_2_1;
-            var e_1, _e, e_2, _f;
-            if (saveHostInUserFolder === void 0) { saveHostInUserFolder = false; }
-            return tslib_1.__generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0:
-                        this.createCertificateIfNotExists();
-                        //#region modify /etc/host to direct traffic appropriately
-                        saveHosts(this.hosts, { saveHostInUserFolder: saveHostInUserFolder });
-                        _g.label = 1;
-                    case 1:
-                        _g.trys.push([1, 6, 7, 8]);
-                        _a = tslib_1.__values(this.portsToPass), _b = _a.next();
-                        _g.label = 2;
-                    case 2:
-                        if (!!_b.done) return [3 /*break*/, 5];
-                        portToPassthrough = _b.value;
-                        return [4 /*yield*/, this.serverPassthrough(portToPassthrough)];
-                    case 3:
-                        _g.sent();
-                        _g.label = 4;
-                    case 4:
-                        _b = _a.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_1_1 = _g.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 8:
-                        _g.trys.push([8, 13, 14, 15]);
-                        _c = tslib_1.__values(this.portsToPass), _d = _c.next();
-                        _g.label = 9;
-                    case 9:
-                        if (!!_d.done) return [3 /*break*/, 12];
-                        portToPassthrough = _d.value;
-                        return [4 /*yield*/, this.serverUdpPassthrough(portToPassthrough)];
-                    case 10:
-                        _g.sent();
-                        _g.label = 11;
-                    case 11:
-                        _d = _c.next();
-                        return [3 /*break*/, 9];
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
-                        e_2_1 = _g.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 15];
-                    case 14:
-                        try {
-                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 15:
-                        tnp_helpers_1.Helpers.info("Activated (server).");
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async startServer(saveHostInUserFolder = false) {
+        this.createCertificateIfNotExists();
+        //#region modify /etc/host to direct traffic appropriately
+        saveHosts(this.hosts, { saveHostInUserFolder });
+        //#endregion
+        // Start TCP/HTTPS passthrough
+        for (const portToPassthrough of this.portsToPass) {
+            await this.serverPassthrough(portToPassthrough);
+        }
+        // Start UDP passthrough
+        for (const portToPassthrough of this.portsToPass) {
+            await this.serverUdpPassthrough(portToPassthrough);
+        }
+        tnp_helpers_1.Helpers.info(`Activated (server).`);
+    }
     //#endregion
     //#region apply hosts
-    VpnSplit.prototype.applyHosts = function (hosts) {
+    applyHosts(hosts) {
         // console.log(hosts);
         saveHosts(hosts);
-    };
-    VpnSplit.prototype.applyHostsLocal = function (hosts) {
+    }
+    applyHostsLocal(hosts) {
         // console.log(hosts);
         saveHostsLocal(hosts);
-    };
+    }
     //#endregion
     //#region start client
-    VpnSplit.prototype.startClient = function (vpnServerTargets_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function (vpnServerTargets, saveHostInUserFolder) {
-            var vpnServerTargets_2, vpnServerTargets_2_1, vpnServerTarget, hosts, vpnServerTargets_3, vpnServerTargets_3_1, vpnServerTarget, newHosts, newHosts_1, newHosts_1_1, host, e_3_1, originalHosts, combinedHostsObj, _a, _b, portToPassthrough, e_4_1, _c, _d, portToPassthrough, e_5_1;
-            var e_6, _e, e_3, _f, e_7, _g, e_4, _h, e_5, _j;
-            if (saveHostInUserFolder === void 0) { saveHostInUserFolder = false; }
-            return tslib_1.__generator(this, function (_k) {
-                switch (_k.label) {
-                    case 0:
-                        if (!Array.isArray(vpnServerTargets)) {
-                            vpnServerTargets = [vpnServerTargets];
-                        }
-                        try {
-                            for (vpnServerTargets_2 = tslib_1.__values(vpnServerTargets), vpnServerTargets_2_1 = vpnServerTargets_2.next(); !vpnServerTargets_2_1.done; vpnServerTargets_2_1 = vpnServerTargets_2.next()) {
-                                vpnServerTarget = vpnServerTargets_2_1.value;
-                                this.preventBadTargetForClient(vpnServerTarget);
-                            }
-                        }
-                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                        finally {
-                            try {
-                                if (vpnServerTargets_2_1 && !vpnServerTargets_2_1.done && (_e = vpnServerTargets_2.return)) _e.call(vpnServerTargets_2);
-                            }
-                            finally { if (e_6) throw e_6.error; }
-                        }
-                        this.createCertificateIfNotExists();
-                        hosts = [];
-                        _k.label = 1;
-                    case 1:
-                        _k.trys.push([1, 6, 7, 8]);
-                        vpnServerTargets_3 = tslib_1.__values(vpnServerTargets), vpnServerTargets_3_1 = vpnServerTargets_3.next();
-                        _k.label = 2;
-                    case 2:
-                        if (!!vpnServerTargets_3_1.done) return [3 /*break*/, 5];
-                        vpnServerTarget = vpnServerTargets_3_1.value;
-                        return [4 /*yield*/, this.getRemoteHosts(vpnServerTarget)];
-                    case 3:
-                        newHosts = _k.sent();
-                        try {
-                            for (newHosts_1 = (e_7 = void 0, tslib_1.__values(newHosts)), newHosts_1_1 = newHosts_1.next(); !newHosts_1_1.done; newHosts_1_1 = newHosts_1.next()) {
-                                host = newHosts_1_1.value;
-                                // Mark the original VPN server domain
-                                host.originHostname = vpnServerTarget.hostname;
-                                hosts.push(host);
-                            }
-                        }
-                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                        finally {
-                            try {
-                                if (newHosts_1_1 && !newHosts_1_1.done && (_g = newHosts_1.return)) _g.call(newHosts_1);
-                            }
-                            finally { if (e_7) throw e_7.error; }
-                        }
-                        _k.label = 4;
-                    case 4:
-                        vpnServerTargets_3_1 = vpnServerTargets_3.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_3_1 = _k.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (vpnServerTargets_3_1 && !vpnServerTargets_3_1.done && (_f = vpnServerTargets_3.return)) _f.call(vpnServerTargets_3);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 8:
-                        originalHosts = this.hostsArr;
-                        combinedHostsObj = tnp_core_1._.values(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(originalHosts), false), tslib_1.__read(hosts.map(function (h) {
-                            return models_1.HostForServer.From({
-                                aliases: h.alias,
-                                ipOrDomain: h.ip,
-                                originHostname: h.originHostname,
-                            }, "external host ".concat(h.alias, " ").concat(h.ip));
-                        })), false).map(function (c) {
-                            var copy = c.clone();
-                            if (!copy.isDefault) {
-                                copy.ip = "127.0.0.1";
-                            }
-                            return copy;
-                        })
-                            .reduce(function (prev, curr) {
-                            var _a;
-                            return tnp_core_1._.merge(prev, (_a = {},
-                                _a[curr.aliases.join(' ')] = curr,
-                                _a));
-                        }, {}));
-                        saveHosts(combinedHostsObj, { saveHostInUserFolder: saveHostInUserFolder });
-                        _k.label = 9;
-                    case 9:
-                        _k.trys.push([9, 14, 15, 16]);
-                        _a = tslib_1.__values(this.portsToPass), _b = _a.next();
-                        _k.label = 10;
-                    case 10:
-                        if (!!_b.done) return [3 /*break*/, 13];
-                        portToPassthrough = _b.value;
-                        return [4 /*yield*/, this.clientPassthrough(portToPassthrough, vpnServerTargets, combinedHostsObj)];
-                    case 11:
-                        _k.sent();
-                        _k.label = 12;
-                    case 12:
-                        _b = _a.next();
-                        return [3 /*break*/, 10];
-                    case 13: return [3 /*break*/, 16];
-                    case 14:
-                        e_4_1 = _k.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 16];
-                    case 15:
-                        try {
-                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                        return [7 /*endfinally*/];
-                    case 16:
-                        _k.trys.push([16, 21, 22, 23]);
-                        _c = tslib_1.__values(this.portsToPass), _d = _c.next();
-                        _k.label = 17;
-                    case 17:
-                        if (!!_d.done) return [3 /*break*/, 20];
-                        portToPassthrough = _d.value;
-                        return [4 /*yield*/, this.clientUdpPassthrough(portToPassthrough, vpnServerTargets, combinedHostsObj)];
-                    case 18:
-                        _k.sent();
-                        _k.label = 19;
-                    case 19:
-                        _d = _c.next();
-                        return [3 /*break*/, 17];
-                    case 20: return [3 /*break*/, 23];
-                    case 21:
-                        e_5_1 = _k.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 23];
-                    case 22:
-                        try {
-                            if (_d && !_d.done && (_j = _c.return)) _j.call(_c);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                        return [7 /*endfinally*/];
-                    case 23:
-                        tnp_helpers_1.Helpers.info("Client activated");
-                        return [2 /*return*/];
-                }
+    async startClient(vpnServerTargets, saveHostInUserFolder = false) {
+        if (!Array.isArray(vpnServerTargets)) {
+            vpnServerTargets = [vpnServerTargets];
+        }
+        for (const vpnServerTarget of vpnServerTargets) {
+            this.preventBadTargetForClient(vpnServerTarget);
+        }
+        this.createCertificateIfNotExists();
+        // Get remote host definitions from remote server
+        const hosts = [];
+        for (const vpnServerTarget of vpnServerTargets) {
+            const newHosts = await this.getRemoteHosts(vpnServerTarget);
+            for (const host of newHosts) {
+                // Mark the original VPN server domain
+                host.originHostname = vpnServerTarget.hostname;
+                hosts.push(host);
+            }
+        }
+        // Merge with original, redirecting all non-default entries to 127.0.0.1
+        const originalHosts = this.hostsArr;
+        const combinedHostsObj = tnp_core_1._.values([
+            ...originalHosts,
+            ...hosts.map(h => models_1.HostForServer.From({
+                aliases: h.alias,
+                ipOrDomain: h.ip,
+                originHostname: h.originHostname,
+            }, `external host ${h.alias} ${h.ip}`)),
+        ]
+            .map(c => {
+            let copy = c.clone();
+            if (!copy.isDefault) {
+                copy.ip = `127.0.0.1`;
+            }
+            return copy;
+        })
+            .reduce((prev, curr) => {
+            return tnp_core_1._.merge(prev, {
+                [curr.aliases.join(' ')]: curr,
             });
-        });
-    };
+        }, {}));
+        saveHosts(combinedHostsObj, { saveHostInUserFolder });
+        // Start TCP/HTTPS passthrough
+        for (const portToPassthrough of this.portsToPass) {
+            await this.clientPassthrough(portToPassthrough, vpnServerTargets, combinedHostsObj);
+        }
+        // Start UDP passthrough
+        for (const portToPassthrough of this.portsToPass) {
+            await this.clientUdpPassthrough(portToPassthrough, vpnServerTargets, combinedHostsObj);
+        }
+        tnp_helpers_1.Helpers.info(`Client activated`);
+    }
     //#endregion
     //#region private methods / get remote hosts
-    VpnSplit.prototype.getRemoteHosts = function (vpnServerTarget) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var url, response, err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        url = "http://".concat(vpnServerTarget.hostname).concat(SERVERS_PATH);
-                        return [4 /*yield*/, (0, axios_1.default)({ url: url, method: 'GET' })];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, response.data];
-                    case 2:
-                        err_1 = _a.sent();
-                        tnp_helpers_1.Helpers.error("Remote server: ".concat(vpnServerTarget.hostname, " may be inactive..."), true, true);
-                        return [2 /*return*/, []];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async getRemoteHosts(vpnServerTarget) {
+        try {
+            const url = `http://${vpnServerTarget.hostname}${SERVERS_PATH}`;
+            const response = await (0, axios_1.default)({ url, method: 'GET' });
+            return response.data;
+        }
+        catch (err) {
+            tnp_helpers_1.Helpers.error(`Remote server: ${vpnServerTarget.hostname} may be inactive...`, true, true);
+            return [];
+        }
+    }
     //#endregion
     //#region private methods / create certificate
-    VpnSplit.prototype.createCertificateIfNotExists = function () {
+    createCertificateIfNotExists() {
         if (!tnp_helpers_1.Helpers.exists(this.serveKeyPath) ||
             !tnp_helpers_1.Helpers.exists(this.serveCertPath)) {
-            tnp_helpers_1.Helpers.info("[vpn-split] Generating new self-signed certificate for localhost...");
-            var commandGen = "openssl req -nodes -new -x509 -keyout ".concat(this.serveKeyName, " -out ").concat(this.serveCertName);
+            tnp_helpers_1.Helpers.info(`[vpn-split] Generating new self-signed certificate for localhost...`);
+            const commandGen = `openssl req -nodes -new -x509 -keyout ${this.serveKeyName} -out ${this.serveCertName}`;
             tnp_helpers_1.Helpers.run(commandGen, { cwd: this.cwd, output: true }).sync();
         }
-    };
+    }
     //#endregion
     //#region private methods / TCP & HTTPS passthrough
-    VpnSplit.prototype.getTarget = function (_a) {
-        var req = _a.req, res = _a.res, port = _a.port, hostname = _a.hostname;
-        return "".concat(req.protocol, "://").concat(hostname, ":").concat(port);
-    };
-    VpnSplit.prototype.getProxyConfig = function (_a) {
-        var req = _a.req, res = _a.res, port = _a.port, hostname = _a.hostname, isHttps = _a.isHttps;
-        var serverPassthrough = !!hostname;
-        var target = this.getTarget({
-            req: req,
-            res: res,
-            port: port,
+    getTarget({ req, res, port, hostname, }) {
+        return `${req.protocol}://${hostname}:${port}`;
+    }
+    getProxyConfig({ req, res, port, hostname, isHttps, }) {
+        const serverPassthrough = !!hostname;
+        const target = this.getTarget({
+            req,
+            res,
+            port,
             hostname: serverPassthrough ? hostname : req.hostname,
         });
         // console.log({
@@ -417,7 +223,7 @@ var VpnSplit = /** @class */ (function () {
         // });
         return isHttps
             ? {
-                target: target,
+                target,
                 ssl: {
                     key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
                     cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
@@ -427,195 +233,150 @@ var VpnSplit = /** @class */ (function () {
                 }),
                 secure: false,
             }
-            : { target: target };
-    };
-    VpnSplit.prototype.getNotFoundMsg = function (req, res, port, type) {
-        return "[vpn-split] You are requesting a URL that is not in proxy reach [".concat(type, "]\nProtocol: ").concat(req.protocol, "\nHostname: ").concat(req.hostname, "\nOriginalUrl: ").concat(req.originalUrl, "\nReq.method: ").concat(req.method, "\nPort: ").concat(port, "\nSERVERS_PATH: ").concat(SERVERS_PATH);
-    };
-    VpnSplit.prototype.getMaybeChangeOriginTrueMsg = function (req, res, port, type) {
-        return "[vpn-split] Possibly need changeOrigin: true in your proxy config\nProtocol: ".concat(req.protocol, "\nHostname: ").concat(req.hostname, "\nOriginalUrl: ").concat(req.originalUrl, "\nReq.method: ").concat(req.method, "\nPort: ").concat(port);
-    };
-    VpnSplit.prototype.filterHeaders = function (req, res) {
+            : { target };
+    }
+    getNotFoundMsg(req, res, port, type) {
+        return `[vpn-split] You are requesting a URL that is not in proxy reach [${type}]
+Protocol: ${req.protocol}
+Hostname: ${req.hostname}
+OriginalUrl: ${req.originalUrl}
+Req.method: ${req.method}
+Port: ${port}
+SERVERS_PATH: ${SERVERS_PATH}`;
+    }
+    getMaybeChangeOriginTrueMsg(req, res, port, type) {
+        return `[vpn-split] Possibly need changeOrigin: true in your proxy config
+Protocol: ${req.protocol}
+Hostname: ${req.hostname}
+OriginalUrl: ${req.originalUrl}
+Req.method: ${req.method}
+Port: ${port}`;
+    }
+    filterHeaders(req, res) {
         // If you have any headers to remove, do it here:
-        var headersToRemove = [
+        const headersToRemove = [
         // 'Strict-Transport-Security',
         // 'Content-Security-Policy',
         // ...
         ];
-        headersToRemove.forEach(function (headerName) {
+        headersToRemove.forEach(headerName => {
             delete req.headers[headerName];
             res.setHeader(headerName, '');
         });
-    };
-    VpnSplit.prototype.isHttpsPort = function (port) {
+    }
+    isHttpsPort(port) {
         // Decide your logic for “is HTTPS” here
         return [443, 4443, 9443].includes(port);
-    };
+    }
     //#region server passthrough (TCP/HTTPS)
-    VpnSplit.prototype.serverPassthrough = function (portToPassthrough) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var isHttps, app, proxy, currentLocalIps, server;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        isHttps = this.isHttpsPort(portToPassthrough);
-                        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-                        app = express();
-                        proxy = httpProxy.createProxyServer({});
-                        currentLocalIps = tslib_1.__spreadArray([
-                            'localhost',
-                            '127.0.0.1'
-                        ], tslib_1.__read(tnp_helpers_1.Helpers.allLocalIpAddresses().map(function (a) { return a.hostname; })), false);
-                        app.use(function (req, res, next) {
-                            _this.filterHeaders(req, res);
-                            if (currentLocalIps.includes(req.hostname)) {
-                                if (req.method === 'GET' && req.originalUrl === SERVERS_PATH) {
-                                    res.send(JSON.stringify(_this.hostsArrWithoutDefault.map(function (h) { return ({
-                                        ip: h.ip,
-                                        alias: tnp_helpers_1.Helpers.arrays.from(h.aliases).join(' '),
-                                    }); })));
-                                }
-                                else {
-                                    var msg = _this.getNotFoundMsg(req, res, portToPassthrough, 'server');
-                                    log.d(msg);
-                                    res.send(msg);
-                                }
-                                next();
-                            }
-                            else {
-                                proxy.web(req, res, _this.getProxyConfig({ req: req, res: res, port: portToPassthrough, isHttps: isHttps }), next);
-                            }
-                        });
-                        server = isHttps
-                            ? tnp_core_1.https.createServer({
-                                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
-                                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
-                            }, app)
-                            : tnp_core_1.http.createServer(app);
-                        return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true })];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                server.listen(portToPassthrough, function () {
-                                    console.log("TCP/HTTPS server listening on port ".concat(portToPassthrough, " (secure=").concat(isHttps, ")"));
-                                    resolve();
-                                });
-                            })];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
+    async serverPassthrough(portToPassthrough) {
+        const isHttps = this.isHttpsPort(portToPassthrough);
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        const app = express();
+        const proxy = httpProxy.createProxyServer({});
+        const currentLocalIps = [
+            'localhost',
+            '127.0.0.1',
+            ...tnp_helpers_1.Helpers.allLocalIpAddresses().map(a => a.hostname),
+        ];
+        app.use((req, res, next) => {
+            this.filterHeaders(req, res);
+            if (currentLocalIps.includes(req.hostname)) {
+                if (req.method === 'GET' && req.originalUrl === SERVERS_PATH) {
+                    res.send(JSON.stringify(this.hostsArrWithoutDefault.map(h => ({
+                        ip: h.ip,
+                        alias: tnp_helpers_1.Helpers.arrays.from(h.aliases).join(' '),
+                    }))));
                 }
+                else {
+                    const msg = this.getNotFoundMsg(req, res, portToPassthrough, 'server');
+                    log.d(msg);
+                    res.send(msg);
+                }
+                next();
+            }
+            else {
+                proxy.web(req, res, this.getProxyConfig({ req, res, port: portToPassthrough, isHttps }), next);
+            }
+        });
+        const server = isHttps
+            ? tnp_core_1.https.createServer({
+                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
+                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
+            }, app)
+            : http.createServer(app);
+        await tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true });
+        await new Promise((resolve, reject) => {
+            server.listen(portToPassthrough, () => {
+                console.log(`TCP/HTTPS server listening on port ${portToPassthrough} (secure=${isHttps})`);
+                resolve();
             });
         });
-    };
+    }
     //#endregion
     //#region client passthrough (TCP/HTTPS)
-    VpnSplit.prototype.clientPassthrough = function (portToPassthrough, vpnServerTargets, hostsArr) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var aliasToOriginHostname, hostsArr_1, hostsArr_1_1, h, _a, _b, alias, originToUrlMap, vpnServerTargets_1, vpnServerTargets_1_1, url, isHttps, app, proxy, server;
-            var e_8, _c, e_9, _d, e_10, _e;
-            var _this = this;
-            return tslib_1.__generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        aliasToOriginHostname = {};
-                        try {
-                            for (hostsArr_1 = tslib_1.__values(hostsArr), hostsArr_1_1 = hostsArr_1.next(); !hostsArr_1_1.done; hostsArr_1_1 = hostsArr_1.next()) {
-                                h = hostsArr_1_1.value;
-                                try {
-                                    for (_a = (e_9 = void 0, tslib_1.__values(h.aliases)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                        alias = _b.value;
-                                        aliasToOriginHostname[alias] = h.originHostname;
-                                    }
-                                }
-                                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                                finally {
-                                    try {
-                                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                                    }
-                                    finally { if (e_9) throw e_9.error; }
-                                }
-                            }
-                        }
-                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                        finally {
-                            try {
-                                if (hostsArr_1_1 && !hostsArr_1_1.done && (_c = hostsArr_1.return)) _c.call(hostsArr_1);
-                            }
-                            finally { if (e_8) throw e_8.error; }
-                        }
-                        // Remove defaults from the map so we don't cause collisions
-                        delete aliasToOriginHostname['localhost'];
-                        delete aliasToOriginHostname['broadcasthost'];
-                        originToUrlMap = {};
-                        try {
-                            for (vpnServerTargets_1 = tslib_1.__values(vpnServerTargets), vpnServerTargets_1_1 = vpnServerTargets_1.next(); !vpnServerTargets_1_1.done; vpnServerTargets_1_1 = vpnServerTargets_1.next()) {
-                                url = vpnServerTargets_1_1.value;
-                                originToUrlMap[url.hostname] = url;
-                            }
-                        }
-                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                        finally {
-                            try {
-                                if (vpnServerTargets_1_1 && !vpnServerTargets_1_1.done && (_e = vpnServerTargets_1.return)) _e.call(vpnServerTargets_1);
-                            }
-                            finally { if (e_10) throw e_10.error; }
-                        }
-                        isHttps = this.isHttpsPort(portToPassthrough);
-                        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-                        app = express();
-                        proxy = httpProxy.createProxyServer({});
-                        app.use(function (req, res, next) {
-                            _this.filterHeaders(req, res);
-                            // Identify the real origin server based on alias
-                            var originHostname = aliasToOriginHostname[req.hostname];
-                            if (!originHostname) {
-                                // Not one of our known aliases
-                                var msg = _this.getMaybeChangeOriginTrueMsg(req, res, portToPassthrough, 'client');
-                                res.send(msg);
-                                next();
-                                return;
-                            }
-                            // Proxy onward to the real server domain at the same port
-                            var targetUrlObj = originToUrlMap[originHostname];
-                            if (!targetUrlObj) {
-                                var notFoundMsg = _this.getNotFoundMsg(req, res, portToPassthrough, 'client');
-                                res.send(notFoundMsg);
-                                next();
-                                return;
-                            }
-                            // Forward
-                            proxy.web(req, res, _this.getProxyConfig({
-                                req: req,
-                                res: res,
-                                port: portToPassthrough,
-                                isHttps: isHttps,
-                                hostname: targetUrlObj.hostname,
-                            }), next);
-                        });
-                        server = isHttps
-                            ? tnp_core_1.https.createServer({
-                                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
-                                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
-                            }, app)
-                            : tnp_core_1.http.createServer(app);
-                        return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true })];
-                    case 1:
-                        _f.sent();
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                server.listen(portToPassthrough, function () {
-                                    log.i("TCP/HTTPS client listening on port ".concat(portToPassthrough, " (secure=").concat(isHttps, ")"));
-                                    resolve();
-                                });
-                            })];
-                    case 2:
-                        _f.sent();
-                        return [2 /*return*/];
-                }
+    async clientPassthrough(portToPassthrough, vpnServerTargets, hostsArr) {
+        // Map from an alias => the “real” origin hostname (the server domain)
+        const aliasToOriginHostname = {};
+        for (const h of hostsArr) {
+            for (const alias of h.aliases) {
+                aliasToOriginHostname[alias] = h.originHostname;
+            }
+        }
+        // Remove defaults from the map so we don't cause collisions
+        delete aliasToOriginHostname['localhost'];
+        delete aliasToOriginHostname['broadcasthost'];
+        // Build a dictionary from originHostname => URL (for quick lookup)
+        const originToUrlMap = {};
+        for (const url of vpnServerTargets) {
+            originToUrlMap[url.hostname] = url;
+        }
+        const isHttps = this.isHttpsPort(portToPassthrough);
+        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        const app = express();
+        const proxy = httpProxy.createProxyServer({});
+        app.use((req, res, next) => {
+            this.filterHeaders(req, res);
+            // Identify the real origin server based on alias
+            const originHostname = aliasToOriginHostname[req.hostname];
+            if (!originHostname) {
+                // Not one of our known aliases
+                const msg = this.getMaybeChangeOriginTrueMsg(req, res, portToPassthrough, 'client');
+                res.send(msg);
+                next();
+                return;
+            }
+            // Proxy onward to the real server domain at the same port
+            const targetUrlObj = originToUrlMap[originHostname];
+            if (!targetUrlObj) {
+                const notFoundMsg = this.getNotFoundMsg(req, res, portToPassthrough, 'client');
+                res.send(notFoundMsg);
+                next();
+                return;
+            }
+            // Forward
+            proxy.web(req, res, this.getProxyConfig({
+                req,
+                res,
+                port: portToPassthrough,
+                isHttps,
+                hostname: targetUrlObj.hostname,
+            }), next);
+        });
+        const server = isHttps
+            ? tnp_core_1.https.createServer({
+                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
+                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
+            }, app)
+            : http.createServer(app);
+        await tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true });
+        await new Promise((resolve, reject) => {
+            server.listen(portToPassthrough, () => {
+                log.i(`TCP/HTTPS client listening on port ${portToPassthrough} (secure=${isHttps})`);
+                resolve();
             });
         });
-    };
+    }
     //#endregion
     //#region UDP passthrough
     /**
@@ -623,34 +384,112 @@ var VpnSplit = /** @class */ (function () {
      * This example forwards inbound messages right back to the sender,
      * or you can forward them to an external IP:port if desired.
      */
-    VpnSplit.prototype.serverUdpPassthrough = function (port) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var socket;
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/];
+    async serverUdpPassthrough(port) {
+        return;
+        // Example of a simple “echo-style” server or forwarder
+        const socket = dgram.createSocket('udp4');
+        // (Optionally) kill existing processes on that port – though for UDP
+        // we might not have a direct “listener process.” Adjust as needed.
+        // await Helpers.killProcessByPort(port, { silent: true }).catch(() => {});
+        socket.on('message', (msg, rinfo) => {
+            // rinfo contains { address, port } of the sender
+            // In a typical “server” scenario, you might:
+            // 1. Inspect msg
+            // 2. Possibly forward to some real backend if needed
+            // 3. Or just echo it back
+            // For a real forward, do something like:
+            // const backendHost = 'some-other-host-or-ip';
+            // const backendPort = 9999;
+            // socket.send(msg, 0, msg.length, backendPort, backendHost);
+            // For a basic echo server:
+            socket.send(msg, 0, msg.length, rinfo.port, rinfo.address, err => {
+                if (err) {
+                    log.er(`UDP server send error: ${err}`);
+                }
             });
         });
-    };
+        socket.on('listening', () => {
+            const address = socket.address();
+            log.i(`UDP server listening at ${address.address}:${address.port}`);
+        });
+        socket.bind(port);
+    }
     /**
      * Start a UDP socket for “client” mode on a given port.
      * This example also just does a trivial pass-through or echo,
      * but you can adapt to forward to a remote server.
      */
-    VpnSplit.prototype.clientUdpPassthrough = function (port, vpnServerTargets, hostsArr) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var socket, primaryTarget, targetHost, targetPort, clientMap;
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/];
-            });
+    async clientUdpPassthrough(port, vpnServerTargets, hostsArr) {
+        return;
+        // console.log(`Client UDP passthrough, port ${port}` );
+        // In client mode, we typically intercept local UDP traffic on “port”
+        // and forward it to the remote server. Then we forward the remote
+        // server's response back to the local client.
+        const socket = dgram.createSocket('udp4');
+        // await Helpers.killProcessByPort(port, { silent: true }).catch(() => {});
+        // For simplicity, pick the first server from the array
+        // Or add your own logic to choose among multiple.
+        const primaryTarget = vpnServerTargets[0];
+        const targetHost = primaryTarget.hostname;
+        // Choose the same port or a custom port
+        const targetPort = port;
+        // A map to remember who originally sent us a packet,
+        // so we can route the response back properly.
+        // Key could be “targetHost:targetPort => { address, port }”
+        // or “clientAddress:clientPort” => { remoteAddress, remotePort }.
+        // Adapt to your scenario.
+        const clientMap = new Map();
+        socket.on('message', (msg, rinfo) => {
+            //
+            // If the message is from a local client, forward to server.
+            // If the message is from the server, forward back to the correct client.
+            //
+            // Check if it’s from local or remote by address. This is simplistic:
+            const isFromLocal = !tnp_core_1._.includes(hostsArr.map(h => h.ipOrDomain), rinfo.address);
+            if (isFromLocal) {
+                // Received from local => forward to “server” (the VPN server)
+                // Keep track of who we got this from (the local client)
+                const key = `local-${rinfo.address}:${rinfo.port}`;
+                clientMap.set(key, rinfo);
+                // Forward to remote
+                socket.send(msg, 0, msg.length, targetPort, targetHost, err => {
+                    if (err) {
+                        log.er(`UDP client forward error: ${err}`);
+                    }
+                });
+            }
+            else {
+                // Probably from remote => forward back to whichever local client sent it
+                // In a more advanced scenario, parse the payload or maintain a bigger table
+                // with NAT-like sessions.
+                //
+                // For now, we guess it’s from the “VPN server”
+                // We'll just route it back to the single local client that we stored
+                // or do multiple if we had a better NAT map.
+                // If you have multi-target or multi-client logic, adapt here.
+                // For example, search clientMap by something in the msg or a NAT key.
+                clientMap.forEach((localRinfo, key) => {
+                    socket.send(msg, 0, msg.length, localRinfo.port, localRinfo.address, err => {
+                        if (err) {
+                            log.er(`UDP client re-send error: ${err}`);
+                        }
+                    });
+                });
+            }
         });
-    };
+        socket.on('listening', () => {
+            const address = socket.address();
+            log.i(`UDP client listening at ${address.address}:${address.port}, forwarding to ${targetHost}:${targetPort}`);
+        });
+        socket.bind(port);
+    }
     //#endregion
     //#region private methods / get port from request
-    VpnSplit.prototype.getPortFromRequest = function (req) {
-        var host = req.headers.host;
-        var protocol = req.protocol;
+    getPortFromRequest(req) {
+        const host = req.headers.host;
+        const protocol = req.protocol;
         if (host) {
-            var hostParts = host.split(':');
+            const hostParts = host.split(':');
             if (hostParts.length === 2) {
                 return Number(hostParts[1]);
             }
@@ -659,39 +498,38 @@ var VpnSplit = /** @class */ (function () {
             }
         }
         return 80;
-    };
+    }
     //#endregion
     //#region private methods / prevent bad target for client
-    VpnSplit.prototype.preventBadTargetForClient = function (vpnServerTarget) {
+    preventBadTargetForClient(vpnServerTarget) {
         if (!vpnServerTarget) {
-            var currentLocalIp = tnp_helpers_1.Helpers.localIpAddress();
-            tnp_helpers_1.Helpers.error("[vpn-server] Please provide a correct target server.\n" +
-                "Example:\n" +
-                "vpn-server ".concat(currentLocalIp, "\n\n") +
-                "Your local IP is: ".concat(currentLocalIp), false, true);
+            const currentLocalIp = tnp_helpers_1.Helpers.localIpAddress();
+            tnp_helpers_1.Helpers.error(`[vpn-server] Please provide a correct target server.\n` +
+                `Example:\n` +
+                `vpn-server ${currentLocalIp}\n\n` +
+                `Your local IP is: ${currentLocalIp}`, false, true);
         }
-    };
-    //#endregion
-    //#region singleton
-    VpnSplit._instances = {};
-    return VpnSplit;
-}());
+    }
+}
 exports.VpnSplit = VpnSplit;
 //#region helper / gen msg
-var genMsg = "\n################################################\n## This file is generated #####################\n################################################\n".trim() + EOL;
+const genMsg = `
+################################################
+## This file is generated #####################
+################################################
+`.trim() + EOL;
 //#endregion
 //#region helpers / save hosts
 function saveHosts(hosts, options) {
-    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
+    const { saveHostInUserFolder } = options || {};
     if (tnp_core_1._.isArray(hosts)) {
-        hosts = hosts.reduce(function (prev, curr) {
-            var _a;
-            return tnp_core_1._.merge(prev, (_a = {},
-                _a[curr.name] = curr,
-                _a));
+        hosts = hosts.reduce((prev, curr) => {
+            return tnp_core_1._.merge(prev, {
+                [curr.name]: curr,
+            });
         }, {});
     }
-    var toSave = parseHost(hosts, !!saveHostInUserFolder);
+    const toSave = parseHost(hosts, !!saveHostInUserFolder);
     if (saveHostInUserFolder) {
         tnp_helpers_1.Helpers.writeFile(HOST_FILE_PATHUSER, toSave);
     }
@@ -700,16 +538,15 @@ function saveHosts(hosts, options) {
     }
 }
 function saveHostsLocal(hosts, options) {
-    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
+    const { saveHostInUserFolder } = options || {};
     if (tnp_core_1._.isArray(hosts)) {
-        hosts = hosts.reduce(function (prev, curr) {
-            var _a;
-            return tnp_core_1._.merge(prev, (_a = {},
-                _a[curr.name] = curr,
-                _a));
+        hosts = hosts.reduce((prev, curr) => {
+            return tnp_core_1._.merge(prev, {
+                [curr.name]: curr,
+            });
         }, {});
     }
-    var toSave = parseHost(hosts, !!saveHostInUserFolder, true);
+    const toSave = parseHost(hosts, !!saveHostInUserFolder, true);
     if (saveHostInUserFolder) {
         tnp_helpers_1.Helpers.writeFile(HOST_FILE_PATHUSER, toSave);
     }
@@ -719,27 +556,26 @@ function saveHostsLocal(hosts, options) {
 }
 //#endregion
 //#region helpers / parse hosts
-function parseHost(hosts, saveHostInUserFolder, useLocal) {
-    if (useLocal === void 0) { useLocal = false; }
-    tnp_core_1._.keys(hosts).forEach(function (hostName) {
-        var v = hosts[hostName];
+function parseHost(hosts, saveHostInUserFolder, useLocal = false) {
+    tnp_core_1._.keys(hosts).forEach(hostName => {
+        const v = hosts[hostName];
         v.name = hostName;
     });
     return (genMsg +
         EOL +
         tnp_core_1._.keys(hosts)
-            .map(function (hostName) {
-            var v = hosts[hostName];
-            var aliasesStr = v.aliases.join(' ');
+            .map(hostName => {
+            const v = hosts[hostName];
+            const aliasesStr = v.aliases.join(' ');
             if (saveHostInUserFolder) {
                 // For a user-specific hosts file:
                 return useLocal
-                    ? "127.0.0.1 ".concat(aliasesStr)
-                    : "".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(aliasesStr);
+                    ? `127.0.0.1 ${aliasesStr}`
+                    : `${v.disabled ? '#' : ''}${v.ipOrDomain} ${aliasesStr}`;
             }
             return useLocal
-                ? "127.0.0.1 ".concat(aliasesStr)
-                : "".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(aliasesStr, " # ").concat(v.name, " ").concat(GENERATED);
+                ? `127.0.0.1 ${aliasesStr}`
+                : `${v.disabled ? '#' : ''}${v.ipOrDomain} ${aliasesStr} # ${v.name} ${GENERATED}`;
         })
             .join(EOL) +
         EOL +