vpn-split 18.0.18 → 18.0.19

package/lib/vpn-split.backend.js

@@ -13,6 +13,7 @@ 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);
 //#endregion
 //#region consts
@@ -118,10 +119,6 @@ var VpnSplit = /** @class */ (function () {
                 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);
                         }
@@ -137,28 +134,68 @@ var VpnSplit = /** @class */ (function () {
     //#region start server
     VpnSplit.prototype.startServer = function () {
         return tslib_1.__awaiter(this, arguments, void 0, function (saveHostInUserFolder) {
-            var index, portToPassthrough;
+            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 (_a) {
-                switch (_a.label) {
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
                     case 0:
                         this.createCertificateIfNotExists();
-                        //#region modify /etc/host 80,443 to redirect to proper server domain/ip
+                        //#region modify /etc/host to direct traffic appropriately
                         saveHosts(this.hosts, { saveHostInUserFolder: saveHostInUserFolder });
-                        index = 0;
-                        _a.label = 1;
+                        _g.label = 1;
                     case 1:
-                        if (!(index < this.portsToPass.length)) return [3 /*break*/, 4];
-                        portToPassthrough = this.portsToPass[index];
-                        return [4 /*yield*/, this.serverPassthrough(portToPassthrough)];
+                        _g.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.portsToPass), _b = _a.next();
+                        _g.label = 2;
                     case 2:
-                        _a.sent();
-                        _a.label = 3;
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        portToPassthrough = _b.value;
+                        return [4 /*yield*/, this.serverPassthrough(portToPassthrough)];
                     case 3:
-                        index++;
-                        return [3 /*break*/, 1];
+                        _g.sent();
+                        _g.label = 4;
                     case 4:
-                        tnp_helpers_1.Helpers.info("Activated.");
+                        _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*/];
                 }
             });
@@ -170,15 +207,19 @@ var VpnSplit = /** @class */ (function () {
         // console.log(hosts);
         saveHosts(hosts);
     };
+    VpnSplit.prototype.applyHostsLocal = function (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;
+            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 (_g) {
-                switch (_g.label) {
+            return tslib_1.__generator(this, function (_k) {
+                switch (_k.label) {
                     case 0:
                         if (!Array.isArray(vpnServerTargets)) {
                             vpnServerTargets = [vpnServerTargets];
@@ -189,59 +230,59 @@ var VpnSplit = /** @class */ (function () {
                                 this.preventBadTargetForClient(vpnServerTarget);
                             }
                         }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
                         finally {
                             try {
-                                if (vpnServerTargets_2_1 && !vpnServerTargets_2_1.done && (_c = vpnServerTargets_2.return)) _c.call(vpnServerTargets_2);
+                                if (vpnServerTargets_2_1 && !vpnServerTargets_2_1.done && (_e = vpnServerTargets_2.return)) _e.call(vpnServerTargets_2);
                             }
-                            finally { if (e_3) throw e_3.error; }
+                            finally { if (e_6) throw e_6.error; }
                         }
                         this.createCertificateIfNotExists();
                         hosts = [];
-                        _g.label = 1;
+                        _k.label = 1;
                     case 1:
-                        _g.trys.push([1, 6, 7, 8]);
+                        _k.trys.push([1, 6, 7, 8]);
                         vpnServerTargets_3 = tslib_1.__values(vpnServerTargets), vpnServerTargets_3_1 = vpnServerTargets_3.next();
-                        _g.label = 2;
+                        _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 = _g.sent();
+                        newHosts = _k.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()) {
+                            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;
-                                // console.log('host.originHostname' + host.originHostname)
                                 hosts.push(host);
                             }
                         }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
                         finally {
                             try {
-                                if (newHosts_1_1 && !newHosts_1_1.done && (_e = newHosts_1.return)) _e.call(newHosts_1);
+                                if (newHosts_1_1 && !newHosts_1_1.done && (_g = newHosts_1.return)) _g.call(newHosts_1);
                             }
-                            finally { if (e_4) throw e_4.error; }
+                            finally { if (e_7) throw e_7.error; }
                         }
-                        _g.label = 4;
+                        _k.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 };
+                        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 && (_d = vpnServerTargets_3.return)) _d.call(vpnServerTargets_3);
+                            if (vpnServerTargets_3_1 && !vpnServerTargets_3_1.done && (_f = vpnServerTargets_3.return)) _f.call(vpnServerTargets_3);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_3) throw e_3.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) {
+                        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,
@@ -252,8 +293,6 @@ var VpnSplit = /** @class */ (function () {
                             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) {
@@ -262,34 +301,59 @@ var VpnSplit = /** @class */ (function () {
                                 _a[curr.aliases.join(' ')] = curr,
                                 _a));
                         }, {}));
-                        saveHosts(cloned, { saveHostInUserFolder: saveHostInUserFolder });
-                        _g.label = 9;
+                        saveHosts(combinedHostsObj, { saveHostInUserFolder: saveHostInUserFolder });
+                        _k.label = 9;
                     case 9:
-                        _g.trys.push([9, 14, 15, 16]);
+                        _k.trys.push([9, 14, 15, 16]);
                         _a = tslib_1.__values(this.portsToPass), _b = _a.next();
-                        _g.label = 10;
+                        _k.label = 10;
                     case 10:
                         if (!!_b.done) return [3 /*break*/, 13];
                         portToPassthrough = _b.value;
-                        return [4 /*yield*/, this.clientPassthrough(portToPassthrough, vpnServerTargets, cloned)];
+                        return [4 /*yield*/, this.clientPassthrough(portToPassthrough, vpnServerTargets, combinedHostsObj)];
                     case 11:
-                        _g.sent();
-                        _g.label = 12;
+                        _k.sent();
+                        _k.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 };
+                        e_4_1 = _k.sent();
+                        e_4 = { error: e_4_1 };
                         return [3 /*break*/, 16];
                     case 15:
                         try {
-                            if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
+                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        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*/];
                 }
@@ -306,17 +370,13 @@ var VpnSplit = /** @class */ (function () {
                     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',
-                            })];
+                        return [4 /*yield*/, (0, axios_1.default)({ url: url, method: 'GET' })];
                     case 1:
-                        response = (_a.sent());
+                        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);
+                        tnp_helpers_1.Helpers.error("Remote server: ".concat(vpnServerTarget.hostname, " may be inactive..."), true, true);
                         return [2 /*return*/, []];
                     case 3: return [2 /*return*/];
                 }
