@push.rocks/smartproxy 3.0.60 → 3.0.61

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './smartproxy.classes.smartproxy';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./smartproxy.classes.smartproxy"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHFEQUFnRCJ9

package/dist/smartproxy.classes.proxyworker.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import * as plugins from './smartproxy.plugins';
+import { SmartproxyRouter } from './smartproxy.classes.router';
+export declare class ProxyWorker {
+    proxyConfigs: plugins.tsclass.network.IReverseProxyConfig[];
+    httpsServer: plugins.https.Server;
+    port: number;
+    router: SmartproxyRouter;
+    socketMap: plugins.lik.Objectmap<plugins.net.Socket>;
+    /**
+     * starts the proxyInstance
+     */
+    start(): Promise<void>;
+    updateProxyConfigs(proxyConfigsArg: plugins.tsclass.network.IReverseProxyConfig[]): Promise<void>;
+    stop(): Promise<void>;
+}
+declare const proxyWorkerCalls: {
+    stop: () => Promise<void>;
+    start: () => Promise<void>;
+    updateReverseConfigs: (configArray: plugins.tsclass.network.IReverseProxyConfig[]) => Promise<void>;
+};
+export declare type TProxyWorkerCalls = typeof proxyWorkerCalls;
+export {};

package/dist/smartproxy.classes.proxyworker.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const smartspawn_1 = require("@pushrocks/smartspawn");
+const plugins = __importStar(require("./smartproxy.plugins"));
+const smartproxy_classes_router_1 = require("./smartproxy.classes.router");
+class ProxyWorker {
+    constructor() {
+        this.proxyConfigs = [];
+        this.port = 8001;
+        this.router = new smartproxy_classes_router_1.SmartproxyRouter();
+        this.socketMap = new plugins.lik.Objectmap();
+    }
+    /**
+     * starts the proxyInstance
+     */
+    async start() {
+        this.httpsServer = plugins.https.createServer(
+        // ================
+        // Spotted this keypair in the code?
+        // Don't get exited:
+        // It is an invalid default keypair.
+        // For proper requests custom domain level keypairs are used that are provided in the reverse config
+        // ================
+        {
+            key: `-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+    `,
+            cert: `-----BEGIN CERTIFICATE-----
+MIIEljCCAn4CCQDY+ZbC9FASVjANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJE
+RTAeFw0xOTA5MjAxNjAxNDRaFw0yMDA5MTkxNjAxNDRaMA0xCzAJBgNVBAYTAkRF
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4thf9JEK/epoXt8hFr8t
+pkRzmaEkgbSKoOga3uGXDLvdNf3BzSIxZ8pzRhZfUnutcmW1thdz3wre/pEJR7oN
+QsfixbLL8/oS5QeXKiUGX0Ssfdg4W0TsoLcRva+1AZsf38MfiUPhzh1/UW/rMywW
+asazQwRZdkkXb4nKJ2IFZx22qnAD4/5Sug+sfeKoFBF/rzI2yK7rognt7kW2LHv6
+rswHnZ1Z2P/gbhlZ/EhG9hFVRZwRLDscWKcuWcxkePDt2J1pDNqD6SYa6ZjGC3AE
+TJw5iEA1bLQ9YvjDNpVYcf6ZvcSilIFjSQu5cs9sUbHGeKTrS5HzfeJXh1PfJyL8
+X0Hu7UBSjfSudso3baE9FGiBFBW2cnXZKDZGtV8eq/qxPetOOgS09pVbNP6508WV
+BR+rz98/VDZLZqcbZ2UpOuz4+kAKmbYE9GplxKQZZO7wWEox7Mid/uUdcqEo4QKn
+no6ujOuzQzn5a2oOS0k5Hk3uHapNJWlW9YI3LHtfADpYH+6cOR+/c3JWBzQJ6AD7
+muvNzA9mWXeHqLxMMP4pkmb7otzZYrEkodUqJgAQxcYhGh6XsCPfJ/D9RN734OJc
+gleVXFI8Kz455HxCW19XNfz16k7T6kqhZ/6SOBbkxEuqg7oEthAP109ZZzgx4oDo
+hQsw24TjLkI4SPIc7nr60UUCAwEAATANBgkqhkiG9w0BAQsFAAOCAgEAu0+zrg0C
+mlSv4Yi24OwB7TBvx+WHesl1IilCUdTiiUMo3NumvsU9Dr3Jkd0jGqYI0eyH4gIt
+KrhAveXfEw7tAOEHiYicmAdIFtyzh++ZWb8mgbBeqij1MP/76Jv+cc0lUqpfRo/A
+qytAsPAILuyL1o1jh28JHcq+v+WYn/FEhjUlH6emhGKGlsAjhUPjzK8MEshNolhj
+t2UXw9WB5B2xWvrqlNMy0F3NAZBkZ/+k21HZo6FmVi+q6OEGcOo7wJt6wrH/lko9
+LxX96GC1JoN1Pfr2FoTKy1WHzrSfyGmDIUCrbaYQ58UuMOR+5eIPPdkf/030u5eX
+xXhF2fBujD57E2zQGh/l2MrOjamcSo0+wYhOqlX3WNdaKNAzPqloBnF6w7eqLYde
+h9He39ySmxjENwv3miOjEP1sBeMBSRfL/ckEonfK5uJgYA5nVMQ3ojUeDMZzLfFE
+Ue2WHt+uPyYk7mMZfOrK2uHzI2/Coqj7lbfRodFwj+fCArYBck2NZannDPKA6X8V
+TzJTbTCteOUUJTrcfZ0gGhGkF4nYLmX5OI+TPqrDJf0fZ+mzAEHzDDVXcBYpYRDr
+r8d9QwrK+WaqVi2ofbMfMByVF72jgeJNa4nxwT9bVbu/Q1T2Lt+YPb4pQ7yCoUgS
+JNj2Dr5H0XoLFFnvuvzcRbhlJ9J67JzR+7g=
+-----END CERTIFICATE-----
+    `
+        }, async (req, res) => {
+            console.log('got request');
+            const destinationConfig = this.router.routeReq(req);
+            // endRequest function
+            const endRequest = (statusArg = 404, messageArg = 'This route is not available on this server.', headers = {}) => {
+                res.writeHead(statusArg, messageArg);
+                res.end(messageArg);
+            };
+            // authentication
+            if (destinationConfig.authentication) {
+                const authInfo = destinationConfig.authentication;
+                switch (authInfo.type) {
+                    case 'Basic':
+                        const authHeader = req.headers.authorization;
+                        if (authHeader) {
+                            if (!authHeader.includes('Basic ')) {
+                                return endRequest(401, 'Authentication required', {
+                                    'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"'
+                                });
+                            }
+                            const authStringBase64 = req.headers.authorization.replace('Basic ', '');
+                            const authString = plugins.smartstring.base64.decode(authStringBase64);
+                            const userPassArray = authString.split(':');
+                            const user = userPassArray[0];
+                            const pass = userPassArray[1];
+                            if (user === authInfo.user && pass === authInfo.pass) {
+                                console.log('request successfully authenticated');
+                            }
+                            else {
+                                return endRequest(403, 'Forbidden: Wrong credentials');
+                            }
+                        }
+                        break;
+                    default:
+                        return endRequest(403, 'Forbidden: unsupported authentication method configured. Please report to the admin.');
+                }
+            }
+            let destinationUrl;
+            if (destinationConfig) {
+                destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${req.url}`;
+            }
+            else {
+                return endRequest();
+            }
+            console.log(destinationUrl);
+            const response = await plugins.smartrequest.request(destinationUrl, {
+                method: req.method,
+                headers: req.headers
+            }, true, // lets make this streaming
+            // lets make this streaming
+            request => {
+                req.on('data', data => {
+                    request.write(data);
+                });
+                req.on('end', data => {
+                    request.end();
+                });
+            });
+            res.statusCode = response.statusCode;
+            console.log(response.statusCode);
+            for (const header of Object.keys(response.headers)) {
+                res.setHeader(header, response.headers[header]);
+            }
+            response.on('data', data => {
+                res.write(data);
+            });
+            response.on('end', () => {
+                res.end();
+            });
+        });
+        // Enable websockets
+        const wss = new plugins.ws.Server({ server: this.httpsServer });
+        wss.on('connection', (ws) => {
+            console.log('got connection for wsc');
+            const wscConnected = plugins.smartpromise.defer();
+            const wsc = new plugins.wsDefault(this.router.routeWs(ws), {
+                headers: {
+                    Host: ws.url
+                }
+            });
+            wsc.on('open', () => {
+                wscConnected.resolve();
+            });
+            ws.on('message', async (message) => {
+                await wscConnected.promise;
+                wsc.emit('message', message);
+            });
+            wsc.on('message', message => {
+                ws.emit('message', message);
+            });
+            // handle closing
+            ws.on('close', message => {
+                wsc.close();
+            });
+            wsc.on('close', message => {
+                ws.close();
+            });
+        });
+        this.httpsServer.keepAliveTimeout = 61000;
+        this.httpsServer.headersTimeout = 65000;
+        this.httpsServer.on('connection', connection => {
+            this.socketMap.add(connection);
+            connection.on('close', () => {
+                this.socketMap.remove(connection);
+            });
+        });
+        this.httpsServer.listen(this.port);
+        console.log(`ProxyWorker -> OK: now listening for new connections on port ${this.port}`);
+    }
+    async updateProxyConfigs(proxyConfigsArg) {
+        this.proxyConfigs = proxyConfigsArg;
+        this.router.setNewProxyConfigs(proxyConfigsArg);
+        for (const hostCandidate of this.proxyConfigs) {
+            // console.log(hostCandidate);
+            this.httpsServer.addContext(hostCandidate.hostName, {
+                cert: hostCandidate.publicKey,
+                key: hostCandidate.privateKey
+            });
+        }
+        /* this.httpsServer.close();
+        this.httpsServer.listen(this.port); */
+    }
+    async stop() {
+        const done = plugins.smartpromise.defer();
+        this.httpsServer.close(() => {
+            done.resolve();
+        });
+        await this.socketMap.forEach(async (socket) => {
+            socket.destroy();
+        });
+        await done.promise;
+    }
+}
+exports.ProxyWorker = ProxyWorker;
+const proxyWorkerInstance = new ProxyWorker();
+// the following is interesting for the master process only
+const proxyWorkerCalls = {
+    stop: async () => {
+        await proxyWorkerInstance.stop();
+    },
+    start: async () => {
+        await proxyWorkerInstance.start();
+    },
+    updateReverseConfigs: async (configArray) => {
+        await proxyWorkerInstance.updateProxyConfigs(configArray);
+    }
+};
+smartspawn_1.expose(proxyWorkerCalls);
+console.log('ProxyWorker initialized');
+//# sourceMappingURL=data:application/json;base64,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

package/dist/smartproxy.classes.router.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="ws" />
+import * as plugins from './smartproxy.plugins';
+export declare class SmartproxyRouter {
+    reverseProxyConfigs: plugins.tsclass.network.IReverseProxyConfig[];
+    /**
+     * sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg
+     */
+    setNewProxyConfigs(reverseCandidatesArg: plugins.tsclass.network.IReverseProxyConfig[]): void;
+    /**
+     * routes a request
+     */
+    routeReq(req: plugins.http.IncomingMessage): plugins.tsclass.network.IReverseProxyConfig;
+    routeWs(ws: plugins.wsDefault): string;
+}

package/dist/smartproxy.classes.router.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = __importStar(require("./smartproxy.plugins"));
+class SmartproxyRouter {
+    constructor() {
+        this.reverseProxyConfigs = [];
+    }
+    /**
+     * sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg
+     */
+    setNewProxyConfigs(reverseCandidatesArg) {
+        this.reverseProxyConfigs = reverseCandidatesArg;
+    }
+    /**
+     * routes a request
+     */
+    routeReq(req) {
+        const originalHost = req.headers.host;
+        const correspodingReverseProxyConfig = this.reverseProxyConfigs.find(reverseConfig => {
+            return reverseConfig.hostName === originalHost;
+        });
+        return correspodingReverseProxyConfig;
+    }
+    routeWs(ws) {
+        const originalHost = plugins.url.parse(ws.url).host;
+        const correspodingReverseProxyConfig = this.reverseProxyConfigs.find(reverseConfig => {
+            return reverseConfig.hostName === originalHost;
+        });
+        return correspodingReverseProxyConfig.destinationIp;
+    }
+}
+exports.SmartproxyRouter = SmartproxyRouter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRwcm94eS5jbGFzc2VzLnJvdXRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0cHJveHkuY2xhc3Nlcy5yb3V0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsOERBQWdEO0FBRWhELE1BQWEsZ0JBQWdCO0lBQTdCO1FBQ1Msd0JBQW1CLEdBQWtELEVBQUUsQ0FBQztJQTRCakYsQ0FBQztJQTFCQzs7O09BR0c7SUFDSSxrQkFBa0IsQ0FBQyxvQkFBbUU7UUFDM0YsSUFBSSxDQUFDLG1CQUFtQixHQUFHLG9CQUFvQixDQUFDO0lBQ2xELENBQUM7SUFFRDs7T0FFRztJQUNJLFFBQVEsQ0FBQyxHQUFpQztRQUMvQyxNQUFNLFlBQVksR0FBRyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQztRQUN0QyxNQUFNLDhCQUE4QixHQUFHLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLEVBQUU7WUFDbkYsT0FBTyxhQUFhLENBQUMsUUFBUSxLQUFLLFlBQVksQ0FBQztRQUNqRCxDQUFDLENBQUMsQ0FBQztRQUNILE9BQU8sOEJBQThCLENBQUM7SUFDeEMsQ0FBQztJQUVNLE9BQU8sQ0FBQyxFQUFxQjtRQUNsQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO1FBQ3BELE1BQU0sOEJBQThCLEdBQUcsSUFBSSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsRUFBRTtZQUNuRixPQUFPLGFBQWEsQ0FBQyxRQUFRLEtBQUssWUFBWSxDQUFDO1FBQ2pELENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyw4QkFBOEIsQ0FBQyxhQUFhLENBQUM7SUFDdEQsQ0FBQztDQUNGO0FBN0JELDRDQTZCQyJ9

package/dist/smartproxy.classes.smartproxy.d.ts

@@ -0,0 +1,17 @@
+import * as plugins from './smartproxy.plugins';
+import { TProxyWorkerCalls } from './smartproxy.classes.proxyworker';
+import { TPortProxyCalls } from './smartproxy.portproxy';
+export interface ISmartProxyOptions {
+    port?: number;
+}
+export declare class SmartProxy {
+    smartsystem: plugins.smartsystem.Smartsystem;
+    reverseConfigs: plugins.tsclass.network.IReverseProxyConfig[];
+    proxyWorkerFunctions: plugins.smartspawn.ModuleThread<TProxyWorkerCalls>;
+    portProxyFunctions: plugins.smartspawn.ModuleThread<TPortProxyCalls>;
+    options: ISmartProxyOptions;
+    constructor(optionsArg?: ISmartProxyOptions);
+    updateReversConfigs(reverseConfigsArg: plugins.tsclass.network.IReverseProxyConfig[]): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/smartproxy.classes.smartproxy.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = __importStar(require("./smartproxy.plugins"));
+class SmartProxy {
+    constructor(optionsArg = {}) {
+        this.smartsystem = new plugins.smartsystem.Smartsystem();
+        this.reverseConfigs = [];
+        this.options = optionsArg;
+    }
+    async updateReversConfigs(reverseConfigsArg) {
+        // TODO search for old hostCandidates with that target
+        this.reverseConfigs = reverseConfigsArg;
+        if (this.proxyWorkerFunctions) {
+            await this.proxyWorkerFunctions.updateReverseConfigs(this.reverseConfigs);
+        }
+    }
+    async start() {
+        this.proxyWorkerFunctions = await plugins.smartspawn.spawn(new plugins.smartspawn.Worker('./smartproxy.classes.proxyworker'));
+        this.proxyWorkerFunctions.updateReverseConfigs(this.reverseConfigs);
+        this.portProxyFunctions = await plugins.smartspawn.spawn(new plugins.smartspawn.Worker('./smartproxy.portproxy'));
+        await this.portProxyFunctions.start(this.options.port);
+        await this.proxyWorkerFunctions.start();
+        console.log('successfully spawned portproxy and proxyworkers!');
+    }
+    async stop() {
+        await this.proxyWorkerFunctions.stop();
+        await plugins.smartspawn.Thread.terminate(this.proxyWorkerFunctions);
+        console.log('proxy worker stopped');
+        await this.portProxyFunctions.stop();
+        await plugins.smartspawn.Thread.terminate(this.portProxyFunctions);
+        console.log('portproxy stopped');
+        console.log('Terminated all childs!');
+    }
+}
+exports.SmartProxy = SmartProxy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRwcm94eS5jbGFzc2VzLnNtYXJ0cHJveHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHByb3h5LmNsYXNzZXMuc21hcnRwcm94eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSw4REFBZ0Q7QUFTaEQsTUFBYSxVQUFVO0lBUXJCLFlBQVksYUFBaUMsRUFBRTtRQVB4QyxnQkFBVyxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNwRCxtQkFBYyxHQUFrRCxFQUFFLENBQUM7UUFPeEUsSUFBSSxDQUFDLE9BQU8sR0FBRyxVQUFVLENBQUM7SUFDNUIsQ0FBQztJQUVNLEtBQUssQ0FBQyxtQkFBbUIsQ0FDOUIsaUJBQWdFO1FBRWhFLHNEQUFzRDtRQUN0RCxJQUFJLENBQUMsY0FBYyxHQUFHLGlCQUFpQixDQUFDO1FBQ3hDLElBQUksSUFBSSxDQUFDLG9CQUFvQixFQUFFO1lBQzdCLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztTQUMzRTtJQUNILENBQUM7SUFFTSxLQUFLLENBQUMsS0FBSztRQUNoQixJQUFJLENBQUMsb0JBQW9CLEdBQUcsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FDeEQsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxrQ0FBa0MsQ0FBQyxDQUNsRSxDQUFDO1FBQ0YsSUFBSSxDQUFDLG9CQUFvQixDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUVwRSxJQUFJLENBQUMsa0JBQWtCLEdBQUcsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FDdEQsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxDQUN4RCxDQUFDO1FBRUYsTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDdkQsTUFBTSxJQUFJLENBQUMsb0JBQW9CLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFeEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxrREFBa0QsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3ZDLE1BQU0sT0FBTyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBQ3JFLE9BQU8sQ0FBQyxHQUFHLENBQUMsc0JBQXNCLENBQUMsQ0FBQztRQUNwQyxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNyQyxNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztRQUNuRSxPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDakMsT0FBTyxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7Q0FDRjtBQS9DRCxnQ0ErQ0MifQ==

package/dist/smartproxy.plugins.d.ts

@@ -0,0 +1,17 @@
+import * as http from 'http';
+import * as https from 'https';
+import * as net from 'net';
+import * as url from 'url';
+export { http, https, net, url };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };
+import * as lik from '@pushrocks/lik';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartspawn from '@pushrocks/smartspawn';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smartsystem from '@pushrocks/smartsystem';
+export { lik, smartrequest, smartpromise, smartspawn, smartstring, smartsystem };
+import * as ws from 'ws';
+import wsDefault from 'ws';
+export { wsDefault, ws };

package/dist/smartproxy.plugins.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// node native scope
+const http = __importStar(require("http"));
+exports.http = http;
+const https = __importStar(require("https"));
+exports.https = https;
+const net = __importStar(require("net"));
+exports.net = net;
+const url = __importStar(require("url"));
+exports.url = url;
+// tsclass scope
+const tsclass = __importStar(require("@tsclass/tsclass"));
+exports.tsclass = tsclass;
+// pushrocks scope
+const lik = __importStar(require("@pushrocks/lik"));
+exports.lik = lik;
+const smartpromise = __importStar(require("@pushrocks/smartpromise"));
+exports.smartpromise = smartpromise;
+const smartrequest = __importStar(require("@pushrocks/smartrequest"));
+exports.smartrequest = smartrequest;
+const smartspawn = __importStar(require("@pushrocks/smartspawn"));
+exports.smartspawn = smartspawn;
+const smartstring = __importStar(require("@pushrocks/smartstring"));
+exports.smartstring = smartstring;
+const smartsystem = __importStar(require("@pushrocks/smartsystem"));
+exports.smartsystem = smartsystem;
+// third party scope
+const ws = __importStar(require("ws"));
+exports.ws = ws;
+const ws_1 = __importDefault(require("ws"));
+exports.wsDefault = ws_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRwcm94eS5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRwcm94eS5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLG9CQUFvQjtBQUNwQiwyQ0FBNkI7QUFLcEIsb0JBQUk7QUFKYiw2Q0FBK0I7QUFJaEIsc0JBQUs7QUFIcEIseUNBQTJCO0FBR0wsa0JBQUc7QUFGekIseUNBQTJCO0FBRUEsa0JBQUc7QUFFOUIsZ0JBQWdCO0FBQ2hCLDBEQUE0QztBQUVuQywwQkFBTztBQUVoQixrQkFBa0I7QUFDbEIsb0RBQXNDO0FBTzdCLGtCQUFHO0FBTlosc0VBQXdEO0FBTTVCLG9DQUFZO0FBTHhDLHNFQUF3RDtBQUsxQyxvQ0FBWTtBQUoxQixrRUFBb0Q7QUFJVixnQ0FBVTtBQUhwRCxvRUFBc0Q7QUFHQSxrQ0FBVztBQUZqRSxvRUFBc0Q7QUFFYSxrQ0FBVztBQUU5RSxvQkFBb0I7QUFDcEIsdUNBQXlCO0FBR0wsZ0JBQUU7QUFGdEIsNENBQTJCO0FBRWxCLG9CQUZGLFlBQVMsQ0FFRSJ9

package/dist/smartproxy.portproxy.d.ts

@@ -0,0 +1,6 @@
+declare const portProxyCalls: {
+    start: (portArg?: number) => Promise<void>;
+    stop: () => Promise<void>;
+};
+export declare type TPortProxyCalls = typeof portProxyCalls;
+export {};

package/dist/smartproxy.portproxy.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = __importStar(require("./smartproxy.plugins"));
+const smartspawn_1 = require("@pushrocks/smartspawn");
+const net = __importStar(require("net"));
+let netServer;
+const portProxyCalls = {
+    start: async (portArg = 8000) => {
+        netServer = net
+            .createServer(from => {
+            const to = net.createConnection({
+                host: 'localhost',
+                port: 8001
+            });
+            from.pipe(to);
+            to.pipe(from);
+        })
+            .listen(portArg);
+        console.log(`PortProxy -> OK: Now listening on port ${portArg}`);
+    },
+    stop: async () => {
+        const done = plugins.smartpromise.defer();
+        netServer.close(() => {
+            done.resolve();
+        });
+        await done.promise;
+    }
+};
+smartspawn_1.expose(portProxyCalls);
+console.log('PortProxy Initialized');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRwcm94eS5wb3J0cHJveHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHByb3h5LnBvcnRwcm94eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSw4REFBZ0Q7QUFDaEQsc0RBQStDO0FBQy9DLHlDQUEyQjtBQUMzQixJQUFJLFNBQTZCLENBQUM7QUFFbEMsTUFBTSxjQUFjLEdBQUc7SUFDckIsS0FBSyxFQUFFLEtBQUssRUFBRSxPQUFPLEdBQUcsSUFBSSxFQUFFLEVBQUU7UUFDOUIsU0FBUyxHQUFHLEdBQUc7YUFDWixZQUFZLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDbkIsTUFBTSxFQUFFLEdBQUcsR0FBRyxDQUFDLGdCQUFnQixDQUFDO2dCQUM5QixJQUFJLEVBQUUsV0FBVztnQkFDakIsSUFBSSxFQUFFLElBQUk7YUFDWCxDQUFDLENBQUM7WUFDSCxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ2QsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNoQixDQUFDLENBQUM7YUFDRCxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbkIsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQ0FBMEMsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUNuRSxDQUFDO0lBQ0QsSUFBSSxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ2YsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMxQyxTQUFTLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRTtZQUNuQixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDakIsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDckIsQ0FBQztDQUNGLENBQUM7QUFHRixtQkFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0FBRXZCLE9BQU8sQ0FBQyxHQUFHLENBQUMsdUJBQXVCLENBQUMsQ0FBQyJ9

package/dist_ts/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts/00_commitinfo_data.js

@@ -1,9 +1,9 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '3.0.60',
+    version: '3.0.61',
     description: 'a proxy for handling high workloads of proxying'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGlEQUFpRDtDQUMvRCxDQUFBIn0=