Add request interceptor to sniff all incomming http traffic

Author: sudharsan-selvaraj

package-lock.json

@@ -110,6 +110,7 @@
     "jsonpath": "^1.1.1",
     "lodash": "^4.17.21",
     "minimatch": "^9.0.3",
+    "parse-headers": "^2.0.5",
     "regex-parser": "^2.3.0",
     "uuid": "^9.0.1",
     "yargs": "^17.7.2",

package.json

@@ -0,0 +1,60 @@
+import { ErrorCallback, IContext } from 'http-mitm-proxy';
+import stream from 'stream';
+import { constructURLFromRequest } from './utils/proxy';
+import responseDecoder from './response-decoder';
+import parseHeader from 'parse-headers';
+
+function interceptBody(writable: stream.Writable | undefined, callback: (value: any) => void) {
+  if (!writable) {
+    return callback(null);
+  }
+  const [originalWrite, originalEnd] = [writable.write, writable.end];
+  const chunks: Buffer[] = [];
+
+  (writable.write as unknown) = function (...args: any) {
+    chunks.push(typeof args[0] === 'string' ? Buffer.from(args[0]) : args[0]);
+    originalWrite.apply(writable, args);
+  };
+
+  (writable.end as unknown) = async function (...args: any) {
+    if (args[0]) {
+      chunks.push(typeof args[0] === 'string' ? Buffer.from(args[0]) : args[0]);
+    }
+    originalEnd.apply(writable, args);
+    callback(Buffer.concat(chunks).toString('utf8'));
+  };
+}
+
+function RequestInterceptor(requestCompletionCallback: (value: any) => void) {
+  return function (ctx: IContext, callback: ErrorCallback) {
+    ctx.use(responseDecoder);
+    const requestData = {} as any;
+    ctx.onRequestEnd((ctx, callback) => {
+      interceptBody(ctx.proxyToServerRequest, (requestBody) => {
+        requestData['postBody'] = requestBody;
+        requestData['requestHeaders'] = ctx.proxyToServerRequest?.getHeaders();
+      });
+      callback();
+    });
+
+    interceptBody(ctx.proxyToClientResponse, (response) => {
+      const { headers, url } = ctx.clientToProxyRequest;
+      const protocol = ctx.isSSL ? 'https://' : 'http://';
+      const _url = constructURLFromRequest({
+        host: headers.host!,
+        path: url!,
+        protocol,
+      });
+      const responseHeaders = parseHeader((ctx.proxyToClientResponse as any)?._header || '');
+      requestData['url'] = _url;
+      requestData['method'] = ctx.clientToProxyRequest.method;
+      requestData['responseBody'] = response;
+      requestData['responseHeaders'] = responseHeaders;
+
+      requestCompletionCallback(requestData);
+    });
+    callback();
+  };
+}
+
+export { RequestInterceptor };

src/interceptor.ts

@@ -14,6 +14,7 @@ import {
 } from './utils/proxy';
 import ResponseDecoder from './response-decoder';
 import { Mock } from './mock';
+import { RequestInterceptor } from './interceptor';
 
 export interface ProxyOptions {
   deviceUDID: string;
@@ -63,6 +64,13 @@ export class Proxy {
       forceSNI: true,
     };
 
+    this.httpProxy.onRequest(
+      RequestInterceptor((requestData: any) => {
+        // console.log('****** REQUEST **********');
+        // console.log(JSON.stringify(requestData, null, 2));
+        // console.log('****************************');
+      })
+    );
     this.httpProxy.onRequest(this.handleMockApiRequest.bind(this));
 
     await new Promise((resolve) => {

src/proxy.ts

@@ -81,10 +81,6 @@ export function modifyRequestBody(ctx: IContext, mockConfig: MockConfig) {
     if (mockConfig.updateRequestBody) {
       postBody = processBody(mockConfig.updateRequestBody, originalBody);
     }
-    if (postBody) {
-      console.log('************* REQUEST BODY **************************');
-      console.log(postBody);
-    }
     ctx.proxyToServerRequest?.setHeader('Content-Length', Buffer.byteLength(postBody));
     ctx.proxyToServerRequest?.write(postBody);
     callback();
@@ -100,7 +96,6 @@ export function modifyResponseBody(ctx: IContext, mockConfig: MockConfig) {
   ctx.onResponseEnd((ctx: IContext, callback: OnRequestDataCallback) => {
     const originalResponse = Buffer.concat(responseBodyChunks).toString('utf8');
     let responseBody = mockConfig.responseBody || originalResponse;
-    //console.log(originalResponse);
 
     if (mockConfig.statusCode) {
       ctx.proxyToClientResponse.writeHead(mockConfig.statusCode);