@requestly/requestly-proxy 1.0.0

package/dist/components/proxy-middleware/index.js

@@ -0,0 +1,257 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIDDLEWARE_TYPE = void 0;
+// Move Proxy code to this package
+var net = require("net");
+const proxy_1 = __importDefault(require("../../lib/proxy"));
+const proxy_ctx_helper_1 = require("./helpers/proxy_ctx_helper");
+const rules_middleware_1 = __importDefault(require("./middlewares/rules_middleware"));
+const amiusing_middleware_1 = __importDefault(require("./middlewares/amiusing_middleware"));
+const logger_middleware_1 = __importDefault(require("./middlewares/logger_middleware"));
+const ssl_cert_middleware_1 = __importDefault(require("./middlewares/ssl_cert_middleware"));
+const ctx_rq_namespace_1 = __importDefault(require("./helpers/ctx_rq_namespace"));
+const http_helpers_1 = require("./helpers/http_helpers");
+const constants_1 = require("./constants");
+const requestly_core_1 = require("@requestly/requestly-core");
+// import SSLProxyingConfigFetcher from "renderer/lib/fetcher/ssl-proxying-config-fetcher";
+// import SSLProxyingManager from "../ssl-proxying/ssl-proxying-manager";
+exports.MIDDLEWARE_TYPE = {
+    AMIUSING: "AMIUSING",
+    RULES: "RULES",
+    LOGGER: "LOGGER",
+    SSL_CERT: "SSL_CERT",
+};
+class ProxyMiddlewareManager {
+    constructor(proxy, proxyConfig, rulesHelper, loggerService, sslConfigFetcher) {
+        this.init_config = (config = {}) => {
+            Object.keys(exports.MIDDLEWARE_TYPE).map((middleware_key) => {
+                this.config[middleware_key] =
+                    config[middleware_key] !== undefined ? !!config[middleware_key] : true;
+            });
+        };
+        this.init = (config = {}) => {
+            this.init_config(config);
+            this.request_handler_idx = 42;
+            if (!this.proxy) {
+                return;
+            }
+            this.init_handlers();
+        };
+        /*
+          This is used to init a sequential handler
+        */
+        this.init_request_handler = (fn, is_detachable = false) => {
+            if (is_detachable) {
+                const idx = this.request_handler_idx;
+                this.proxy.onRequestSetArray(idx, fn);
+                this.request_handler_idx++;
+                return idx;
+            }
+            this.proxy.onRequest(fn);
+        };
+        this.init_amiusing_handler = () => {
+            const amiusing_middleware = new amiusing_middleware_1.default(this.config[exports.MIDDLEWARE_TYPE.AMIUSING]);
+            this.init_request_handler((ctx, callback) => {
+                amiusing_middleware.on_request(ctx);
+                callback();
+            }, true);
+        };
+        this.init_ssl_cert_handler = () => {
+            const ssl_cert_middleware = new ssl_cert_middleware_1.default(this.config[exports.MIDDLEWARE_TYPE.SSL_CERT], this.proxyConfig.rootCertPath);
+            this.init_request_handler((ctx, callback) => {
+                ssl_cert_middleware.on_request(ctx);
+                callback();
+            }, true);
+        };
+        this.init_main_handler = () => {
+            const self = this;
+            const is_detachable = true;
+            const logger_middleware = new logger_middleware_1.default(this.config[exports.MIDDLEWARE_TYPE.LOGGER], this.loggerService);
+            const idx = this.init_request_handler((ctx, callback) => __awaiter(this, void 0, void 0, function* () {
+                ctx.rq = new ctx_rq_namespace_1.default();
+                ctx.rq.set_original_request((0, proxy_ctx_helper_1.get_request_options)(ctx));
+                ctx.proxyToServerRequestOptions.rejectUnauthorized = false;
+                // Figure out a way to enable/disable middleware dynamically
+                // instead of re-initing this again
+                const rules_middleware = new rules_middleware_1.default(this.config[exports.MIDDLEWARE_TYPE.RULES], ctx, this.rulesHelper);
+                let request_body_chunks = [];
+                ctx.onRequestData(function (ctx, chunk, callback) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (chunk) {
+                            request_body_chunks.push(chunk);
+                        }
+                        return callback(null, null); // don't write chunks to client Request
+                    });
+                });
+                ctx.onRequestEnd(function (ctx, callback) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        let body = new Buffer.concat(request_body_chunks);
+                        const contentTypeHeader = (0, proxy_ctx_helper_1.getRequestContentTypeHeader)(ctx);
+                        const contentType = (0, http_helpers_1.getContentType)(contentTypeHeader);
+                        const parsedBody = (0, http_helpers_1.bodyParser)(contentTypeHeader, body);
+                        // Request body before any modifications
+                        let pre_final_body = parsedBody || body.toString("utf8");
+                        ctx.rq.set_original_request({ body: pre_final_body });
+                        ctx.rq_request_body = pre_final_body;
+                        if (parsedBody && constants_1.RQ_INTERCEPTED_CONTENT_TYPES.includes(contentType)) {
+                            // Do modifications, if any
+                            const { action_result_objs, continue_request } = yield rules_middleware.on_request_end(ctx);
+                        }
+                        // Use the updated request
+                        ctx.proxyToServerRequest.write(ctx.rq_request_body);
+                        ctx.rq.set_final_request({ body: ctx.rq_request_body });
+                        return callback();
+                    });
+                });
+                ctx.onResponse((ctx, callback) => __awaiter(this, void 0, void 0, function* () {
+                    ctx.rq.set_original_response((0, proxy_ctx_helper_1.get_response_options)(ctx));
+                    const { action_result_objs, continue_request: continue_response } = yield rules_middleware.on_response(ctx);
+                    if (continue_response) {
+                        return callback();
+                    }
+                }));
+                let response_body_chunks = [];
+                ctx.onResponseData(function (ctx, chunk, callback) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (chunk) {
+                            response_body_chunks.push(chunk);
+                        }
+                        return callback(null, null); // don't write chunks to client response
+                    });
+                });
+                ctx.onResponseEnd(function (ctx, callback) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        let body = new Buffer.concat(response_body_chunks);
+                        const contentTypeHeader = (0, proxy_ctx_helper_1.getResponseContentTypeHeader)(ctx);
+                        const contentType = (0, http_helpers_1.getContentType)(contentTypeHeader);
+                        const parsedBody = (0, http_helpers_1.bodyParser)(contentTypeHeader, body);
+                        ctx.rq_response_body = body;
+                        ctx.rq_response_status_code = (0, proxy_ctx_helper_1.getResponseStatusCode)(ctx);
+                        if (constants_1.RQ_INTERCEPTED_CONTENT_TYPES.includes(contentType) && parsedBody) {
+                            ctx.rq.set_original_response({ body: parsedBody });
+                            // Body and status code before any modifications
+                            ctx.rq_response_body = parsedBody;
+                            const { action_result_objs, continue_request } = yield rules_middleware.on_response_end(ctx);
+                            // ctx.rq_response_body, ctx.rq_response_status_code after modifications
+                            // TODO: @sahil to investigate why this is need
+                            // Remove some conflicting headers like content-length, if any
+                            delete (0, proxy_ctx_helper_1.getResponseHeaders)(ctx)["content-length"];
+                        }
+                        ctx.proxyToClientResponse.writeHead(ctx.rq_response_status_code || (0, proxy_ctx_helper_1.getResponseStatusCode)(ctx), (0, proxy_ctx_helper_1.getResponseHeaders)(ctx));
+                        ctx.proxyToClientResponse.write(ctx.rq_response_body);
+                        ctx.rq.set_final_response(Object.assign(Object.assign({}, (0, proxy_ctx_helper_1.get_response_options)(ctx)), { status_code: ctx.rq_response_status_code || (0, proxy_ctx_helper_1.getResponseStatusCode)(ctx), body: ctx.rq_response_body }));
+                        logger_middleware.send_network_log(ctx, rules_middleware.action_result_objs, requestly_core_1.CONSTANTS.REQUEST_STATE.COMPLETE);
+                        return callback();
+                    });
+                });
+                // Remove headers that may conflict
+                delete (0, proxy_ctx_helper_1.getRequestHeaders)(ctx)["content-length"];
+                const { action_result_objs, continue_request } = yield rules_middleware.on_request(ctx);
+                ctx.rq.set_final_request((0, proxy_ctx_helper_1.get_request_options)(ctx));
+                // TODO: Removing this log for now. Will add this when support is added for upsert in firebase logs.
+                logger_middleware.send_network_log(ctx, rules_middleware.action_result_objs, requestly_core_1.CONSTANTS.REQUEST_STATE.LOADING);
+                //logger
+                if (continue_request) {
+                    return callback();
+                }
+            }), is_detachable);
+        };
+        this.init_ssl_tunneling_handler = () => {
+            this.proxy.onConnect((req, socket, head, callback) => __awaiter(this, void 0, void 0, function* () {
+                const host = req.url.split(":")[0];
+                const port = req.url.split(":")[1];
+                const origin = `https://${host}`;
+                const isSSLProxyingActive = this.sslProxyingManager.isSslProxyingActive(origin);
+                if (isSSLProxyingActive) {
+                    return callback();
+                }
+                // TODO: @sahil add logger here for CONNECT request
+                console.log("Tunnel to", req.url);
+                // Hack: For timing out tunnel in case of inclusionList/ExclusionList Change
+                global.rq.sslTunnelingSocketsMap[req.url] = socket;
+                var conn = net.connect({
+                    port: port,
+                    host: host,
+                    allowHalfOpen: false,
+                }, function () {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        conn.on("finish", () => {
+                            console.log(`Finish ${host}`);
+                            socket.destroy();
+                            delete global.rq.sslTunnelingSocketsMap[req.url];
+                        });
+                        socket.on("close", () => {
+                            console.log("Close");
+                            conn.end();
+                        });
+                        // socket.on('data', (data) => {
+                        //   // console.log("FROM SOCKET: " + data.toString("ascii") + "\n");
+                        //   console.log("FROM SOCKET: data");
+                        // });
+                        // conn.on('data', (data) => {
+                        //   // console.log("FROM CONN: " + data.toString("ascii") + "\n");
+                        //   console.log("FROM CONN: data");
+                        // });
+                        socket.write("HTTP/1.1 200 OK\r\n\r\n", "UTF-8", function () {
+                            conn.pipe(socket);
+                            socket.pipe(conn);
+                        });
+                    });
+                });
+                conn.on("error", function (err) {
+                    filterSocketConnReset(err, "PROXY_TO_SERVER_SOCKET");
+                });
+                socket.on("error", function (err) {
+                    filterSocketConnReset(err, "CLIENT_TO_PROXY_SOCKET");
+                });
+            }));
+            // Since node 0.9.9, ECONNRESET on sockets are no longer hidden
+            function filterSocketConnReset(err, socketDescription) {
+                if (err.errno === "ECONNRESET") {
+                    console.log("Got ECONNRESET on " + socketDescription + ", ignoring.");
+                }
+                else {
+                    console.log("Got unexpected error on " + socketDescription, err);
+                }
+            }
+        };
+        this.init_handlers = () => {
+            this.proxy.onRequestHandlers = [];
+            this.proxy.onConnectHandlers = [];
+            this.proxy.use(proxy_1.default.gunzip);
+            // this.init_ssl_tunneling_handler();
+            this.init_amiusing_handler();
+            this.init_ssl_cert_handler();
+            this.init_main_handler();
+        };
+        /*
+        {
+          AMIUSING: true,
+          PROXY: true,
+          LOGGER: true,
+          SSL_CERT: true
+        }
+        */
+        this.config = {};
+        this.init_config();
+        this.proxy = proxy;
+        this.proxyConfig = proxyConfig;
+        this.rulesHelper = rulesHelper;
+        this.loggerService = loggerService;
+        this.sslConfigFetcher = sslConfigFetcher;
+        // this.sslProxyingManager = new SSLProxyingManager(sslConfigFetcher);
+    }
+}
+exports.default = ProxyMiddlewareManager;

