@dev-blinq/cucumber_client 1.0.1546-dev → 1.0.1548-dev

package/bin/assets/scripts/recorder.js

@@ -144,7 +144,7 @@ class BVTRecorder {
       getAction: (e) => {
         this.eventUtils.consumeEvent(e);
       },
-      getInterestedElement: () => { },
+      getInterestedElement: () => {},
       hoverOutlineStyle: "",
     });
 
@@ -159,7 +159,7 @@ class BVTRecorder {
         };
       },
       getAction: () => null,
-      getInterestedElement: () => { },
+      getInterestedElement: () => {},
       hoverOutlineStyle: "",
     });
 
@@ -174,7 +174,7 @@ class BVTRecorder {
         };
       },
       getAction: () => null,
-      getInterestedElement: () => { },
+      getInterestedElement: () => {},
       hoverOutlineStyle: "",
     });
 
@@ -684,7 +684,7 @@ class BVTRecorder {
       this.PW.roleUtils.getElementAccessibleName(el, true) ||
       "";
     const result = this.getElementProperties(el);
-    const elText = this.PW.selectorUtils.elementText(new Map(), el)
+    const elText = this.PW.selectorUtils.elementText(new Map(), el);
     return {
       role,
       label,

package/bin/client/recorderv3/bvt_init.js

@@ -80,9 +80,9 @@ const timeOutForFunction = async (promise, timeout = 5000) => {
   }
 };
 
-async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN }) {
+async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = null }) {
   console.log("Connecting to " + WS_URL);
-  const socket = io(WS_URL);
+  socket = socket || io(WS_URL);
   socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
   socket.on("connect", () => {
     socketLogger.info("Connected to BVTRecorder server");

package/bin/client/recorderv3/wbr_entry.js

@@ -0,0 +1,29 @@
+import { io } from "socket.io-client";
+import { BVTRecorderInit } from "./bvt_init.js";
+const requiredEnvVars = ["PROJECT_ID", "BLINQ_TOKEN", "SESSION_ID", "WORKER_WS_SERVER_URL"];
+function validateEnvVariables() {
+    const missingVars = requiredEnvVars.filter((varName) => !process.env[varName]);
+    if (missingVars.length > 0) {
+        throw new Error(`Missing required environment variables: ${missingVars.join(", ")}`);
+    }
+}
+const socket = io(process.env.WORKER_WS_SERVER_URL, {
+    path: "/ws",
+    transports: ["websocket", "polling"],
+    reconnection: true,
+});
+function initWebBVTRecorder(socket) {
+    validateEnvVariables();
+    const WORKER_WS_SERVER_URL = process.env.WORKER_WS_SERVER_URL;
+    const PROJECT_ID = process.env.PROJECT_ID;
+    const TOKEN = process.env.BLINQ_TOKEN;
+    const ROOM_ID = process.env.SESSION_ID;
+    BVTRecorderInit({
+        envName: WORKER_WS_SERVER_URL,
+        projectDir: PROJECT_ID,
+        roomId: ROOM_ID,
+        TOKEN: TOKEN,
+        socket: socket,
+    });
+}
+initWebBVTRecorder(socket);

package/bin/client/recorderv3/web-ipcMain.js

@@ -0,0 +1,129 @@
+// web-ipcMain.ts
+import { EventEmitter } from "events";
+export class WebIpcMain extends EventEmitter {
+    socket;
+    handlers = new Map();
+    constructor(socket) {
+        super();
+        this.socket = socket;
+        this.setupSocketListeners();
+    }
+    setupSocketListeners() {
+        // Handle invoke calls from renderer (via relay server)
+        this.socket.on("invoke", async ({ channel, args, invokeId, clientId }) => {
+            const handler = this.handlers.get(channel);
+            if (!handler) {
+                this.socket.emit("invoke-response", {
+                    invokeId,
+                    clientId,
+                    error: `No handler registered for channel: ${channel}`,
+                });
+                return;
+            }
+            try {
+                const event = {
+                    frameId: 0,
+                    processId: 0,
+                    sender: {
+                        send: (replyChannel, ...replyArgs) => {
+                            this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                        },
+                    },
+                    senderFrame: null,
+                };
+                const result = await Promise.resolve(handler(event, ...args));
+                this.socket.emit("invoke-response", { invokeId, clientId, result });
+            }
+            catch (error) {
+                this.socket.emit("invoke-response", {
+                    invokeId,
+                    clientId,
+                    error: error.message || "Handler error",
+                });
+            }
+        });
+        // Handle send calls from renderer (fire and forget)
+        this.socket.on("send", ({ channel, args, clientId }) => {
+            const event = {
+                frameId: 0,
+                processId: 0,
+                sender: {
+                    send: (replyChannel, ...replyArgs) => {
+                        this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                    },
+                },
+                senderFrame: null,
+                ports: [],
+                reply: (replyChannel, ...replyArgs) => {
+                    this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                },
+            };
+            this.emit(channel, event, ...args);
+        });
+        // Handle postMessage
+        this.socket.on("postMessage", ({ channel, message, clientId }) => {
+            const event = {
+                frameId: 0,
+                processId: 0,
+                sender: {
+                    send: (replyChannel, ...replyArgs) => {
+                        this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                    },
+                },
+                senderFrame: null,
+                ports: [],
+                reply: (replyChannel, ...replyArgs) => {
+                    this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                },
+            };
+            this.emit(channel, event, message);
+        });
+        // Handle sendToHost
+        this.socket.on("sendToHost", ({ channel, args, clientId }) => {
+            const event = {
+                frameId: 0,
+                processId: 0,
+                sender: {
+                    send: (replyChannel, ...replyArgs) => {
+                        this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                    },
+                },
+                senderFrame: null,
+                ports: [],
+                reply: (replyChannel, ...replyArgs) => {
+                    this.socket.emit("message", { channel: replyChannel, args: replyArgs, clientId });
+                },
+            };
+            this.emit(channel, event, ...args);
+        });
+    }
+    handle(channel, listener) {
+        if (this.handlers.has(channel)) {
+            throw new Error(`Handler for channel '${channel}' already exists`);
+        }
+        this.handlers.set(channel, listener);
+    }
+    handleOnce(channel, listener) {
+        const onceWrapper = async (event, ...args) => {
+            this.removeHandler(channel);
+            return await Promise.resolve(listener(event, ...args));
+        };
+        this.handle(channel, onceWrapper);
+    }
+    removeHandler(channel) {
+        this.handlers.delete(channel);
+    }
+    // Send message to all connected clients (via relay server)
+    sendToAll(channel, ...args) {
+        this.socket.emit("broadcast", { channel, args });
+    }
+    // Send message to specific client by client ID (via relay server)
+    sendToClient(clientId, channel, ...args) {
+        this.socket.emit("message", { channel, args, clientId });
+    }
+    // Cleanup
+    destroy() {
+        this.handlers.clear();
+        this.removeAllListeners();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1546-dev",
+  "version": "1.0.1548-dev",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",