@dev-blinq/cucumber_client 1.0.1366-stage → 1.0.1367-stage

package/bin/client/recorderv3/bvt_init.js

@@ -0,0 +1,325 @@
+import { io } from "socket.io-client";
+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 = process.env.WORKER_WS_SERVER_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;
+    this.routes = routes;
+  }
+  init() {
+    this.socket.on("request", async (data) => {
+      const { event, input, id, roomId, socketId } = data;
+      if (event !== "recorderWindow.getCurrentChromiumPath") {
+        socketLogger.info("Received request", { event, input, id, roomId, socketId });
+      }
+      try {
+        const handler = this.routes[event];
+        if (!handler) {
+          console.error(`No handler found for event: ${event}`);
+          return;
+        }
+        const response = await handler(input);
+        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.error(`Error handling request for event: ${event}`, error);
+        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: {
+            message: error?.message,
+            code: error?.code,
+            info: error?.info,
+            stack: error?.stack,
+          },
+          roomId,
+          socketId,
+        });
+      }
+    });
+  }
+}
+
+const timeOutForFunction = async (promise, timeout = 5000) => {
+  const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
+
+  try {
+    const res = await Promise.race([promise, timeoutPromise]);
+    return res;
+  } catch (error) {
+    console.error(error);
+    socketLogger.error(error);
+    throw error;
+  }
+};
+
+async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = null }) {
+  console.log("Connecting to " + WS_URL);
+  socket = socket || io(WS_URL);
+  socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
+  socket.on("connect", () => {
+    socketLogger.info(`${roomId} Connected to BVTRecorder server`);
+    console.log(`${roomId} Connected to BVTRecorder server`);
+  });
+  socket.on("disconnect", () => {
+    socketLogger.info(`${roomId} Disconnected from server`);
+    console.log(`${roomId} Disconnected from server`);
+  });
+  socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
+  const recorder = new BVTRecorder({
+    envName,
+    projectDir,
+    TOKEN,
+    sendEvent: (event, data) => {
+      socketLogger.info("Sending event", { event, data, roomId });
+      socket.emit(event, data, roomId);
+    },
+    logger: socketLogger,
+  });
+  try {
+    await recorder.openBrowser();
+    socketLogger.info("BVTRecorder.browserOpened");
+    socket.emit("BVTRecorder.browserOpened", null, roomId);
+  } catch (e) {
+    if (e instanceof Error) {
+      socketLogger.error("BVTRecorder.browserLaunchFailed", e);
+      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
+    } else {
+      socketLogger.error("BVTRecorder.browserLaunchFailed", JSON.stringify(e));
+      socket.emit("BVTRecorder.browserLaunchFailed", JSON.stringify(e), roomId);
+    }
+    console.error("Browser launch failed", e);
+  }
+
+  const promisifiedSocketServer = new PromisifiedSocketServer(socket, {
+    "recorderWindow.openBrowser": async (input) => {
+      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) => {
+          socketLogger.error("Error opening browser", e);
+          console.error("BVTRecorder.browserLaunchFailed", e);
+          socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
+        });
+    },
+    "recorderWindow.closeBrowser": async (input) => {
+      return recorder.closeBrowser(input);
+    },
+    "recorderWindow.reOpenBrowser": async (input) => {
+      return recorder
+        .reOpenBrowser(input)
+        .then(() => {
+          socketLogger.info("BVTRecorder.browserOpened");
+          console.log("BVTRecorder.browserOpened");
+          socket.emit("BVTRecorder.browserOpened", null, roomId);
+        })
+        .catch((e) => {
+          socketLogger.info("BVTRecorder.browserLaunchFailed");
+          console.error("BVTRecorder.browserLaunchFailed", e);
+          socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+        });
+    },
+    "recorderWindow.startRecordingInput": async (input) => {
+      return timeOutForFunction(recorder.startRecordingInput(input));
+    },
+    "recorderWindow.stopRecordingInput": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingInput(input));
+    },
+    "recorderWindow.startRecordingText": async (input) => {
+      // console.log("--- {{ }} -- : recorderWindow.startRecordingText", input);
+      return timeOutForFunction(recorder.startRecordingText(input));
+    },
+    "recorderWindow.stopRecordingText": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingText(input));
+    },
+    "recorderWindow.startRecordingContext": async (input) => {
+      return timeOutForFunction(recorder.startRecordingContext(input));
+    },
+    "recorderWindow.stopRecordingContext": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingContext(input));
+    },
+    "recorderWindow.runStep": async (input) => {
+      return recorder.runStep(input);
+    },
+    "recorderWindow.saveScenario": async (input) => {
+      return recorder.saveScenario(input);
+    },
+    "recorderWindow.getImplementedSteps": async (input) => {
+      // console.log("recorderWindow.getImplementedSteps", input);
+      return (await recorder.getImplementedSteps(input)).implementedSteps;
+    },
+    "recorderWindow.getImplementedScenarios": async (input) => {
+      // console.log("recorderWindow.getImplementedScenarios", input);
+      return (await recorder.getImplementedSteps(input)).scenarios;
+    },
+    "recorderWindow.getCurrentChromiumPath": async () => {
+      // console.log("recorderWindow.getCurrentChromiumPath");
+      return await recorder.getCurrentChromiumPath();
+    },
+    "recorderWindow.overwriteTestData": async (input) => {
+      // console.log("recorderWindow.overwriteTestData");
+      return await recorder.overwriteTestData(input);
+    },
+    "recorderWindow.generateStepName": async (input) => {
+      return recorder.generateStepName(input);
+    },
+    "recorderWindow.getFeatureAndScenario": async (input) => {
+      return recorder.generateScenarioAndFeatureNames(input);
+    },
+    "recorderWindow.generateCommandName": async (input) => {
+      return recorder.generateCommandName(input);
+    },
+    "recorderWindow.loadTestData": async (input) => {
+      return recorder.loadTestData(input);
+    },
+    "recorderWindow.discard": async (input) => {
+      return await recorder.discardTestData(input);
+    },
+    "recorderWindow.addToTestData": async (input) => {
+      return await recorder.addToTestData(input);
+    },
+    "recorderWindow.getScenarios": async () => {
+      return recorder.getScenarios();
+    },
+    "recorderWindow.setShouldTakeScreenshot": async (input) => {
+      return recorder.setShouldTakeScreenshot(input);
+    },
+    "recorderWindow.compareWithScenario": async ({ projectDir, scenario }, roomId) => {
+      return await compareWithScenario(getAppDataDir(projectDir), scenario);
+    },
+    "recorderWindow.getCommandsForImplementedStep": async (input) => {
+      return recorder.getCommandsForImplementedStep(input);
+    },
+    "recorderWindow.getNumberOfOccurrences": async (input) => {
+      return recorder.getNumberOfOccurrences(input);
+    },
+    "recorderWindow.getFakeParams": async ({ parametersMap }) => {
+      return recorder.fakeParams(parametersMap);
+    },
+    "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);
+    },
+    "recorderWindow.findRelatedTextInAllFrames": async (input) => {
+      return recorder.findRelatedTextInAllFrames(input);
+    },
+    "recorderWindow.getReportFolder": async (input) => {
+      return recorder.getReportFolder();
+    },
+    "recorderWindow.getSnapshotFiles": async (input) => {
+      const snapshotFolder = recorder.getSnapshotFolder();
+      if (snapshotFolder) {
+        const files = await readdir(snapshotFolder);
+        const ymlFiles = files.filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+        return { folder: snapshotFolder, files: ymlFiles };
+      } else return { folder: null, files: [] };
+    },
+    "recorderWindow.getCurrentPageTitle": async (input) => {
+      return await recorder.getCurrentPageTitle();
+    },
+    "recorderWindow.getCurrentPageUrl": async (input) => {
+      return await recorder.getCurrentPageUrl();
+    },
+    "recorderWindow.sendAriaSnapshot": async (input) => {
+      const snapshot = input?.snapshot;
+      const deselect = input?.deselect;
+      if (deselect === true) {
+        return await recorder.deselectAriaElements();
+      }
+      if (snapshot !== null) {
+        return await recorder.processAriaSnapshot(snapshot);
+      }
+    },
+    "recorderWindow.revertMode": async (input) => {
+      await recorder.revertMode();
+    },
+    "recorderWindow.setMode": async (input) => {
+      const mode = input?.mode;
+      return recorder.setMode(mode);
+    },
+    "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);
+    },
+    "browserUI.requestState": async (input) => {
+      console.log("Received browserUI.requestState");
+      await recorder.getBrowserState();
+    },
+    "browserUI.createTab": async (input) => {
+      console.log("Received browserUI.createTab", input);
+      await recorder.createTab(input);
+    },
+    "browserUI.closeTab": async (input) => {
+      console.log("Received browserUI.closeTab", input);
+      await recorder.closeTab(input);
+    },
+    "browserUI.selectTab": async (input) => {
+      console.log("Received browserUI.selectTab", input);
+      await recorder.selectTab(input);
+    },
+    "recorderWindow.cleanup": async (input) => {
+      return recorder.cleanup(input);
+    },
+  });
+
+  socket.on("targetBrowser.command.event", async (input) => {
+    return recorder.onAction(input);
+  });
+  promisifiedSocketServer.init();
+}
+
+export { BVTRecorderInit };

