@dev-blinq/cucumber_client 1.0.1308-dev → 1.0.1308-stage

package/bin/client/recorderv3/index.js

@@ -4,10 +4,23 @@ import { BVTRecorder } from "./bvt_recorder.js";
 import { compareWithScenario } from "../code_gen/duplication_analysis.js";
 import { getAppDataDir } from "./app_dir.js";
 import { readdir } from "fs/promises";
+import socketLogger from "../utils/socket_logger.js";
 
 let port = process.env.EDITOR_PORT || 3003;
 const WS_URL = "http://localhost:" + port;
 
+const responseSize = (response) => {
+  try {
+    if (typeof response !== "string") {
+      return new Blob([JSON.stringify(response)]).size;
+    } else {
+      return new Blob([response]).size;
+    }
+  } catch {
+    return -1;
+  }
+};
+
 class PromisifiedSocketServer {
   constructor(socket, routes) {
     this.socket = socket;
@@ -16,7 +29,9 @@ class PromisifiedSocketServer {
   init() {
     this.socket.on("request", async (data) => {
       const { event, input, id, roomId, socketId } = data;
-      // console.log("request", { event, input, id, roomId, socketId });
+      if (event !== "recorderWindow.getCurrentChromiumPath") {
+        socketLogger.info("Received request", { event, input, id, roomId, socketId });
+      }
       try {
         const handler = this.routes[event];
         if (!handler) {
@@ -24,17 +39,19 @@ class PromisifiedSocketServer {
           return;
         }
         const response = await handler(input);
-        // console.log("response", { id, value: response, roomId, socketId });
+        if (event !== "recorderWindow.getCurrentChromiumPath") {
+          socketLogger.info(`Sending response for ${event}, ${responseSize(response)} bytes`);
+        }
         this.socket.emit("response", { id, value: response, roomId, socketId });
       } catch (error) {
-        console.log("request", JSON.stringify({ event, input, id, roomId, socketId }));
-        console.error("response", { id, error, roomId, socketId });
-        // console.error({
-        //   message: error?.message,
-        //   code: error?.code,
-        //   info: error?.info,
-        //   stack: error?.stack,
-        // })
+        socketLogger.error("Error handling request", {
+          event,
+          input,
+          id,
+          roomId,
+          socketId,
+          error: error instanceof Error ? `${error.message}\n${error.stack}` : error,
+        });
         this.socket.emit("response", {
           id,
           error: {
@@ -52,13 +69,16 @@ class PromisifiedSocketServer {
 }
 
 const init = ({ envName, projectDir, roomId, TOKEN }) => {
-  console.log("connecting to " + WS_URL);
+  console.log("Connecting to " + WS_URL);
   const socket = io(WS_URL);
+  socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
   socket.on("connect", () => {
-    // console.log('connected to server')
+    socketLogger.info("Connected to BVTRecorder server");
+    console.log("Connected to BVTRecorder server");
   });
   socket.on("disconnect", () => {
-    // console.log('disconnected from server')
+    socketLogger.info("Disconnected from server");
+    console.log("Disconnected from server");
   });
   socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
   const recorder = new BVTRecorder({
@@ -66,18 +86,20 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     projectDir,
     TOKEN,
     sendEvent: (event, data) => {
-      console.log("----", event, data, "roomId", roomId);
+      socketLogger.info("Sending event", { event, data, roomId });
       socket.emit(event, data, roomId);
     },
+    logger: socketLogger,
   });
   recorder
     .openBrowser()
     .then(() => {
-      // console.log("BVTRecorder.browserOpened");
+      socketLogger.info("BVTRecorder.browserOpened");
       socket.emit("BVTRecorder.browserOpened", null, roomId);
     })
     .catch((e) => {
-      socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+      socketLogger.error("BVTRecorder.browserLaunchFailed", e);
+      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
     });
   const timeOutForFunction = async (promise, timeout = 5000) => {
     const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
@@ -87,6 +109,7 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       return res;
     } catch (error) {
       console.error(error);
+      socketLogger.error(error);
       throw error;
     }
   };
@@ -96,10 +119,13 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       return recorder
         .openBrowser(input)
         .then(() => {
+          socketLogger.info("BVTRecorder.browserOpened");
+          console.info("BVTRecorder.browserOpened");
           socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
         })
         .catch((e) => {
-          console.error(e);
+          socketLogger.error("Error opening browser", e);
+          console.error("BVTRecorder.browserLaunchFailed", e);
           socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
         });
     },
@@ -110,10 +136,13 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       return recorder
         .reOpenBrowser(input)
         .then(() => {
-          // console.log("BVTRecorder.browserOpened");
+          socketLogger.info("BVTRecorder.browserOpened");
+          console.log("BVTRecorder.browserOpened");
           socket.emit("BVTRecorder.browserOpened", null, roomId);
         })
-        .catch(() => {
+        .catch((e) => {
+          socketLogger.info("BVTRecorder.browserLaunchFailed");
+          console.error("BVTRecorder.browserLaunchFailed", e);
           socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
         });
     },
@@ -194,6 +223,12 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.abortExecution": async (input) => {
       return recorder.abortExecution(input);
     },
+    "recorderWindow.pauseExecution": async (input) => {
+      return recorder.pauseExecution(input);
+    },
+    "recorderWindow.resumeExecution": async (input) => {
+      return recorder.resumeExecution(input);
+    },
     "recorderWindow.loadExistingScenario": async (input) => {
       return recorder.loadExistingScenario(input);
     },
@@ -206,9 +241,7 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.getSnapshotFiles": async (input) => {
       const snapshotFolder = recorder.getSnapshotFolder();
       if (snapshotFolder) {
-        // Get the list of filenames in the snapshot folder
         const files = await readdir(snapshotFolder);
-        // Filter the files to only include .png files
         const ymlFiles = files.filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
         return { folder: snapshotFolder, files: ymlFiles };
       } else return { folder: null, files: [] };
@@ -239,6 +272,21 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
       return await recorder.getStepsAndCommandsForScenario(input);
     },
+    "recorderWindow.getNetworkEvents": async (input) => {
+      return await recorder.getNetworkEvents(input);
+    },
+    "recorderWindow.initExecution": async (input) => {
+      return await recorder.initExecution(input);
+    },
+    "recorderWindow.cleanupExecution": async (input) => {
+      return await recorder.cleanupExecution(input);
+    },
+    "recorderWindow.resetExecution": async (input) => {
+      return await recorder.resetExecution(input);
+    },
+    "recorderWindow.stopRecordingNetwork": async (input) => {
+      return recorder.stopRecordingNetwork(input);
+    },
   });
   socket.on("targetBrowser.command.event", async (input) => {
     return recorder.onAction(input);
@@ -265,7 +313,6 @@ try {
   showUsage(error, usage);
 }
 try {
-  // console.log({ envName, projectDir, featureName, scenarioName, stepIndex, roomId })
   init({
     envName,
     projectDir,

package/bin/client/recorderv3/network.js

@@ -0,0 +1,299 @@
+/**
+ * @typedef {Object} NetworkEvent
+ * @property {import('playwright').Request} request
+ * @property {import('playwright').Response|null} response
+ * @property {string} id
+ * @property {number} timestamp
+ * @property {string} status - 'completed', 'failed'
+ */
+
+class NetworkMonitor {
+  constructor() {
+    this.networkId = 0;
+    /** @type {Map<string, NetworkEvent>} */
+    this.requestIdMap = new Map();
+    this.networkEvents = new Map();
+    /** @type {Map<import('playwright').Page, {responseListener: Function, requestFailedListener: Function}>} */
+    this.pageListeners = new Map();
+  }
+
+  /**
+   * Add network event listeners to a page
+   * @param {import('playwright').Page} page
+   */
+  addNetworkEventListener(page) {
+    // Create the listener functions
+    const responseListener = async (response) => {
+      const request = response.request();
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response,
+        timestamp: Date.now(),
+        status: "completed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+
+    const requestFailedListener = (request) => {
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response: null,
+        timestamp: Date.now(),
+        status: "failed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+    // Store the listeners for later removal
+    this.pageListeners.set(page, {
+      responseListener,
+      requestFailedListener,
+    });
+
+    // Add the listeners to the page
+    page.on("response", responseListener);
+    page.on("requestfailed", requestFailedListener);
+  }
+
+  /**
+   * Remove network event listeners from a specific page
+   * @param {import('playwright').Page} page
+   */
+  removeNetworkEventListener(page) {
+    const listeners = this.pageListeners.get(page);
+    if (listeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+      this.pageListeners.delete(page);
+      console.log("Network event listeners removed from page");
+    }
+  }
+
+  /**
+   * Remove network event listeners from all pages
+   */
+  removeAllNetworkEventListeners() {
+    for (const [page, listeners] of this.pageListeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+    }
+    this.pageListeners.clear();
+    console.log("All network event listeners removed");
+  }
+
+  /**
+   * Check if a page has active listeners
+   * @param {import('playwright').Page} page
+   * @returns {boolean}
+   */
+  hasListeners(page) {
+    return this.pageListeners.has(page);
+  }
+
+  /**
+   * Get the number of pages with active listeners
+   * @returns {number}
+   */
+  getActiveListenersCount() {
+    return this.pageListeners.size;
+  }
+
+  /**
+   * Get all network events until now
+   */
+  getAllNetworkEvents() {
+    return Array.from(this.networkEvents.values());
+  }
+
+  /**
+   * Get network events within a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsInRange(startId, endId) {
+    const events = [];
+    for (let i = startId; i <= endId; i++) {
+      const event = this.networkEvents.get(i.toString());
+      if (event) {
+        events.push(event);
+      }
+    }
+    return events;
+  }
+
+  /**
+   * Get network events since a specific ID
+   * @param {number} sinceId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsSince(sinceId) {
+    return this.getNetworkEventsInRange(sinceId + 1, this.networkId);
+  }
+
+  /**
+   * Get events by status
+   * @param {string} status - 'completed', 'failed'
+   * @returns {NetworkEvent[]}
+   */
+  getEventsByStatus(status) {
+    return Array.from(this.networkEvents.values()).filter((event) => event.status === status);
+  }
+
+  /**
+   * Get current network ID (latest)
+   * @returns {number}
+   */
+  getCurrentNetworkId() {
+    return this.networkId;
+  }
+
+  getCurrentNetworkEventsLength() {
+    return this.networkEvents.size;
+  }
+
+  /**
+   * Get statistics about stored events
+   * @returns {Object}
+   */
+  getStats() {
+    const events = Array.from(this.networkEvents.values());
+    return {
+      total: events.length,
+      completed: events.filter((e) => e.status === "completed").length,
+      failed: events.filter((e) => e.status === "failed").length,
+      oldestTimestamp: events.length > 0 ? Math.min(...events.map((e) => e.timestamp)) : null,
+      newestTimestamp: events.length > 0 ? Math.max(...events.map((e) => e.timestamp)) : null,
+    };
+  }
+
+  /**
+   * Marshall network event for serialization
+   * @param {NetworkEvent} networkEvent
+   * @returns {Promise<Object>}
+   */
+  async marshallNetworkEvent(networkEvent) {
+    const { request, response } = networkEvent;
+
+    try {
+      const url = new URL(request.url());
+      const marshalledEvent = {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: url.href,
+        method: request.method(),
+        statusCode: response?.status() ?? null,
+        statusText: response?.statusText() ?? null,
+        queryParams: Object.fromEntries(url.searchParams.entries()),
+      };
+
+      // Try to get response body safely (only for successful responses)
+      if (response && networkEvent.status === "completed") {
+        try {
+          const isBinary =
+            !response.headers()["content-type"]?.includes("application/json") &&
+            !response.headers()["content-type"]?.includes("text");
+          let body;
+          if (isBinary) {
+            body = await response.body();
+          } else {
+            body = await response.text();
+          }
+          let json;
+          try {
+            if (typeof body === "string") {
+              json = JSON.parse(body); // Check if body is valid JSON
+            }
+          } catch (_) {
+            //Ignore
+          }
+          const responseBody = isBinary ? body : json ? JSON.stringify(json) : body;
+          marshalledEvent.contentType = isBinary ? "binary" : json ? "json" : "text";
+          marshalledEvent.responseBody = responseBody;
+        } catch (error) {
+          marshalledEvent.responseBody = `[Error reading response: ${error.message}]`;
+        }
+      } else if (networkEvent.status === "failed") {
+        marshalledEvent.failureReason = request.failure()?.errorText || "Unknown error";
+      }
+
+      console.log("Marshalled network event:", marshalledEvent);
+
+      return marshalledEvent;
+    } catch (error) {
+      console.error("Error marshalling network event:", error);
+      return {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: request.url(),
+        method: request.method(),
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   *@returns {Promise<Object[]>}
+   * Get all marshalled network events
+   * This is useful for sending to the server or saving to a file.
+   *   */
+  async getAllMarshalledNetworkEvents() {
+    const events = this.getAllNetworkEvents();
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events since this ID
+   * @returns {Promise<Object[]>}
+   * @param {number} sinceId
+   */
+  async getMarshalledNetworkEvents(sinceId) {
+    const events = this.getNetworkEventsSince(sinceId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events in a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {Promise<Object[]>}
+   */
+  async getMarshalledNetworkEventsInRange(startId, endId) {
+    const events = this.getNetworkEventsInRange(startId, endId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Clear all network events
+   */
+  clearNetworkEvents() {
+    this.networkEvents.clear();
+    this.networkId = 0;
+  }
+}
+
+export default NetworkMonitor;

package/bin/client/recorderv3/scriptTest.js

@@ -2,4 +2,4 @@
 
 // getImplementedSteps('/Users/yash/Library/Application Support/blinq.io/67d7c7ffb099a8da65d7e204').then((implementedSteps) => {
 //     console.log(JSON.stringify(implementedSteps, null, 2));
-// });
+// });

package/bin/client/recorderv3/services.js

@@ -15,20 +15,7 @@ export class NamesService {
     if (!screenshot && commands.length > 1) {
       screenshot = this.screenshotMap.get(commands[commands.length - 2].inputID);
     }
-    this.logger.info(
-      "data: " +
-        JSON.stringify(
-          {
-            commands,
-            stepsNames,
-            parameters,
-            map,
-          },
-          null,
-          2
-        )
-    );
-    // get screenshot for the last command
+
     const url = `${getRunsServiceBaseURL()}/generate-step-information/generate`;
     const TIMEOUT = 120; // 2 minutes
     const { data } = await axiosClient({
@@ -38,7 +25,7 @@ export class NamesService {
         commands,
         stepsNames,
         parameters,
-        screenshot,
+        //screenshot,
         map,
       },
       headers: {
@@ -65,6 +52,7 @@ export class NamesService {
         }
       } catch (error) {
         if (i === TIMEOUT - 1) {
+          this.logger.error("Timeout while generating step details: ", error);
           console.error("Timeout while generating step details: ", error);
         }
       }
@@ -96,7 +84,6 @@ export class NamesService {
       scenario: scenarioAsText,
     };
 
-    this.logger.info("data: " + JSON.stringify(genObject, null, 2));
     // get screenshot for the last command
     const url = `${getRunsServiceBaseURL()}/generate-step-information/generate_scenario_feature`;
     const TIMEOUT = 120; // 2 minutes
@@ -140,6 +127,7 @@ export class NamesService {
     if (result.status !== 200) {
       return { success: false, message: "Error while generating step details" };
     }
+
     return result.data;
   }