package/dist/components/proxy-middleware/middlewares/amiusing_middleware.d.ts

@@ -0,0 +1,6 @@
+export default AmisuingMiddleware;
+declare class AmisuingMiddleware {
+    constructor(is_active: any);
+    is_active: any;
+    on_request: (ctx: any) => Promise<boolean>;
+}

package/dist/components/proxy-middleware/middlewares/amiusing_middleware.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class AmisuingMiddleware {
+    constructor(is_active) {
+        this.on_request = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return true;
+            }
+            Object.assign(ctx.proxyToServerRequestOptions.headers, {
+                ["amiusingrequestly"]: "true",
+            });
+        });
+        this.is_active = is_active;
+    }
+}
+exports.default = AmisuingMiddleware;

package/dist/components/proxy-middleware/middlewares/logger_middleware.d.ts

@@ -0,0 +1,66 @@
+export default LoggerMiddleware;
+declare class LoggerMiddleware {
+    constructor(is_active: any, loggerService: any);
+    is_active: any;
+    loggerService: any;
+    generate_curl_from_har: (requestHarObject: any) => string;
+    send_network_log: (ctx: any, action_result_objs?: any[], requestState?: string) => void;
+    createLog: (ctx: any, action_result_objs?: any[], requestState?: string) => {
+        id: any;
+        timestamp: number;
+        finalHar: {
+            log: {
+                version: string;
+                creator: {};
+                browser: {};
+                pages: any[];
+                entries: {
+                    startedDateTime: string;
+                    request: {
+                        bodySize: number;
+                        headersSize: number;
+                        httpVersion: string;
+                        cookies: any[];
+                        headers: {
+                            name: string;
+                            value: any;
+                        }[];
+                        method: any;
+                        queryString: any[];
+                        url: string;
+                        postData: {
+                            mimeType: any;
+                            text: any;
+                        };
+                    };
+                    response: {
+                        status: any;
+                        httpVersion: string;
+                        cookies: any[];
+                        headers: {
+                            name: string;
+                            value: any;
+                        }[];
+                        content: {
+                            size: number;
+                            compression: number;
+                            mimeType: any;
+                            text: any;
+                            comment: string;
+                        };
+                        headersSize: number;
+                        bodySize: number;
+                        comment: string;
+                    };
+                    cache: {};
+                    timings: {};
+                    comment: string;
+                }[];
+                comment: string;
+            };
+        };
+        requestShellCurl: string;
+        actions: any[];
+        requestState: string;
+    };
+}

