vpn-split 18.0.18 → 18.0.20

package/lib/vpn-split.backend.js

@@ -1,30 +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 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',
@@ -42,593 +43,510 @@ 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:
-                        // console.log('ports', ports)
-                        // console.log({
-                        //   allowNotSudo
-                        // })
-                        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 index, portToPassthrough;
-            if (saveHostInUserFolder === void 0) { saveHostInUserFolder = false; }
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.createCertificateIfNotExists();
-                        //#region modify /etc/host 80,443 to redirect to proper server domain/ip
-                        saveHosts(this.hosts, { saveHostInUserFolder: saveHostInUserFolder });
-                        index = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(index < this.portsToPass.length)) return [3 /*break*/, 4];
-                        portToPassthrough = this.portsToPass[index];
-                        return [4 /*yield*/, this.serverPassthrough(portToPassthrough)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        index++;
-                        return [3 /*break*/, 1];
-                    case 4:
-                        tnp_helpers_1.Helpers.info("Activated.");
-                        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);
-    };
+    }
+    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_1_1, originalHosts, cloned, _a, _b, portToPassthrough, e_2_1;
-            var e_3, _c, e_1, _d, e_4, _e, e_2, _f;
-            if (saveHostInUserFolder === void 0) { saveHostInUserFolder = false; }
-            return tslib_1.__generator(this, function (_g) {
-                switch (_g.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_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (vpnServerTargets_2_1 && !vpnServerTargets_2_1.done && (_c = vpnServerTargets_2.return)) _c.call(vpnServerTargets_2);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                        this.createCertificateIfNotExists();
-                        hosts = [];
-                        _g.label = 1;
-                    case 1:
-                        _g.trys.push([1, 6, 7, 8]);
-                        vpnServerTargets_3 = tslib_1.__values(vpnServerTargets), vpnServerTargets_3_1 = vpnServerTargets_3.next();
-                        _g.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 = _g.sent();
-                        try {
-                            for (newHosts_1 = (e_4 = 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;
-                                host.originHostname = vpnServerTarget.hostname;
-                                // console.log('host.originHostname' + host.originHostname)
-                                hosts.push(host);
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                        finally {
-                            try {
-                                if (newHosts_1_1 && !newHosts_1_1.done && (_e = newHosts_1.return)) _e.call(newHosts_1);
-                            }
-                            finally { if (e_4) throw e_4.error; }
-                        }
-                        _g.label = 4;
-                    case 4:
-                        vpnServerTargets_3_1 = vpnServerTargets_3.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 (vpnServerTargets_3_1 && !vpnServerTargets_3_1.done && (_d = vpnServerTargets_3.return)) _d.call(vpnServerTargets_3);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 8:
-                        originalHosts = this.hostsArr;
-                        cloned = 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";
-                            }
-                            // copy = HostForServer.From(copy);
-                            // console.log('cloned host.originHostname' + copy.originHostname)
-                            return copy;
-                        })
-                            .reduce(function (prev, curr) {
-                            var _a;
-                            return tnp_core_1._.merge(prev, (_a = {},
-                                _a[curr.aliases.join(' ')] = curr,
-                                _a));
-                        }, {}));
-                        saveHosts(cloned, { saveHostInUserFolder: saveHostInUserFolder });
-                        _g.label = 9;
-                    case 9:
-                        _g.trys.push([9, 14, 15, 16]);
-                        _a = tslib_1.__values(this.portsToPass), _b = _a.next();
-                        _g.label = 10;
-                    case 10:
-                        if (!!_b.done) return [3 /*break*/, 13];
-                        portToPassthrough = _b.value;
-                        return [4 /*yield*/, this.clientPassthrough(portToPassthrough, vpnServerTargets, cloned)];
-                    case 11:
-                        _g.sent();
-                        _g.label = 12;
-                    case 12:
-                        _b = _a.next();
-                        return [3 /*break*/, 10];
-                    case 13: return [3 /*break*/, 16];
-                    case 14:
-                        e_2_1 = _g.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 16];
-                    case 15:
-                        try {
-                            if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 16:
-                        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, " maybe inactive...") +
-                            " nothing to passthrought ", 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 certification for localhost... please follow instructions..");
-            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();
-            // Helpers.run(`openssl verify -verbose -x509_strict -CAfile ${this.serveKeyName} ${this.serveCertChainName}`,
-            //   { cwd: this.cwd, output: true }).sync()
         }
-    };
+    }
     //#endregion
