@dev-blinq/cucumber_client 1.0.1690-dev → 1.0.1692-dev

package/bin/client/recorderv3/network.js

@@ -1,299 +0,0 @@
-/**
- * @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

@@ -1,5 +0,0 @@
-// import { getImplementedSteps } from "./implemented_steps.js";
-
-// getImplementedSteps('/Users/yash/Library/Application Support/blinq.io/67d7c7ffb099a8da65d7e204').then((implementedSteps) => {
-//     console.log(JSON.stringify(implementedSteps, null, 2));
-// });

package/bin/client/recorderv3/ws_server.js

@@ -1,72 +0,0 @@
-import { Server } from "socket.io";
-
-const io = new Server({
-  cors: {
-    origin: "*",
-    methods: ["GET", "POST"],
-  },
-});
-
-const broadcastRequestResponse = (socket) => {
-  //   data: { event: string; input: any; id: string; roomId: string; socketId: string }
-  socket.on("request", async (data) => {
-    const { event, input, id, roomId } = data;
-    const socketId = socket.id;
-    // console.log("request __", event, input, id, roomId, socketId);
-    socket.to(roomId).emit("request", { event, input, id, roomId, socketId });
-  });
-  //   data: { id: string; value: any; error: any; roomId: string; socketId: string }
-  socket.on("response", (data) => {
-    const { id, value, error, roomId, socketId } = data;
-    // console.log("response __", id, value, error, roomId, socketId);
-    socket.to(socketId).emit("response", { id, value, error, roomId, socketId });
-  });
-};
-
-const targetBrowserEvents = [
-  "targetBrowser.command.new",
-  "targetBrowser.command.newText",
-  "targetBrowser.screenshotURL",
-  "targetBrowser.command.event",
-];
-const BVTRecorderEvents = [
-  "BVTRecorder.command.new",
-  "BVTRecorder.browserOpened",
-  "BVTRecorder.onFrameNavigate",
-  "BVTRecorder.onPageClose",
-  "BVTRecorder.onBrowserClose",
-  "BVTRecorder.getTestData",
-];
-const startServer = (WS_PORT) => {
-  io.on("connection", (socket) => {
-    // console.log("a user connected ", socket.id);
-    socket.on("disconnect", () => {
-      // console.log("user disconnected", socket.id);
-    });
-    socket.on("createRoom", ({ id, window }) => {
-      // console.log("creating and joining room", id, window, socket.id);
-      socket.join(id);
-    });
-    socket.on("joinRoom", ({ id, window }) => {
-      // console.log("joining room", id, window, socket.id);
-      socket.join(id);
-    });
-    targetBrowserEvents.forEach((event) => {
-      socket.on(event, (input, roomId) => {
-        // console.log(event, input, roomId);
-        socket.to(roomId).emit(event, input);
-      });
-    });
-    BVTRecorderEvents.forEach((event) => {
-      socket.on(event, (input, roomId) => {
-        // console.log(event, input, roomId);
-        socket.to(roomId).emit(event, input);
-      });
-    });
-    broadcastRequestResponse(socket);
-  });
-  io.listen(WS_PORT);
-  console.log(`Socket IO listening on *:${WS_PORT}`);
-};
-
-export { startServer };