package/dist/components/proxy-middleware/middlewares/logger_middleware.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const httpsnippet_1 = __importDefault(require("httpsnippet"));
+const utils_1 = require("../rule_action_processor/utils");
+const harObectCreator_1 = require("../helpers/harObectCreator");
+const url = require("url");
+class LoggerMiddleware {
+    constructor(is_active, loggerService) {
+        this.generate_curl_from_har = (requestHarObject) => {
+            if (!requestHarObject) {
+                return "";
+            }
+            let requestCurl = "";
+            try {
+                const harObject = (0, lodash_1.cloneDeep)(requestHarObject);
+                requestCurl = new httpsnippet_1.default(harObject).convert("shell", "curl", {
+                    indent: " ",
+                });
+            }
+            catch (err) {
+                console.error(`LoggerMiddleware.generate_curl_from_har Error: ${err}`);
+            }
+            return requestCurl;
+        };
+        this.send_network_log = (ctx, action_result_objs = [], requestState = "") => {
+            // let query_params_string;
+            // if (ctx.rq.final_request.query_params) {
+            //   query_params_string = JSON.stringify(ctx.rq.final_request.query_params);
+            // }
+            // const log = {
+            //   id: ctx.uuid,
+            //   timestamp: Math.floor(Date.now() / 1000),
+            //   url: url.parse(
+            //     (ctx.isSSL ? "https://" : "http://") +
+            //       ctx.clientToProxyRequest.headers.host +
+            //       ctx.clientToProxyRequest.url
+            //   ).href,
+            //   request: {
+            //     method: ctx.rq.final_request.method,
+            //     path: ctx.rq.final_request.host,
+            //     host: ctx.rq.final_request.host,
+            //     port: ctx.rq.final_request.port,
+            //     headers: ctx.rq.final_request.headers,
+            //     body: ctx.rq.final_request.body,
+            //     query_params: query_params_string,
+            //   },
+            //   requestShellCurl: this.generate_curl_from_har(
+            //     ctx.rq.final_request.requestHarObject
+            //   ),
+            //   response: {
+            //     statusCode: ctx.rq.final_response.status_code,
+            //     headers: ctx.rq.final_response.headers || {},
+            //     contentType:
+            //       (ctx.rq.final_response.headers &&
+            //         ctx.rq.final_response.headers["content-type"] &&
+            //         ctx.rq.final_response.headers["content-type"].includes(";") &&
+            //         ctx.rq.final_response.headers["content-type"].split(";")[0]) ||
+            //       (ctx.rq.final_response.headers &&
+            //         ctx.rq.final_response.headers["content-type"]),
+            //     body: ctx.rq.final_response.body || null,
+            //   },
+            //   actions: get_success_actions_from_action_results(action_result_objs),
+            // };
+            // ipcRenderer.send("log-network-request", log);
+            // TODO: Sending log for now. Ideally this should be har object
+            this.loggerService.addLog(this.createLog(ctx, action_result_objs, requestState), ctx.rq.final_request.headers || {});
+        };
+        this.createLog = (ctx, action_result_objs = [], requestState = "") => {
+            var _a, _b;
+            const protocol = ctx.isSSL ? "https" : "http";
+            const rqLog = {
+                id: ctx.uuid,
+                timestamp: Math.floor(Date.now() / 1000),
+                finalHar: (0, harObectCreator_1.createHar)(ctx.rq.final_request.headers, ctx.rq.final_request.method, protocol, ctx.rq.final_request.host, ctx.rq.final_request.path, ctx.rq.final_request.body, ctx.rq.final_response.status_code, ctx.rq.final_response.body, ctx.rq.final_response.headers || {}),
+                requestShellCurl: this.generate_curl_from_har((_b = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.rq) === null || _a === void 0 ? void 0 : _a.final_request) === null || _b === void 0 ? void 0 : _b.requestHarObject),
+                actions: (0, utils_1.get_success_actions_from_action_results)(action_result_objs),
+                requestState
+            };
+            return rqLog;
+        };
+        this.is_active = is_active;
+        this.loggerService = loggerService;
+    }
+}
+exports.default = LoggerMiddleware;