-    //#region private methods / proxy passthrough
-    VpnSplit.prototype.getTarget = function (_a) {
-        var req = _a.req, res = _a.res, port = _a.port, hostname = _a.hostname;
-        // console.log(`protocol="${req.protocol}", hostname="${hostname}", port="${port}"`)
-        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,
+    //#region private methods / TCP & HTTPS passthrough
+    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(`[target] [${serverPassthrough ? 'server' : 'client'}] target="${target}", hostname="${hostname}",`
-        // +` protocol="${req.protocol}", ip="${req.ip}", origin="${req.originalUrl}"`)
+        // console.log({
+        //   target,
+        //   port,
+        //   hostname,
+        //   reqHostname: req.hostname,
+        //   serverPassthrough,
+        // });
         return isHttps
             ? {
-                target: target,
+                target,
                 ssl: {
                     key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
                     cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
                 },
                 agent: new tnp_core_1.https.Agent({
-                    // for self signed you could also add
-                    // rejectUnauthorized: false,
-                    // allow legacy server
                     secureOptions: crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT,
                 }),
                 secure: false,
-                // followRedirects: true,
-                // changeOrigin: true,
             }
-            : {
-                target: target,
-            };
-    };
-    VpnSplit.prototype.getGetRequestInfo = function (req, res, port, type) {
-        return "server passthrough type: ".concat(type, "\nprotocol: ").concat(req.protocol, " <br>\nhostname: ").concat(req.hostname, " <br>\noriginalUrl: ").concat(req.originalUrl, " <br>\nreq.method ").concat(req.method, " <br>\nport: ").concat(port, " <br>\nSERVERS_PATH ").concat(SERVERS_PATH, " <br>");
-    };
-    VpnSplit.prototype.getNotFoundMsg = function (req, res, port, type) {
-        return "[vpn-split] You are requesting url that is not in proxy reach ".concat(type, "\n").concat(this.getGetRequestInfo(req, res, port, type), "\n    ");
-    };
-    VpnSplit.prototype.getMaybeChangeOriginTrueMs = function (req, res, port, type) {
-        return "[vpn-split] maybe changeOrigin: true, in your porxy config ?\n".concat(this.getGetRequestInfo(req, res, port, type), "\n    ");
-    };
-    Object.defineProperty(VpnSplit.prototype, "headersToRemove", {
-        get: function () {
-            return [
-            // 'Strict-Transport-Security',
-            // 'upgrade-insecure-requests',
-            // 'Content-Security-Policy',
-            // 'Upgrade-Insecure-Requests',
-            // 'content-security-policy',
-            ];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    VpnSplit.prototype.filterHeaders = function (req, res) {
-        this.headersToRemove.forEach(function (headerName) {
+            : { 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:
+        const headersToRemove = [
+        // 'Strict-Transport-Security',
+        // 'Content-Security-Policy',
+        // ...
+        ];
+        headersToRemove.forEach(headerName => {
             delete req.headers[headerName];
             res.setHeader(headerName, '');
         });
-    };
-    VpnSplit.prototype.isHttpsPort = function (port) {
-        var httpPorts = [
-            443, 4443, 9443,
-            // 2222,
-            // 22,
+    }
+    isHttpsPort(port) {
+        // Decide your logic for “is HTTPS” here
+        return [443, 4443, 9443].includes(port);
+    }
+    //#region server passthrough (TCP/HTTPS)
+    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),
         ];
-        port = Number(port);
-        return httpPorts.includes(port);
-    };
-    //#region start server passthrough
-    VpnSplit.prototype.serverPassthrough = function (portToPassthrough) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var isHttps, app, proxy, currentLocalIps, h;
-            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);
-                        // console.log({ currentLocalIps });
-                        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);
-                            }
-                        });
-                        h = isHttps
-                            ? new tnp_core_1.https.Server({
-                                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
-                                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
-                            }, app)
-                            : new tnp_core_1.http.Server(app);
-                        return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true })];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                h.listen(portToPassthrough, function () {
-                                    console.log("Passthrough ".concat(isHttps ? 'SECURE' : 'UNSECURE', " server") +
-                                        " listening on port: ".concat(portToPassthrough, "\n        env: ").concat(app.settings.env, "\n          "));
-                                });
-                                resolve(void 0);
-                            })];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
+        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 start client passthrough
-    VpnSplit.prototype.resolveProperTarget = function (vpnServerTargetsObj, req, hosts) {
-        /**
-         *
-         */
-        var originHostname = hosts[req.hostname];
-        // console.log({
-        //   'req.hostname': req.hostname,
-        //   'originHostname': originHostname
-        // })
-        return vpnServerTargetsObj[originHostname];
-    };
-    VpnSplit.prototype.clientPassthrough = function (portToPassthrough, vpnServerTargets, hostsArr) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var hosts, vpnServerTargetsObj, isHttps, app, proxy, h;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hosts = hostsArr.reduce(function (a, b) {
-                            var e_5, _a;
-                            var aliasesObj = {};
-                            try {
-                                for (var _b = tslib_1.__values(b.aliases), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                    var aliasDomain = _c.value;
-                                    aliasesObj[aliasDomain] = b.originHostname;
-                                }
-                            }
-                            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                            finally {
-                                try {
-                                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                                }
-                                finally { if (e_5) throw e_5.error; }
-                            }
-                            return tnp_core_1._.merge(a, aliasesObj);
-                        }, {});
-                        vpnServerTargetsObj = vpnServerTargets.reduce(function (a, b) {
-                            var _a;
-                            return tnp_core_1._.merge(a, (_a = {},
-                                _a[b.hostname] = b,
-                                _a));
-                        }, {});
-                        delete hosts['localhost'];
-                        delete hosts['broadcasthost'];
-                        isHttps = this.isHttpsPort(portToPassthrough);
-                        // if (isHttps) {
-                        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-                        app = express();
-                        proxy = httpProxy.createProxyServer({});
-                        app.use(function (req, res, next) {
-                            // console.log('req', req  );
-                            _this.filterHeaders(req, res);
-                            var port = _this.getPortFromRequest(req);
-                            if (req.hostname === 'localhost') {
-                                if (_this.portsToPass.includes(port)) {
-                                    var msg = _this.getNotFoundMsg(req, res, portToPassthrough, 'client');
-                                    // log.d(msg)
-                                    res.send(msg);
-                                }
-                                else {
-                                    var msg = _this.getMaybeChangeOriginTrueMs(req, res, portToPassthrough, 'client');
-                                    // log.d(msg)
-                                    res.send(msg);
-                                }
-                                next();
-                            }
-                            else {
-                                proxy.web(req, res, _this.getProxyConfig({
-                                    req: req,
-                                    res: res,
-                                    port: portToPassthrough,
-                                    isHttps: isHttps,
-                                    hostname: _this.resolveProperTarget(vpnServerTargetsObj, req, hosts).hostname,
-                                }), next);
-                            }
-                        });
-                        h = isHttps
-                            ? new tnp_core_1.https.Server({
-                                key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
-                                cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
-                            }, app)
-                            : new tnp_core_1.http.Server(app);
-                        return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true })];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                h.listen(portToPassthrough, function () {
-                                    log.i("Passthrough ".concat(isHttps ? 'SECURE' : '', " client") +
-                                        " listening on port: ".concat(portToPassthrough, "\n        env: ").concat(app.settings.env, "\n          "));
-                                });
-                                resolve(void 0);
-                            })];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    //#region client passthrough (TCP/HTTPS)
+    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
+    /**
+     * Start a UDP socket for “server” mode on a given port.
+     * This example forwards inbound messages right back to the sender,
+     * or you can forward them to an external IP:port if desired.
+     */
+    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.
+     */
+    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;
-        var port;
+    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) {
-                port = hostParts[1];
+                return Number(hostParts[1]);
             }
             else {
-                // Default ports based on protocol
-                port = protocol === 'https' ? '443' : '80';
+                return protocol === 'https' ? 443 : 80;
             }
         }