package/bin/client/recorderv3/bvt_recorder.js

@@ -205,7 +205,6 @@ export class BVTRecorder {
     this.shouldTakeScreenshot = true;
     this.watcher = null;
     this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
-
     this.tempProjectFolder = `${tmpdir()}/bvt_temp_project_${Math.floor(Math.random() * 1000000)}`;
     this.tempSnapshotsFolder = path.join(this.tempProjectFolder, "data/snapshots");
 
@@ -228,6 +227,8 @@ export class BVTRecorder {
     interceptResults: "BVTRecorder.interceptResults",
     onDebugURLChange: "BVTRecorder.onDebugURLChange",
     updateCommand: "BVTRecorder.updateCommand",
+    browserStateSync: "BrowserService.stateSync",
+    browserStateError: "BrowserService.stateError",
   };
   bindings = {
     __bvt_recordCommand: async ({ frame, page, context }, event) => {
@@ -365,12 +366,21 @@ export class BVTRecorder {
       },
       bvtContext: this.bvtContext,
     });
-    const context = bvtContext.playContext;
-    this.context = context;
+    this.context = bvtContext.playContext;
     this.web = bvtContext.stable || bvtContext.web;
     this.web.tryAllStrategies = true;
     this.page = bvtContext.page;
     this.pageSet.add(this.page);
+    if (process.env.REMOTE_RECORDER === "true") {
+      this.browserEmitter = new RemoteBrowserService({
+        CDP_CONNECT_URL: `http://localhost:${this.#remoteDebuggerPort}`,
+        context: this.context,
+      });
+      this.browserEmitter.on(this.events.browserStateSync, (state) => {
+        this.page = this.browserEmitter.getSelectedPage();
+        this.sendEvent(this.events.browserStateSync, state);
+      });
+    }
     this.lastKnownUrlPath = this._updateUrlPath();
     const browser = await this.context.browser();
     this.browser = browser;
@@ -818,7 +828,6 @@ export class BVTRecorder {
     this.previousHistoryLength = null;
     this.previousUrl = null;
     this.previousEntries = null;
-
     await closeContext();
     this.pageSet.clear();
   }
@@ -1353,4 +1362,53 @@ export class BVTRecorder {
 
     return newFakeParams;
   }
+
+  async getBrowserState() {
+    try {
+      const state = await this.browserEmitter?.getState();
+      this.sendEvent(this.events.browserStateSync, state);
+    } catch (error) {
+      this.logger.error("Error getting browser state:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error getting browser state",
+        code: "GET_STATE_ERROR",
+      });
+    }
+  }
+
+  async createTab({ url }) {
+    try {
+      await this.browserEmitter?.createTab(url);
+    } catch (error) {
+      this.logger.error("Error creating tab:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error creating tab",
+        code: "CREATE_TAB_ERROR",
+      });
+    }
+  }
+
+  async closeTab({ pageId }) {
+    try {
+      await this.browserEmitter?.closeTab(pageId);
+    } catch (error) {
+      this.logger.error("Error closing tab:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error closing tab",
+        code: "CLOSE_TAB_ERROR",
+      });
+    }
+  }
+
+  async selectTab({ pageId }) {
+    try {
+      await this.browserEmitter?.selectTab(pageId);
+    } catch (error) {
+      this.logger.error("Error selecting tab:", error);
+      this.sendEvent(this.events.browserStateError, {
+        message: "Error selecting tab",
+        code: "SELECT_TAB_ERROR",
+      });
+    }
+  }
 }