package/dist/components/proxy-middleware/middlewares/rules_middleware.d.ts

@@ -0,0 +1,40 @@
+export default RulesMiddleware;
+declare class RulesMiddleware {
+    constructor(is_active: any, ctx: any, rulesHelper: any);
+    is_active: any;
+    rule_processor_helper: RuleProcessorHelper;
+    rule_action_processor: RuleActionProcessor;
+    rulesHelper: any;
+    active_rules: any[];
+    on_request_actions: any[];
+    on_response_actions: any[];
+    action_result_objs: any[];
+    _init_request_data: (ctx: any) => void;
+    request_data: any;
+    _init_response_data: (ctx: any) => void;
+    response_data: {
+        response_headers: any;
+    };
+    _update_request_data: (data: any) => void;
+    _fetch_rules: () => Promise<void>;
+    _process_rules: (is_response?: boolean) => any;
+    _update_action_result_objs: (action_result_objs?: any[]) => void;
+    on_request: (ctx: any) => Promise<any[] | {
+        action_result_objs: any[];
+        continue_request: boolean;
+    }>;
+    on_response: (ctx: any) => Promise<any[] | {
+        action_result_objs: any[];
+        continue_request: boolean;
+    }>;
+    on_request_end: (ctx: any) => Promise<any[] | {
+        action_result_objs: any[];
+        continue_request: boolean;
+    }>;
+    on_response_end: (ctx: any) => Promise<any[] | {
+        action_result_objs: any[];
+        continue_request: boolean;
+    }>;
+}
+import RuleProcessorHelper from "../helpers/rule_processor_helper";
+import RuleActionProcessor from "../rule_action_processor";