-        else {
-            // Default to port 80 if no host header is present (uncommon)
-            port = '80';
-        }
-        return Number(port);
-    };
+        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 (correct?) target server\n      Example:\n      vpn-server ".concat(currentLocalIp, " # or whatever ip of your machine with vpn\n\n      # your local ip is: ").concat(currentLocalIp, "\n\n      your args:\n      ").concat(process.argv.slice(2).join(', '), "\n      "), 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) {
-    // console.log({ hosts })
-    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
+    const { saveHostInUserFolder } = options || {};
+    if (tnp_core_1._.isArray(hosts)) {
+        hosts = hosts.reduce((prev, curr) => {
+            return tnp_core_1._.merge(prev, {
+                [curr.name]: curr,
+            });
+        }, {});
+    }
+    const toSave = parseHost(hosts, !!saveHostInUserFolder);
+    if (saveHostInUserFolder) {
+        tnp_helpers_1.Helpers.writeFile(HOST_FILE_PATHUSER, toSave);
+    }
+    else {
+        tnp_helpers_1.Helpers.writeFile(tnp_config_1.HOST_FILE_PATH, toSave);
+    }
+}
+function saveHostsLocal(hosts, options) {
+    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);
-    // Object.values(hosts).forEach( c => c )
-    // console.log({ toSave })
+    const toSave = parseHost(hosts, !!saveHostInUserFolder, true);
     if (saveHostInUserFolder) {
         tnp_helpers_1.Helpers.writeFile(HOST_FILE_PATHUSER, toSave);
     }
@@ -638,22 +556,26 @@ function saveHosts(hosts, options) {
 }
 //#endregion
 //#region helpers / parse hosts
-function parseHost(hosts, options) {
-    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
-    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];
+            .map(hostName => {
+            const v = hosts[hostName];
+            const aliasesStr = v.aliases.join(' ');
             if (saveHostInUserFolder) {
-                return "".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(v.aliases.join(' '));
+                // For a user-specific hosts file:
+                return useLocal
+                    ? `127.0.0.1 ${aliasesStr}`
+                    : `${v.disabled ? '#' : ''}${v.ipOrDomain} ${aliasesStr}`;
             }
-            return ("".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(v.aliases.join(' ')) +
-                " # ".concat(v.name, " ").concat(GENERATED));
+            return useLocal
+                ? `127.0.0.1 ${aliasesStr}`
+                : `${v.disabled ? '#' : ''}${v.ipOrDomain} ${aliasesStr} # ${v.name} ${GENERATED}`;
         })
             .join(EOL) +
         EOL +