@@ -328,18 +388,15 @@ var VpnSplit = /** @class */ (function () {
     VpnSplit.prototype.createCertificateIfNotExists = function () {
         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..");
+            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.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
+    //#region private methods / TCP & HTTPS 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) {
@@ -351,8 +408,13 @@ var VpnSplit = /** @class */ (function () {
             port: 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,
@@ -361,60 +423,38 @@ var VpnSplit = /** @class */ (function () {
                     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>");
+            : { target: target };
     };
     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    ");
+        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.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    ");
+    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);
     };
-    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) {
+        // If you have any headers to remove, do it here:
+        var headersToRemove = [
+        // 'Strict-Transport-Security',
+        // 'Content-Security-Policy',
+        // ...
+        ];
+        headersToRemove.forEach(function (headerName) {
             delete req.headers[headerName];
             res.setHeader(headerName, '');
         });
     };
     VpnSplit.prototype.isHttpsPort = function (port) {
-        var httpPorts = [
-            443, 4443, 9443,
-            // 2222,
-            // 22,
-        ];
-        port = Number(port);
-        return httpPorts.includes(port);
+        // Decide your logic for “is HTTPS” here
+        return [443, 4443, 9443].includes(port);
     };
-    //#region start server passthrough
+    //#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, h;
+            var isHttps, app, proxy, currentLocalIps, server;
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
@@ -427,17 +467,14 @@ var VpnSplit = /** @class */ (function () {
                             '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(' '),
-                                        };
-                                    })));
+                                    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');
@@ -450,21 +487,20 @@ var VpnSplit = /** @class */ (function () {
                                 proxy.web(req, res, _this.getProxyConfig({ req: req, res: res, port: portToPassthrough, isHttps: isHttps }), next);
                             }
                         });
-                        h = isHttps
-                            ? new tnp_core_1.https.Server({
+                        server = isHttps
+                            ? tnp_core_1.https.createServer({
                                 key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
                                 cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
                             }, app)
-                            : new tnp_core_1.http.Server(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) {
-                                h.listen(portToPassthrough, function () {
-                                    console.log("Passthrough ".concat(isHttps ? 'SECURE' : 'UNSECURE', " server") +
-                                        " listening on port: ".concat(portToPassthrough, "\n        env: ").concat(app.settings.env, "\n          "));
+                                server.listen(portToPassthrough, function () {
+                                    console.log("TCP/HTTPS server listening on port ".concat(portToPassthrough, " (secure=").concat(isHttps, ")"));
+                                    resolve();
                                 });
-                                resolve(void 0);
                             })];
                     case 2:
                         _a.sent();
@@ -474,135 +510,165 @@ var VpnSplit = /** @class */ (function () {
         });
     };
     //#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];
-    };
+    //#region client passthrough (TCP/HTTPS)
     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 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 (_a) {
-                switch (_a.label) {
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.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 {
+                        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 {
-                                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                    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; }
                                 }
-                                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'];
+                        }
+                        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);
-                        // 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);
-                                }
+                            // 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;
                             }