package/dist/components/proxy-middleware/middlewares/rules_middleware.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_ctx_helper_1 = require("../helpers/proxy_ctx_helper");
+const rule_processor_helper_1 = __importDefault(require("../helpers/rule_processor_helper"));
+const rule_action_processor_1 = __importDefault(require("../rule_action_processor"));
+class RulesMiddleware {
+    constructor(is_active, ctx, rulesHelper) {
+        this._init_request_data = (ctx) => {
+            var _a, _b, _c, _d;
+            this.request_data = {
+                request_url: (0, proxy_ctx_helper_1.get_request_url)(ctx),
+                request_headers: (0, proxy_ctx_helper_1.get_original_request_headers)(ctx),
+                query_params: (_b = (_a = ctx.rq) === null || _a === void 0 ? void 0 : _a.original_request) === null || _b === void 0 ? void 0 : _b.query_params,
+                method: (_d = (_c = ctx.rq) === null || _c === void 0 ? void 0 : _c.original_request) === null || _d === void 0 ? void 0 : _d.method,
+            };
+            this.rule_processor_helper.init_request_data(this.request_data);
+        };
+        this._init_response_data = (ctx) => {
+            this.response_data = {
+                response_headers: (0, proxy_ctx_helper_1.get_original_response_headers)(ctx),
+            };
+            this.rule_processor_helper.init_response_data(this.response_data);
+        };
+        this._update_request_data = (data) => {
+            this.request_data = Object.assign(Object.assign({}, this.request_data), data);
+            this.rule_processor_helper.init_request_data(this.request_data);
+        };
+        this._fetch_rules = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.active_rules = yield this.rulesHelper.get_rules(true, ((_a = this.request_data) === null || _a === void 0 ? void 0 : _a.request_headers) || {});
+        });
+        /*
+          @return: actions[]
+        */
+        this._process_rules = (is_response = false) => {
+            // https://github.com/requestly/requestly-master/issues/686
+            // 1 time processing if we fix this issue
+            let rule_actions = this.rule_processor_helper.process_rules(this.active_rules, is_response);
+            // Filter out all the null actions
+            rule_actions = rule_actions.filter((action) => !!action);
+            return rule_actions;
+        };
+        this._update_action_result_objs = (action_result_objs = []) => {
+            if (action_result_objs) {
+                this.action_result_objs =
+                    this.action_result_objs.concat(action_result_objs);
+            }
+        };
+        this.on_request = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return [];
+            }
+            // TODO: Remove this. Hack to fix rule not fetching first time.
+            yield this._fetch_rules();
+            this.on_request_actions = this._process_rules();
+            const { action_result_objs, continue_request } = yield this.rule_action_processor.process_actions(this.on_request_actions, ctx);
+            this._update_action_result_objs(action_result_objs);
+            return { action_result_objs, continue_request };
+        });
+        this.on_response = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return [];
+            }
+            this._init_response_data(ctx);
+            this.on_response_actions = this._process_rules(true);
+            const { action_result_objs, continue_request } = yield this.rule_action_processor.process_actions(this.on_response_actions, ctx);
+            this._update_action_result_objs(action_result_objs);
+            return { action_result_objs, continue_request };
+        });
+        this.on_request_end = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return [];
+            }
+            this._update_request_data({ request_body: ctx.rq.get_json_request_body() });
+            const { action_result_objs, continue_request } = yield this.rule_action_processor.process_actions(this.on_request_actions, ctx);
+            this._update_action_result_objs(action_result_objs);
+            return { action_result_objs, continue_request };
+        });
+        this.on_response_end = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return [];
+            }
+            const { action_result_objs, continue_request } = yield this.rule_action_processor.process_actions(this.on_response_actions, ctx);
+            this._update_action_result_objs(action_result_objs);
+            return { action_result_objs, continue_request };
+        });
+        this.is_active = is_active;
+        this.rule_processor_helper = new rule_processor_helper_1.default();
+        this.rule_action_processor = new rule_action_processor_1.default();
+        this.rulesHelper = rulesHelper;
+        this._init_request_data(ctx);
+        this.active_rules = [];
+        this._fetch_rules();
+        // Keeping these 2 separate because of request and response headers
+        // from rule processor are triggers during different proxy hooks.
+        // These can be combined into 1 if we change the actions returned
+        // by modify headers rule processor
+        // TODO: @sahil865gupta UPGRADE MODIFY HEADER ACTIONS
+        // https://github.com/requestly/requestly-master/issues/686
+        this.on_request_actions = [];
+        this.on_response_actions = [];
+        this.action_result_objs = [];
+    }
+}
+exports.default = RulesMiddleware;