-                            else {
-                                proxy.web(req, res, _this.getProxyConfig({
-                                    req: req,
-                                    res: res,
-                                    port: portToPassthrough,
-                                    isHttps: isHttps,
-                                    hostname: _this.resolveProperTarget(vpnServerTargetsObj, req, hosts).hostname,
-                                }), next);
+                            // 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);
                         });
-                        h = isHttps
-                            ? new tnp_core_1.https.Server({
+                        server = isHttps
+                            ? tnp_core_1.https.createServer({
                                 key: tnp_core_1.fse.readFileSync(this.serveKeyPath),
                                 cert: tnp_core_1.fse.readFileSync(this.serveCertPath),
                             }, app)
-                            : new tnp_core_1.http.Server(app);
+                            : tnp_core_1.http.createServer(app);
                         return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(portToPassthrough, { silent: true })];
                     case 1:
-                        _a.sent();
+                        _f.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          "));
+                                server.listen(portToPassthrough, function () {
+                                    log.i("TCP/HTTPS client listening on port ".concat(portToPassthrough, " (secure=").concat(isHttps, ")"));
+                                    resolve();
                                 });
-                                resolve(void 0);
                             })];
                     case 2:
-                        _a.sent();
+                        _f.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
     //#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.
+     */
+    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*/];
+            });
+        });
+    };
+    /**
+     * 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*/];
+            });
+        });
+    };
     //#endregion
     //#region private methods / get port from request
     VpnSplit.prototype.getPortFromRequest = function (req) {
         var host = req.headers.host;
         var protocol = req.protocol;
-        var port;
         if (host) {
             var 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) {
         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);
+            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);
         }
     };
     //#endregion
@@ -616,7 +682,6 @@ var genMsg = "\n################################################\n## This file i
 //#endregion
 //#region helpers / save hosts
 function saveHosts(hosts, options) {
-    // console.log({ hosts })
     var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
     if (tnp_core_1._.isArray(hosts)) {
         hosts = hosts.reduce(function (prev, curr) {
@@ -626,9 +691,25 @@ function saveHosts(hosts, options) {
                 _a));
         }, {});
     }
-    var toSave = parseHost(hosts, saveHostInUserFolder);
-    // Object.values(hosts).forEach( c => c )
-    // console.log({ toSave })
+    var 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) {
+    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
+    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));
+        }, {});
+    }
+    var toSave = parseHost(hosts, !!saveHostInUserFolder, true);
     if (saveHostInUserFolder) {
         tnp_helpers_1.Helpers.writeFile(HOST_FILE_PATHUSER, toSave);
     }
@@ -638,8 +719,8 @@ function saveHosts(hosts, options) {
 }
 //#endregion
 //#region helpers / parse hosts
-function parseHost(hosts, options) {
-    var saveHostInUserFolder = (options || {}).saveHostInUserFolder;
+function parseHost(hosts, saveHostInUserFolder, useLocal) {
+    if (useLocal === void 0) { useLocal = false; }
     tnp_core_1._.keys(hosts).forEach(function (hostName) {
         var v = hosts[hostName];
         v.name = hostName;
@@ -649,11 +730,16 @@ function parseHost(hosts, options) {
         tnp_core_1._.keys(hosts)
             .map(function (hostName) {
             var v = hosts[hostName];
+            var 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 ".concat(aliasesStr)
+                    : "".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(aliasesStr);
             }
-            return ("".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(v.aliases.join(' ')) +
-                " # ".concat(v.name, " ").concat(GENERATED));
+            return useLocal
+                ? "127.0.0.1 ".concat(aliasesStr)
+                : "".concat(v.disabled ? '#' : '').concat(v.ipOrDomain, " ").concat(aliasesStr, " # ").concat(v.name, " ").concat(GENERATED);
         })
             .join(EOL) +
         EOL +