package/dist/components/proxy-middleware/middlewares/ssl_cert_middleware.d.ts

@@ -0,0 +1,7 @@
+export default SslCertMiddleware;
+declare class SslCertMiddleware {
+    constructor(is_active: any, rootCertPath: any);
+    is_active: any;
+    rootCertPath: any;
+    on_request: (ctx: any) => Promise<boolean>;
+}

package/dist/components/proxy-middleware/middlewares/ssl_cert_middleware.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+class SslCertMiddleware {
+    constructor(is_active, rootCertPath) {
+        this.on_request = (ctx) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.is_active) {
+                return true;
+            }
+            if (ctx.clientToProxyRequest.headers.host == "requestly.io" &&
+                ctx.clientToProxyRequest.url.indexOf("/ssl") == 0) {
+                ctx.proxyToClientResponse.writeHead(200, {
+                    "Content-Type": "text/plain",
+                    "Content-Disposition": "attachment;filename=RequestlyCA.pem.crt",
+                });
+                const certificateString = fs.readFileSync(this.rootCertPath);
+                ctx.proxyToClientResponse.end(certificateString);
+            }
+        });
+        this.is_active = is_active;
+        this.rootCertPath = rootCertPath;
+    }
+}
+exports.default = SslCertMiddleware;

package/dist/components/proxy-middleware/rule_action_processor/handle_mixed_response.d.ts

@@ -0,0 +1,14 @@
+export default handleMixedResponse;
+declare function handleMixedResponse(ctx: any, destinationUrl: any): Promise<{
+    status: boolean;
+    response_data: {
+        headers: {
+            "Cache-Control": string;
+        };
+        status_code: number;
+        body: any;
+    };
+} | {
+    status: boolean;
+    response_data?: undefined;
+}>;