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

package/bin/client/recorderv3/bvt_recorder.js

@@ -1,160 +1,173 @@
 // define the jsdoc type for the input
 import { closeContext, initContext, _getDataFile, resetTestData } from "automation_model";
-import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
-import path from "path";
-import url from "url";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import url from "node:url";
 import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
-import { NamesService } from "./services.js";
+import { NamesService, PublishService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
-import { readFile, writeFile } from "fs/promises";
-import { updateStepDefinitions, loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
-import { updateFeatureFile } from "./update_feature.js";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { loadStepDefinitions, getCommandsForImplementedStep, _toRecordingStep, getCucumberStep, getCodePage, toMethodName, } from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
-import { findAvailablePort } from "../utils/index.js";
-import socketLogger from "../utils/socket_logger.js";
+import { findAvailablePort, getRunsServiceBaseURL } from "../utils/index.js";
+import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
 import { tmpdir } from "os";
+import { chromium } from "playwright-core";
+import { axiosClient } from "../utils/axiosClient.js";
+import { _generateCodeFromCommand } from "../code_gen/playwright_codeget.js";
+import { Recording } from "../recording.js";
+import { MIXPANEL_EVENTS, mixpanelTrackEvent } from "./mixpanel.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export function getInitScript(config, options) {
-  const preScript = `
+    const preScript = `
   window.__bvt_Recorder_config = ${JSON.stringify(config ?? null)};
   window.__PW_options = ${JSON.stringify(options ?? null)};
   `;
-  const recorderScript = readFileSync(
-    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
-    "utf8"
-  );
-  return preScript + recorderScript;
+    const recorderScript = readFileSync(path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"), "utf8");
+    return preScript + recorderScript;
 }
-
 async function evaluate(frame, script) {
-  if (frame.isDetached()) return;
-  const url = frame.url();
-  if (url === "" || url === "about:blank") return;
-  await frame.evaluate(script);
-  for (const childFrame of frame.childFrames()) {
-    await evaluate(childFrame, script);
-  }
+    if (frame.isDetached())
+        return;
+    const url = frame.url();
+    if (url === "" || url === "about:blank")
+        return;
+    await frame.evaluate(script);
+    for (const childFrame of frame.childFrames()) {
+        await evaluate(childFrame, script);
+    }
 }
-
-async function findNestedFrameSelector(frame, obj) {
-  console.log("Testing new version");
-  try {
-    const parent = frame.parentFrame();
-    if (!parent) return { children: obj };
-    const frameElement = await frame.frameElement();
-    if (!frameElement) return;
-    const selectors = await parent.evaluate((element) => {
-      return window.__bvt_Recorder.locatorGenerator.getElementLocators(element, { excludeText: true }).locators;
-    }, frameElement);
-    return findNestedFrameSelector(parent, { children: obj, selectors });
-  } catch (e) {
-    socketLogger.error(`Error in findNestedFrameSelector: ${e}`);
-    console.error(e);
-  }
+async function findNestedFrameSelector(frame, obj = {}) {
+    try {
+        const parent = frame.parentFrame();
+        if (!parent)
+            return { children: obj };
+        const frameElement = await frame.frameElement();
+        if (!frameElement)
+            return;
+        const selectors = await frameElement.evaluate((element) => {
+            const recorder = window.__bvt_Recorder;
+            return recorder.locatorGenerator.getElementLocators(element, { excludeText: true }).locators;
+        });
+        return findNestedFrameSelector(parent, { children: obj, selectors });
+    }
+    catch (e) {
+        socketLogger.error(`Error in script evaluation: ${getErrorMessage(e)}`, undefined, "findNestedFrameSelector");
+    }
 }
 const transformFillAction = (action, el) => {
-  if (el.tagName.toLowerCase() === "input") {
-    switch (el.type) {
-      case "date":
-      case "datetime-local":
-      case "month":
-      case "time":
-      case "week":
-      case "range":
-      case "color":
-        return {
-          type: "set_input",
-          value: action.text,
-        };
+    if (el.tagName.toLowerCase() === "input") {
+        switch (el.type) {
+            case "date":
+            case "datetime-local":
+            case "month":
+            case "time":
+            case "week":
+            case "range":
+            case "color":
+                return {
+                    type: "set_input",
+                    value: action.text,
+                };
+        }
     }
-  }
-  return {
-    type: "fill_element",
-    value: action.text,
-  };
-};
-const transformClickAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode, isSnapshot) => {
-  if (isInHoverMode) {
-    return {
-      type: "hover_element",
-    };
-  }
-  if (isVerify) {
     return {
-      type: "verify_page_contains_text",
-      value: el.value ?? el.text,
-    };
-  }
-  if (isPopupCloseClick) {
-    return {
-      type: "popup_close",
+        type: "fill_element",
+        value: action.text,
     };
-  }
-  if (isSnapshot) {
+};
+const transformClickAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode, isSnapshot) => {
+    if (isInHoverMode) {
+        return {
+            type: "hover_element",
+        };
+    }
+    if (isVerify) {
+        return {
+            type: "verify_page_contains_text",
+            value: el.value ?? el.text,
+        };
+    }
+    if (isPopupCloseClick) {
+        return {
+            type: "popup_close",
+        };
+    }
+    if (isSnapshot) {
+        return {
+            type: "snapshot_element",
+            value: action.value,
+        };
+    }
     return {
-      type: "snapshot_element",
-      value: action.value,
+        type: "click_element",
     };
-  }
-  return {
-    type: "click_element",
-  };
 };
 const transformAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode, isSnapshot) => {
-  switch (action.name) {
-    case "click":
-      return transformClickAction(action, el, isVerify, isPopupCloseClick, isInHoverMode, isSnapshot);
-    case "fill": {
-      return transformFillAction(action, el);
-    }
-    case "select": {
-      return {
-        type: "select_combobox",
-        value: action.options[0],
-      };
-    }
-
-    case "check": {
-      return {
-        type: "check_element",
-        check: true,
-      };
-    }
-    case "uncheck": {
-      return {
-        type: "check_element",
-        check: false,
-      };
-    }
-    case "assertText": {
-      return {
-        type: "verify_page_contains_text",
-        value: action.text,
-      };
-    }
-    case "press": {
-      return {
-        type: "press_key",
-        value: action.key,
-      };
-    }
-    case "setInputFiles": {
-      return {
-        type: "set_input_files",
-        files: action.files,
-      };
-    }
-    default: {
-      socketLogger.error(`Action not supported: ${action.name}`);
-      console.log("action not supported", action);
-      throw new Error("action not supported");
-    }
-  }
+    switch (action.name) {
+        case "click":
+            return transformClickAction(action, el, isVerify, isPopupCloseClick, isInHoverMode, isSnapshot);
+        case "fill": {
+            return transformFillAction(action, el);
+        }
+        case "select": {
+            return {
+                type: "select_combobox",
+                value: action.options?.[0] ?? "",
+            };
+        }
+        case "check": {
+            return {
+                type: "check_element",
+                check: true,
+            };
+        }
+        case "uncheck": {
+            return {
+                type: "check_element",
+                check: false,
+            };
+        }
+        case "assertText": {
+            return {
+                type: "verify_page_contains_text",
+                value: action.text,
+            };
+        }
+        case "press": {
+            return {
+                type: "press_key",
+                value: action.key,
+            };
+        }
+        case "setInputFiles": {
+            return {
+                type: "set_input_files",
+                files: action.files,
+            };
+        }
+        default: {
+            socketLogger.error(`Action not supported: ${action.name}`);
+            console.log("action not supported", action);
+            throw new Error("action not supported");
+        }
+    }
+};
+const diffPaths = (currentPath, newPath) => {
+    const currentDomain = new URL(currentPath).hostname;
+    const newDomain = new URL(newPath).hostname;
+    if (currentDomain !== newDomain) {
+        return true;
+    }
+    else {
+        const currentRoute = new URL(currentPath).pathname;
+        const newRoute = new URL(newPath).pathname;
+        return currentRoute !== newRoute;
+    }
 };
 /**
  * @typedef {Object} BVTRecorderInput
@@ -165,1074 +178,1438 @@ const transformAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode,
  * @property {Object} logger
  */
 export class BVTRecorder {
-  #currentURL = "";
-  #activeFrame = null;
-  #mode = "noop";
-  #previousMode = "noop";
-  #remoteDebuggerPort = null;
-  /**
-   *
-   * @param {BVTRecorderInput} initialState
-   */
-  constructor(initialState) {
-    Object.assign(this, initialState);
-    this.screenshotMap = new Map();
-    this.snapshotMap = new Map();
-    this.scenariosStepsMap = new Map();
-    this.namesService = new NamesService({
-      screenshotMap: this.screenshotMap,
-      TOKEN: this.TOKEN,
-      projectDir: this.projectDir,
-      logger: this.logger,
-    });
-    this.pageSet = new Set();
-    this.lastKnownUrlPath = "";
-    this.world = { attach: () => {} };
-    this.shouldTakeScreenshot = true;
-    this.watcher = null;
-    this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
-    if (existsSync(this.networkEventsFolder)) {
-      rmSync(this.networkEventsFolder, { recursive: true, force: true });
-    }
-  }
-  events = {
-    onFrameNavigate: "BVTRecorder.onFrameNavigate",
-    onPageClose: "BVTRecorder.onPageClose",
-    onBrowserClose: "BVTRecorder.onBrowserClose",
-    onNewCommand: "BVTRecorder.command.new",
-    onCommandDetails: "BVTRecorder.onCommandDetails",
-    onStepDetails: "BVTRecorder.onStepDetails",
-    getTestData: "BVTRecorder.getTestData",
-    onGoto: "BVTRecorder.onGoto",
-    cmdExecutionStart: "BVTRecorder.cmdExecutionStart",
-    cmdExecutionSuccess: "BVTRecorder.cmdExecutionSuccess",
-    cmdExecutionError: "BVTRecorder.cmdExecutionError",
-    interceptResults: "BVTRecorder.interceptResults",
-  };
-  bindings = {
-    __bvt_recordCommand: async ({ frame, page, context }, event) => {
-      this.#activeFrame = frame;
-      const nestFrmLoc = await findNestedFrameSelector(frame);
-      this.logger.info(`Time taken for action: ${event.statistics.time}`);
-      await this.onAction({ ...event, nestFrmLoc });
-    },
-    __bvt_getMode: async () => {
-      return this.#mode;
-    },
-    __bvt_setMode: async (src, mode) => {
-      await this.setMode(mode);
-    },
-    __bvt_revertMode: async () => {
-      await this.revertMode();
-    },
-    __bvt_recordPageClose: async ({ page }) => {
-      this.pageSet.delete(page);
-    },
-    __bvt_closePopups: async () => {
-      await this.onClosePopup();
-    },
-    __bvt_log: async (src, message) => {
-      this.logger.info(`Inside Browser: ${message}`);
-    },
-    __bvt_getObject: (_src, obj) => {
-      this.processObject(obj);
-    },
-  };
-
-  getSnapshot = async (attr) => {
-    const selector = `[__bvt_snapshot="${attr}"]`;
-    const locator = await this.web.page.locator(selector);
-    const snapshot = await locator.ariaSnapshot();
-    return snapshot;
-  };
-
-  processObject = async ({ type, action, value }) => {
-    switch (type) {
-      case "snapshot-element": {
-        if (action === "get-template") {
-          return true;
-        }
-        break;
-      }
-      default: {
-        console.log("Unknown object type", type);
-        break;
-      }
-    }
-  };
-
-  getPWScript() {
-    const pwFolder = path.join(__dirname, "..", "..", "assets", "preload", "pw_utils");
-    const result = [];
-    for (const script of readdirSync(pwFolder)) {
-      const path = path.join(pwFolder, script);
-      const content = readFileSync(path, "utf8");
-      result.push(content);
-    }
-    return result;
-  }
-  getRecorderScripts() {
-    const recorderFolder = path.join(__dirname, "..", "..", "assets", "preload", "recorder");
-    const result = [];
-    for (const script of readdirSync(recorderFolder)) {
-      const path = path.join(recorderFolder, script);
-      const content = readFileSync(path, "utf8");
-      result.push(content);
-    }
-    return result;
-  }
-  getInitScripts(config) {
-    return getInitScript(config, {
-      sdkLanguage: "javascript",
-      testIdAttributeName: "blinq-test-id",
-      stableRafCount: 0,
-      browserName: this.browser?.browserType().name(),
-      inputFileRoleTextbox: false,
-      customEngines: [],
-      isUnderTest: true,
-    });
-  }
-
-  async _initBrowser({ url }) {
-    this.#remoteDebuggerPort = await findAvailablePort();
-    process.env.CDP_LISTEN_PORT = this.#remoteDebuggerPort;
-
-    // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => {} };
-
-    const ai_config_file = path.join(this.projectDir, "ai_config.json");
-    let ai_config = {};
-    if (existsSync(ai_config_file)) {
-      try {
-        ai_config = JSON.parse(readFileSync(ai_config_file, "utf8"));
-      } catch (error) {
-        this.logger.error("Error reading ai_config.json", error);
-      }
-    }
-    this.config = ai_config;
-    const initScripts = {
-      // recorderCjs: injectedScriptSource,
-      scripts: [
-        this.getInitScripts(ai_config),
-        `\ndelete Object.getPrototypeOf(navigator).webdriver;${process.env.WINDOW_DEBUGGER ? "window.debug=true;\n" : ""}`,
-      ],
+    #currentURL = "";
+    #activeFrame = null;
+    #mode = "noop";
+    #previousMode = "noop";
+    #remoteDebuggerPort = null;
+    envName;
+    projectDir;
+    TOKEN;
+    sendEvent;
+    logger;
+    userId;
+    screenshotMap = new Map();
+    snapshotMap = new Map();
+    scenariosStepsMap = new Map();
+    namesService;
+    workspaceService;
+    pageSet = new Set();
+    lastKnownUrlPath = "";
+    world = {
+        attach: async () => { },
+        parameters: {},
+        log: (message) => {
+            socketLogger.log.call(socketLogger, "info", message, undefined, "Cucumber.JS World");
+        },
     };
-
-    const bvtContext = await initContext(url, false, false, this.world, 450, initScripts, this.envName);
-    this.bvtContext = bvtContext;
-    this.stepRunner = new BVTStepRunner({
-      projectDir: this.projectDir,
-      sendExecutionStatus: (data) => {
-        if (data && data.type) {
-          switch (data.type) {
-            case "cmdExecutionStart":
-              this.sendEvent(this.events.cmdExecutionStart, data);
-              break;
-            case "cmdExecutionSuccess":
-              this.sendEvent(this.events.cmdExecutionSuccess, data);
-              break;
-            case "cmdExecutionError":
-              this.sendEvent(this.events.cmdExecutionError, data);
-              break;
-            case "interceptResults":
-              this.sendEvent(this.events.interceptResults, data);
-              break;
-            default:
-              break;
-          }
-        }
-      },
-      bvtContext: this.bvtContext,
-    });
-    const context = bvtContext.playContext;
-    this.context = context;
-    this.web = bvtContext.stable || bvtContext.web;
-    this.web.tryAllStrategies = true;
-    this.page = bvtContext.page;
-    this.pageSet.add(this.page);
-    this.lastKnownUrlPath = this._updateUrlPath();
-    const browser = await this.context.browser();
-    this.browser = browser;
-
-    // add bindings
-    for (const [name, handler] of Object.entries(this.bindings)) {
-      await this.context.exposeBinding(name, handler);
-    }
-    this._watchTestData();
-    this.web.onRestoreSaveState = (url) => {
-      this._initBrowser({ url });
+    shouldTakeScreenshot = true;
+    watcher = null;
+    networkEventsFolder;
+    tempProjectFolder;
+    tempSnapshotsFolder;
+    config = {};
+    bvtContext;
+    stepRunner;
+    context;
+    web;
+    page;
+    browser = null;
+    backgroundBrowser;
+    backgroundContext;
+    timerId = null;
+    previousIndex = null;
+    previousHistoryLength = null;
+    previousEntries = null;
+    previousUrl = null;
+    scenarioDoc;
+    isVerify = false;
+    /**
+     * @param initialState Initial recorder state and dependencies
+     */
+    constructor(initialState) {
+        this.envName = initialState.envName;
+        this.projectDir = initialState.projectDir;
+        this.TOKEN = initialState.TOKEN;
+        this.sendEvent = initialState.sendEvent;
+        this.logger = initialState.logger;
+        this.userId = initialState.userId;
+        this.namesService = new NamesService({
+            screenshotMap: this.screenshotMap,
+            TOKEN: this.TOKEN,
+            projectDir: this.projectDir,
+            logger: this.logger,
+        });
+        this.workspaceService = new PublishService(this.TOKEN);
+        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");
+        if (existsSync(this.networkEventsFolder)) {
+            rmSync(this.networkEventsFolder, { recursive: true, force: true });
+        }
+    }
+    events = {
+        onFrameNavigate: "BVTRecorder.onFrameNavigate",
+        onPageClose: "BVTRecorder.onPageClose",
+        onBrowserClose: "BVTRecorder.onBrowserClose",
+        onNewCommand: "BVTRecorder.command.new",
+        onCommandDetails: "BVTRecorder.onCommandDetails",
+        onStepDetails: "BVTRecorder.onStepDetails",
+        getTestData: "BVTRecorder.getTestData",
+        onGoto: "BVTRecorder.onGoto",
+        cmdExecutionStart: "BVTRecorder.cmdExecutionStart",
+        cmdExecutionSuccess: "BVTRecorder.cmdExecutionSuccess",
+        cmdExecutionError: "BVTRecorder.cmdExecutionError",
+        interceptResults: "BVTRecorder.interceptResults",
+        onDebugURLChange: "BVTRecorder.onDebugURLChange",
+        updateCommand: "BVTRecorder.updateCommand",
     };
-  }
-  async onClosePopup() {
-    // console.log("close popups");
-    await this.bvtContext.web.closeUnexpectedPopups();
-  }
-  async evaluateInAllFrames(context, script) {
-    // retry 3 times
-    for (let i = 0; i < 3; i++) {
-      try {
-        for (const page of context.pages()) {
-          await evaluate(page.mainFrame(), script);
+    bindings = {
+        __bvt_recordCommand: async ({ frame, page, context }, event) => {
+            this.#activeFrame = frame;
+            const nestFrmLoc = await findNestedFrameSelector(frame);
+            if (event.statistics?.time !== undefined) {
+                this.logger.info(`Time taken for action: ${event.statistics.time}`);
+            }
+            await this.onAction({ ...event, nestFrmLoc });
+        },
+        __bvt_getMode: async () => {
+            return this.#mode;
+        },
+        __bvt_setMode: async (_src, mode) => {
+            await this.setMode(mode);
+        },
+        __bvt_revertMode: async () => {
+            await this.revertMode();
+        },
+        __bvt_recordPageClose: async ({ page }) => {
+            this.pageSet.delete(page);
+        },
+        __bvt_closePopups: async () => {
+            await this.onClosePopup();
+        },
+        __bvt_log: async (_src, message) => {
+            this.logger.info(`Inside Browser: ${message}`);
+        },
+        __bvt_getObject: (_src, obj) => {
+            this.processObject(obj);
+        },
+    };
+    getSnapshot = async (attr) => {
+        const selector = `[__bvt_snapshot="${attr}"]`;
+        const locator = await this.web.page.locator(selector);
+        const snapshot = await locator.ariaSnapshot();
+        return snapshot;
+    };
+    processObject = async ({ type, action, value }) => {
+        switch (type) {
+            case "snapshot-element": {
+                if (action === "get-template") {
+                    return true;
+                }
+                break;
+            }
+            default: {
+                console.log("Unknown object type", type);
+                break;
+            }
         }
-        return;
-      } catch (error) {
-        // console.error("Error evaluting in context:", error);
-        this.logger.error("Error evaluating in context:", error);
-      }
-    }
-  }
-
-  getMode() {
-    // console.log("getMode", this.#mode);
-    this.logger.info("Current mode:", this.#mode);
-    return this.#mode;
-  }
-
-  async setMode(mode) {
-    await this.evaluateInAllFrames(this.context, `window.__bvt_Recorder.mode = "${mode}";`);
-    this.#previousMode = this.#mode;
-    this.#mode = mode;
-  }
-  async revertMode() {
-    await this.setMode(this.#previousMode);
-  }
-
-  async _openTab({ url }) {
-    // add listeners for new pages
-    this._addPagelisteners(this.context);
-
-    await this.page.goto(url, {
-      waitUntil: "domcontentloaded",
-    });
-    // add listener for frame navigation on current tab
-    this._addFrameNavigateListener(this.page);
-
-    // eval init script on current tab
-    // await this._initPage(this.page);
-    this.#currentURL = new URL(url).pathname;
-
-    await this.page.dispatchEvent("html", "scroll");
-    await delay(1000);
-  }
-  _addFrameNavigateListener(page) {
-    page.on("close", () => {
-      try {
-        if (!this.pageSet.has(page)) return;
-        // console.log(this.context.pages().length);
-        if (this.context.pages().length > 0) {
-          this.sendEvent(this.events.onPageClose);
-        } else {
-          // closed all tabs
-          this.sendEvent(this.events.onBrowserClose);
-        }
-      } catch (error) {
-        this.logger.error("Error in page close event");
-        this.logger.error(error);
-        console.error("Error in page close event");
-        console.error(error);
-      }
-    });
-
-    page.on("framenavigated", async (frame) => {
-      try {
-        if (frame !== page.mainFrame()) return;
-        this.handlePageTransition();
-      } catch (error) {
-        this.logger.error("Error in handlePageTransition event");
-        this.logger.error(error);
-        console.error("Error in handlePageTransition event");
-        console.error(error);
-      }
-      try {
-        if (frame !== this.#activeFrame) return;
-
-        // hack to sync the action event with the frame navigation
-        await this.storeScreenshot({
-          element: { inputID: "frame" },
+    };
+    getPWScript() {
+        const pwFolder = path.join(__dirname, "..", "..", "assets", "preload", "pw_utils");
+        const result = [];
+        for (const script of readdirSync(pwFolder)) {
+            const scriptPath = path.join(pwFolder, script);
+            const content = readFileSync(scriptPath, "utf8");
+            result.push(content);
+        }
+        return result;
+    }
+    getRecorderScripts() {
+        const recorderFolder = path.join(__dirname, "..", "..", "assets", "preload", "recorder");
+        const result = [];
+        for (const script of readdirSync(recorderFolder)) {
+            const scriptPath = path.join(recorderFolder, script);
+            const content = readFileSync(scriptPath, "utf8");
+            result.push(content);
+        }
+        return result;
+    }
+    getInitScripts(config) {
+        return getInitScript(config, {
+            sdkLanguage: "javascript",
+            testIdAttributeName: "blinq-test-id",
+            stableRafCount: 0,
+            browserName: this.browser?.browserType().name(),
+            inputFileRoleTextbox: false,
+            customEngines: [],
+            isUnderTest: true,
         });
-
-        const newPath = new URL(frame.url()).pathname;
-        const newTitle = await frame.title();
-        if (newPath !== this.#currentURL) {
-          this.sendEvent(this.events.onFrameNavigate, { url: newPath, title: newTitle });
-          this.#currentURL = newPath;
-        }
-        // await this._setRecordingMode(frame);
-        // await this._initPage(page);
-      } catch (error) {
-        this.logger.error("Error in frame navigate event");
-        this.logger.error(error);
-        console.error("Error in frame navigate event");
-        // console.error(error);
-      }
-    });
-  }
-
-  hasHistoryReplacementAtIndex(previousEntries, currentEntries, index) {
-    if (!previousEntries || !currentEntries) return false;
-    if (index >= previousEntries.length || index >= currentEntries.length) return false;
-
-    const prevEntry = previousEntries[index];
-    // console.log("prevEntry", prevEntry);
-    const currEntry = currentEntries[index];
-    // console.log("currEntry", currEntry);
-
-    // Check if the entry at this index has been replaced
-    return prevEntry.id !== currEntry.id;
-  }
-
-  // Even simpler approach for your specific case
-  analyzeTransitionType(entries, currentIndex, currentEntry) {
-    // console.log("Analyzing transition type");
-    // console.log("===========================");
-    // console.log("Current Index:", currentIndex);
-    // console.log("Current Entry:", currentEntry);
-    // console.log("Current Entries:", entries);
-    // console.log("Current entries length:", entries.length);
-    // console.log("===========================");
-    // console.log("Previous Index:", this.previousIndex);
-    // // console.log("Previous Entry:", this.previousEntries[this.previousIndex]);
-    // console.log("Previous Entries:", this.previousEntries);
-    // console.log("Previous entries length:", this.previousHistoryLength);
-
-    if (this.previousIndex === null || this.previousHistoryLength === null || !this.previousEntries) {
-      return {
-        action: "initial",
-      };
-    }
-
-    const indexDiff = currentIndex - this.previousIndex;
-    const lengthDiff = entries.length - this.previousHistoryLength;
-
-    // Backward navigation
-    if (indexDiff < 0) {
-      return { action: "back" };
-    }
-
-    // Forward navigation
-    if (indexDiff > 0 && lengthDiff === 0) {
-      // Check if the entry at current index is the same as before
-      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
-
-      if (entryReplaced) {
-        return { action: "navigate" }; // New navigation that replaced forward history
-      } else {
-        return { action: "forward" }; // True forward navigation
-      }
-    }
-
-    // New navigation (history grew)
-    if (lengthDiff > 0) {
-      return { action: "navigate" };
-    }
-
-    // Same position, same length
-    if (lengthDiff <= 0) {
-      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
-
-      return entryReplaced ? { action: "navigate" } : { action: "reload" };
-    }
-
-    return { action: "unknown" };
-  }
-
-  async getCurrentTransition() {
-    if (this?.web?.browser?._name !== "chromium") {
-      return;
-    }
-    const client = await this.context.newCDPSession(this.web.page);
-
-    try {
-      const result = await client.send("Page.getNavigationHistory");
-      const entries = result.entries;
-      const currentIndex = result.currentIndex;
-
-      const currentEntry = entries[currentIndex];
-      const transitionInfo = this.analyzeTransitionType(entries, currentIndex, currentEntry);
-      this.previousIndex = currentIndex;
-      this.previousHistoryLength = entries.length;
-      this.previousUrl = currentEntry.url;
-      this.previousEntries = [...entries]; // Store a copy of current entries
-
-      return {
-        currentEntry,
-        navigationAction: transitionInfo.action,
-      };
-    } catch (error) {
-      this.logger.error("Error in getCurrentTransition event");
-      this.logger.error(error);
-      console.error("Error in getTransistionType event", error);
-    } finally {
-      await client.detach();
-    }
-  }
-  userInitiatedTransitionTypes = ["typed", "address_bar"];
-  async handlePageTransition() {
-    const transition = await this.getCurrentTransition();
-    if (!transition) return;
-
-    const { currentEntry, navigationAction } = transition;
-
-    switch (navigationAction) {
-      case "initial":
-        // console.log("Initial navigation, no action taken");
-        return;
-      case "navigate":
-        // console.log("transitionType", transition.transitionType);
-        // console.log("sending onGoto event", { url: currentEntry.url,
-        // type: "navigate", });
-        if (this.userInitiatedTransitionTypes.includes(currentEntry.transitionType)) {
-          const env = JSON.parse(readFileSync(this.envName), "utf8");
-          const baseUrl = env.baseUrl;
-          let url = currentEntry.userTypedURL;
-          if (baseUrl && url.startsWith(baseUrl)) {
-            url = url.replace(baseUrl, "{{env.baseUrl}}");
-          }
-          // console.log("User initiated transition");
-          this.sendEvent(this.events.onGoto, { url, type: "navigate" });
+    }
+    async _initBrowser({ url }) {
+        if (process.env.CDP_LISTEN_PORT === undefined) {
+            this.#remoteDebuggerPort = await findAvailablePort();
+            process.env.CDP_LISTEN_PORT = String(this.#remoteDebuggerPort);
         }
-        return;
-      case "back":
-        // console.log("User navigated back");
-        // console.log("sending onGoto event", {
-        //   type: "back",
-        // });
-        this.sendEvent(this.events.onGoto, { type: "back" });
-        return;
-      case "forward":
-        // console.log("User navigated forward"); console.log("sending onGoto event", { type: "forward", });
-        this.sendEvent(this.events.onGoto, { type: "forward" });
-        return;
-      default:
-        this.sendEvent(this.events.onGoto, { type: "unknown" });
-        return;
+        else {
+            this.#remoteDebuggerPort = Number(process.env.CDP_LISTEN_PORT);
+        }
+        // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
+        const ai_config_file = path.join(this.projectDir, "ai_config.json");
+        let ai_config = {};
+        if (existsSync(ai_config_file)) {
+            try {
+                ai_config = JSON.parse(readFileSync(ai_config_file, "utf8"));
+            }
+            catch (error) {
+                this.logger.error("Error reading ai_config.json", { error });
+            }
+        }
+        this.config = ai_config;
+        const initScripts = {
+            recorderCjs: null,
+            scripts: [
+                this.getInitScripts(ai_config),
+                `\ndelete Object.getPrototypeOf(navigator).webdriver;${process.env.WINDOW_DEBUGGER ? "window.debug=true;\n" : ""}`,
+            ],
+        };
+        const scenario = { pickle: this.scenarioDoc };
+        const bvtContext = await initContext(url, false, false, this.world, 450, initScripts, this.envName, scenario);
+        this.bvtContext = bvtContext;
+        this.stepRunner = new BVTStepRunner({
+            projectDir: this.projectDir,
+            sendExecutionStatus: (data) => {
+                if (data && data.type) {
+                    switch (data.type) {
+                        case "cmdExecutionStart":
+                            this.sendEvent(this.events.cmdExecutionStart, data);
+                            break;
+                        case "cmdExecutionSuccess":
+                            this.sendEvent(this.events.cmdExecutionSuccess, data);
+                            break;
+                        case "cmdExecutionError":
+                            this.sendEvent(this.events.cmdExecutionError, data);
+                            break;
+                        case "interceptResults":
+                            this.sendEvent(this.events.interceptResults, data);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            },
+            bvtContext: this.bvtContext,
+        });
+        this.context = bvtContext.playContext;
+        this.web = bvtContext.stable || bvtContext.web;
+        this.web.tryAllStrategies = true;
+        this.page = bvtContext.page;
+        this.pageSet.add(this.page);
+        this.lastKnownUrlPath = this._updateUrlPath();
+        const browser = await this.context.browser();
+        this.browser = browser;
+        // add bindings
+        for (const [name, handler] of Object.entries(this.bindings)) {
+            await this.context.exposeBinding(name, handler);
+        }
+        this._watchTestData();
+        this.web.onRestoreSaveState = async (url) => {
+            await this._initBrowser({ url });
+            this._addPagelisteners(this.context);
+            this._addFrameNavigateListener(this.page);
+        };
+        // create a second browser for locator generation
+        this.backgroundBrowser = await chromium.launch({
+            headless: true,
+        });
+        this.backgroundContext = await this.backgroundBrowser.newContext({});
+        await this.backgroundContext.addInitScript({ content: this.getInitScripts(this.config) });
+        await this.backgroundContext.newPage();
     }
-  }
-
-  async getCurrentPageTitle() {
-    const title = await this.page.title();
-    return title;
-  }
-  async getCurrentPageUrl() {
-    const url = await this.page.url();
-    return url;
-  }
-
-  _addPagelisteners(context) {
-    context.on("page", async (page) => {
-      try {
-        if (page.isClosed()) return;
-        this.pageSet.add(page);
-
-        await page.waitForLoadState("domcontentloaded");
-
-        // add listener for frame navigation on new tab
-        this._addFrameNavigateListener(page);
-      } catch (error) {
-        this.logger.error("Error in page event");
-        this.logger.error(error);
-        console.error("Error in page event");
-        console.error(error);
-      }
-    });
-  }
-  async openBrowser() {
-    const env = JSON.parse(readFileSync(this.envName), "utf8");
-    const url = env.baseUrl;
-    await this._initBrowser({ url });
-    await this._openTab({ url });
-    process.env.TEMP_RUN = true;
-  }
-  overlayLocators(event) {
-    let locatorsResults = [...event.locators];
-    const cssLocators = event.cssLocators;
-    for (const cssLocator of cssLocators) {
-      locatorsResults.push({ mode: "NO_TEXT", css: cssLocator });
-    }
-    if (event.digitLocators) {
-      for (const digitLocator of event.digitLocators) {
-        digitLocator.mode = "IGNORE_DIGIT";
-        locatorsResults.push(digitLocator);
-      }
-    }
-    if (event.contextLocator) {
-      locatorsResults.push({
-        mode: "CONTEXT",
-        text: event.contextLocator.texts[0],
-        css: event.contextLocator.css,
-        climb: event.contextLocator.climbCount,
-      });
-    }
-    return locatorsResults;
-  }
-  async getScreenShot() {
-    const client = await this.context.newCDPSession(this.web.page);
-    try {
-      // Using CDP to capture the screenshot
-      const { data } = await client.send("Page.captureScreenshot", { format: "png" });
-      return data;
-    } catch (error) {
-      this.logger.error("Error in taking browser screenshot");
-      console.error("Error in taking browser screenshot", error);
-    } finally {
-      await client.detach();
-    }
-  }
-  async storeScreenshot(event) {
-    try {
-      // const spath = path.join(__dirname, "media", `${event.inputID}.png`);
-      const screenshotURL = await this.getScreenShot();
-      this.screenshotMap.set(event.element.inputID, screenshotURL);
-      // writeFileSync(spath, screenshotURL, "base64");
-    } catch (error) {
-      console.error("Error in saving screenshot: ", error);
-    }
-  }
-  async onAction(event) {
-    this._updateUrlPath();
-    // const locators = this.overlayLocators(event);
-    const cmdEvent = {
-      ...event.element,
-      ...transformAction(
-        event.action,
-        event.element,
-        event.mode === "recordingText" || event.mode === "recordingContext",
-        event.isPopupCloseClick,
-        event.mode === "recordingHover",
-        event.mode === "multiInspecting"
-      ),
-      locators: {
-        locators: event.locators,
-        iframe_src: !event.frame.isTop ? event.frame.url : undefined,
-      },
-      allStrategyLocators: event.allStrategyLocators,
-      url: event.frame.url,
-      title: event.frame.title,
-      extract: {},
-      lastKnownUrlPath: this.lastKnownUrlPath,
-    };
-    if (event.nestFrmLoc?.children) {
-      cmdEvent.locators.nestFrmLoc = event.nestFrmLoc.children;
+    async onClosePopup() {
+        // console.log("close popups");
+        await this.bvtContext.web?.closeUnexpectedPopups(null, null);
     }
-    // this.logger.info({ event });
-    if (this.shouldTakeScreenshot) {
-      await this.storeScreenshot(event);
+    async evaluateInAllFrames(context, script) {
+        // retry 3 times
+        for (let i = 0; i < 3; i++) {
+            try {
+                for (const page of context.pages()) {
+                    await evaluate(page.mainFrame(), script);
+                }
+                return;
+            }
+            catch (error) {
+                // console.error("Error evaluting in context:", error);
+                this.logger.error("Error evaluating in context", { error });
+            }
+        }
     }
-    this.sendEvent(this.events.onNewCommand, cmdEvent);
-    this._updateUrlPath();
-  }
-  _updateUrlPath() {
-    try {
-      let url = this.bvtContext.web.page.url();
-      if (url === "about:blank") {
-        return;
-      } else {
-        this.lastKnownUrlPath = new URL(url).pathname;
-      }
-    } catch (error) {
-      console.error("Error in getting last known url path", error);
-    }
-  }
-  async closeBrowser() {
-    delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => {});
-    this.watcher = null;
-    this.previousIndex = null;
-    this.previousHistoryLength = null;
-    this.previousUrl = null;
-    this.previousEntries = null;
-
-    await closeContext();
-    this.pageSet.clear();
-  }
-  async reOpenBrowser(input) {
-    if (input && input.envName) {
-      this.envName = path.join(this.projectDir, "environments", input.envName + ".json");
-      process.env.BLINQ_ENV = this.envName;
-    }
-    await this.closeBrowser();
-    //   logger.log("closed");
-    await delay(1000);
-    await this.openBrowser();
-    //   logger.log("opened");
-  }
-  async getNumberOfOccurrences({ searchString, regex = false, partial = true, ignoreCase = false, tag = "*" }) {
-    this.isVerify = false;
-    //const script = `window.countStringOccurrences(${JSON.stringify(searchString)});`;
-    if (searchString.length === 0) return -1;
-    let result = 0;
-    for (let i = 0; i < 3; i++) {
-      result = 0;
-      try {
-        for (const page of this.context.pages()) {
-          for (const frame of page.frames()) {
+    getMode() {
+        // console.log("getMode", this.#mode);
+        this.logger.info("Current mode", { mode: this.#mode });
+        return this.#mode;
+    }
+    async setMode(mode) {
+        await this.evaluateInAllFrames(this.context, `window.__bvt_Recorder.mode = "${mode}";`);
+        this.#previousMode = this.#mode;
+        this.#mode = mode;
+    }
+    async revertMode() {
+        await this.setMode(this.#previousMode);
+    }
+    async _openTab({ url }) {
+        // add listeners for new pages
+        this._addPagelisteners(this.context);
+        await this.page.goto(url, {
+            waitUntil: "domcontentloaded",
+            timeout: typeof this.config.page_timeout === "number" ? this.config.page_timeout : 60_000,
+        });
+        // add listener for frame navigation on current tab
+        this._addFrameNavigateListener(this.page);
+        // eval init script on current tab
+        // await this._initPage(this.page);
+        this.#currentURL = url;
+        await this.page.dispatchEvent("html", "scroll");
+        await delay(1000);
+    }
+    _addFrameNavigateListener(page) {
+        page.on("close", () => {
             try {
-              //scope, text1, tag1, regex1 = false, partial1, ignoreCase = true, _params: Params)
-              const frameResult = await this.web._locateElementByText(
-                frame,
-                searchString,
-                tag,
-                regex,
-                partial,
-                ignoreCase,
-                {}
-              );
-              result += frameResult.elementCount;
-            } catch (e) {
-              console.log(e);
+                if (!this.pageSet.has(page))
+                    return;
+                // console.log(this.context.pages().length);
+                if (this.context.pages().length > 0) {
+                    this.sendEvent(this.events.onPageClose);
+                }
+                else {
+                    // closed all tabs
+                    this.sendEvent(this.events.onBrowserClose);
+                }
+            }
+            catch (error) {
+                this.logger.error("Error in page close event", { error });
+                console.error("Error in page close event");
+                console.error(error);
             }
-          }
+        });
+        page.on("framenavigated", async (frame) => {
+            try {
+                if (frame !== page.mainFrame())
+                    return;
+                await this.handlePageTransition();
+            }
+            catch (error) {
+                this.logger.error("Error in handlePageTransition event", { error });
+                console.error("Error in handlePageTransition event");
+                console.error(error);
+            }
+            try {
+                if (frame !== this.#activeFrame)
+                    return;
+                // hack to sync the action event with the frame navigation
+                await this.storeScreenshot({
+                    element: { inputID: "frame" },
+                });
+                const newUrl = frame.url();
+                const newPath = new URL(newUrl).pathname;
+                const newTitle = await frame.title();
+                const changed = diffPaths(this.#currentURL, newUrl);
+                if (changed) {
+                    this.sendEvent(this.events.onFrameNavigate, { url: newPath, title: newTitle });
+                    this.#currentURL = newUrl;
+                }
+            }
+            catch (error) {
+                this.logger.error("Error in frame navigate event", { error });
+                console.error("Error in frame navigate event");
+                // console.error(error);
+            }
+        });
+    }
+    hasHistoryReplacementAtIndex(previousEntries, currentEntries, index) {
+        if (!previousEntries || !currentEntries)
+            return false;
+        if (index >= previousEntries.length || index >= currentEntries.length)
+            return false;
+        const prevEntry = previousEntries[index];
+        // console.log("prevEntry", prevEntry);
+        const currEntry = currentEntries[index];
+        // console.log("currEntry", currEntry);
+        // Check if the entry at this index has been replaced
+        return prevEntry.id !== currEntry.id;
+    }
+    // Even simpler approach for your specific case
+    analyzeTransitionType(entries, currentIndex, currentEntry) {
+        // console.log("Analyzing transition type");
+        // console.log("===========================");
+        // console.log("Current Index:", currentIndex);
+        // console.log("Current Entry:", currentEntry);
+        // console.log("Current Entries:", entries);
+        // console.log("Current entries length:", entries.length);
+        // console.log("===========================");
+        // console.log("Previous Index:", this.previousIndex);
+        // // console.log("Previous Entry:", this.previousEntries[this.previousIndex]);
+        // console.log("Previous Entries:", this.previousEntries);
+        // console.log("Previous entries length:", this.previousHistoryLength);
+        if (this.previousIndex === null || this.previousHistoryLength === null || !this.previousEntries) {
+            return {
+                action: "initial",
+            };
         }
-
-        return result;
-      } catch (e) {
-        console.log(e);
-        result = 0;
-      }
-    }
-  }
-
-  async startRecordingInput() {
-    await this.setMode("recordingInput");
-  }
-  async stopRecordingInput() {
-    await this.setMode("idle");
-  }
-  async startRecordingText(isInspectMode) {
-    if (isInspectMode) {
-      await this.setMode("inspecting");
-    } else {
-      await this.setMode("recordingText");
-    }
-  }
-  async stopRecordingText() {
-    await this.setMode("idle");
-  }
-  async startRecordingContext() {
-    await this.setMode("recordingContext");
-  }
-  async stopRecordingContext() {
-    await this.setMode("idle");
-  }
-
-  async abortExecution() {
-    await this.stepRunner.abortExecution();
-  }
-
-  async pauseExecution({ cmdId }) {
-    await this.stepRunner.pauseExecution(cmdId);
-  }
-
-  async resumeExecution({ cmdId }) {
-    await this.stepRunner.resumeExecution(cmdId);
-  }
-
-  async dealyedRevertMode() {
-    const timerId = setTimeout(async () => {
-      await this.revertMode();
-    }, 100);
-    this.timerId = timerId;
-  }
-  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
-    const { skipAfter = true, skipBefore = !isFirstStep } = options || {};
-    const _env = {
-      TOKEN: this.TOKEN,
-      TEMP_RUN: true,
-      REPORT_FOLDER: this.bvtContext.reportFolder,
-      BLINQ_ENV: this.envName,
-      DEBUG: "blinq:route",
-    };
-
-    this.bvtContext.navigate = true;
-    this.bvtContext.loadedRoutes = null;
-    if (listenNetwork) {
-      this.bvtContext.STORE_DETAILED_NETWORK_DATA = true;
-    } else {
-      this.bvtContext.STORE_DETAILED_NETWORK_DATA = false;
-    }
-    for (const [key, value] of Object.entries(_env)) {
-      process.env[key] = value;
-    }
-
-    if (this.timerId) {
-      clearTimeout(this.timerId);
-      this.timerId = null;
-    }
-    await this.setMode("running");
-
-    try {
-      const { result, info } = await this.stepRunner.runStep(
-        {
-          step,
-          parametersMap,
-          envPath: this.envName,
-          tags,
-          config: this.config,
-        },
-        this.bvtContext,
-        {
-          skipAfter,
-          skipBefore,
-        }
-      );
-      await this.revertMode();
-      return { info };
-    } catch (error) {
-      await this.revertMode();
-      throw error;
-    } finally {
-      for (const key of Object.keys(_env)) {
-        delete process.env[key];
-      }
-      this.bvtContext.navigate = false;
-    }
-  }
-  async saveScenario({ scenario, featureName, override, isSingleStep }) {
-    await updateStepDefinitions({ scenario, featureName, projectDir: this.projectDir }); // updates mjs files
-    if (!isSingleStep) await updateFeatureFile({ featureName, scenario, override, projectDir: this.projectDir }); // updates gherkin files
-    await this.cleanup({ tags: scenario.tags });
-  }
-  async getImplementedSteps() {
-    const stepsAndScenarios = await getImplementedSteps(this.projectDir);
-    const implementedSteps = stepsAndScenarios.implementedSteps;
-    const scenarios = stepsAndScenarios.scenarios;
-    for (const scenario of scenarios) {
-      this.scenariosStepsMap.set(scenario.name, scenario.steps);
-      delete scenario.steps;
+        const indexDiff = currentIndex - this.previousIndex;
+        const lengthDiff = entries.length - this.previousHistoryLength;
+        // Backward navigation
+        if (indexDiff < 0) {
+            return { action: "back" };
+        }
+        // Forward navigation
+        if (indexDiff > 0 && lengthDiff === 0) {
+            // Check if the entry at current index is the same as before
+            const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+            if (entryReplaced) {
+                return { action: "navigate" }; // New navigation that replaced forward history
+            }
+            else {
+                return { action: "forward" }; // True forward navigation
+            }
+        }
+        // New navigation (history grew)
+        if (lengthDiff > 0) {
+            return { action: "navigate" };
+        }
+        // Same position, same length
+        if (lengthDiff <= 0) {
+            const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+            return entryReplaced ? { action: "navigate" } : { action: "reload" };
+        }
+        return { action: "unknown" };
     }
-    return {
-      implementedSteps,
-      scenarios,
-    };
-  }
-  async getStepsAndCommandsForScenario({ name, featureName }) {
-    const steps = this.scenariosStepsMap.get(name) || [];
-    for (const step of steps) {
-      if (step.isImplemented) {
-        step.commands = this.getCommandsForImplementedStep({ stepName: step.text });
-      } else {
-        step.commands = [];
-      }
-    }
-    return steps;
-    // return getStepsAndCommandsForScenario({
-    //   name,
-    //   featureName,
-    //   projectDir: this.projectDir,
-    //   map: this.scenariosStepsMap,
-    // });
-  }
-
-  async generateStepName({ commands, stepsNames, parameters, map }) {
-    return await this.namesService.generateStepName({ commands, stepsNames, parameters, map });
-  }
-  async generateScenarioAndFeatureNames(scenarioAsText) {
-    return await this.namesService.generateScenarioAndFeatureNames(scenarioAsText);
-  }
-  async generateCommandName({ command }) {
-    return await this.namesService.generateCommandName({ command });
-  }
-
-  async getCurrentChromiumPath() {
-    const currentURL = await this.bvtContext.web.page.url();
-    const env = JSON.parse(readFileSync(this.envName), "utf8");
-    const baseURL = env.baseUrl;
-    const relativeURL = currentURL.startsWith(baseURL) ? currentURL.replace(baseURL, "/") : undefined;
-    return {
-      relativeURL,
-      baseURL,
-      currentURL,
-    };
-  }
-
-  getReportFolder() {
-    if (this.bvtContext.reportFolder) {
-      return this.bvtContext.reportFolder;
-    } else return "";
-  }
-
-  getSnapshotFolder() {
-    if (this.bvtContext.snapshotFolder) {
-      return path.join(process.cwd(), this.bvtContext.snapshotFolder);
-    } else return "";
-  }
-
-  async overwriteTestData(data) {
-    this.bvtContext.stable.overwriteTestData(data.value, this.world);
-  }
-
-  _watchTestData() {
-    this.watcher = chokidar.watch(_getDataFile(this.world, this.bvtContext, this.web), {
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 2000,
-        pollInterval: 100,
-      },
-    });
-
-    if (existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
-      try {
-        const testData = JSON.parse(readFileSync(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
-        // this.logger.info("Test data", testData);
-        this.sendEvent(this.events.getTestData, testData);
-      } catch (e) {
-        // this.logger.error("Error reading test data file", e);
-        console.log("Error reading test data file", e);
-      }
-    }
-
-    this.logger.info("Watching for test data changes");
-
-    this.watcher.on("all", async (event, path) => {
-      try {
-        const testData = JSON.parse(await readFile(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
-        // this.logger.info("Test data", testData);
-        console.log("Test data changed", testData);
-        this.sendEvent(this.events.getTestData, testData);
-      } catch (e) {
-        // this.logger.error("Error reading test data file", e);
-        console.log("Error reading test data file", e);
-      }
-    });
-  }
-  async loadTestData({ data, type }) {
-    if (type === "user") {
-      const username = data.username;
-      await this.web.loadTestDataAsync("users", username, this.world);
-    } else {
-      const csv = data.csv;
-      const row = data.row;
-      // code = `await context.web.loadTestDataAsync("csv","${csv}:${row}", this)`;
-      await this.web.loadTestDataAsync("csv", `${csv}:${row}`, this.world);
-    }
-  }
-
-  async discardTestData({ tags }) {
-    resetTestData(this.envName, this.world);
-    await this.cleanup({ tags });
-  }
-  async addToTestData(obj) {
-    if (!existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
-      await writeFile(_getDataFile(this.world, this.bvtContext, this.web), JSON.stringify({}), "utf8");
-    }
-    let data = JSON.parse(await readFile(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
-    data = Object.assign(data, obj);
-    await writeFile(_getDataFile(this.world, this.bvtContext, this.web), JSON.stringify(data), "utf8");
-  }
-  getScenarios() {
-    const featureFiles = readdirSync(path.join(this.projectDir, "features"))
-      .filter((file) => file.endsWith(".feature"))
-      .map((file) => path.join(this.projectDir, "features", file));
-    try {
-      const parsedFiles = featureFiles.map((file) => this.parseFeatureFile(file));
-      const output = {};
-      parsedFiles.forEach((file) => {
-        if (!file.feature) return;
-        if (!file.feature.name) return;
-        output[file.feature.name] = [];
-        file.feature.children.forEach((child) => {
-          if (child.scenario) {
-            output[file.feature.name].push(child.scenario.name);
-          }
+    async getCurrentTransition() {
+        if (this?.web?.browser?._name !== "chromium") {
+            return;
+        }
+        const client = await this.context.newCDPSession(this.web.page);
+        try {
+            const result = await client.send("Page.getNavigationHistory");
+            const entries = result.entries;
+            const currentIndex = result.currentIndex;
+            const currentEntry = entries[currentIndex];
+            const transitionInfo = this.analyzeTransitionType(entries, currentIndex, currentEntry);
+            this.previousIndex = currentIndex;
+            this.previousHistoryLength = entries.length;
+            this.previousUrl = currentEntry.url;
+            this.previousEntries = [...entries]; // Store a copy of current entries
+            return {
+                currentEntry,
+                navigationAction: transitionInfo.action,
+            };
+        }
+        catch (error) {
+            this.logger.error("Error in getCurrentTransition event", { error });
+            console.error("Error in getTransistionType event", error);
+        }
+        finally {
+            await client.detach();
+        }
+    }
+    userInitiatedTransitionTypes = ["typed", "address_bar"];
+    async handlePageTransition() {
+        const transition = await this.getCurrentTransition();
+        if (!transition)
+            return;
+        const { currentEntry, navigationAction } = transition;
+        switch (navigationAction) {
+            case "initial":
+                // console.log("Initial navigation, no action taken");
+                return;
+            case "navigate":
+                // console.log("transitionType", transition.transitionType);
+                // console.log("sending onGoto event", { url: currentEntry.url,
+                // type: "navigate", });
+                if (this.userInitiatedTransitionTypes.includes(currentEntry.transitionType)) {
+                    const env = JSON.parse(readFileSync(this.envName, "utf8"));
+                    const baseUrl = env.baseUrl;
+                    let url = currentEntry.userTypedURL;
+                    if (baseUrl && url.startsWith(baseUrl)) {
+                        url = url.replace(baseUrl, "{{env.baseUrl}}");
+                    }
+                    // console.log("User initiated transition");
+                    this.sendEvent(this.events.onGoto, { url, type: "navigate" });
+                }
+                return;
+            case "back":
+                // console.log("User navigated back");
+                // console.log("sending onGoto event", {
+                //   type: "back",
+                // });
+                this.sendEvent(this.events.onGoto, { type: "back" });
+                return;
+            case "forward":
+                // console.log("User navigated forward"); console.log("sending onGoto event", { type: "forward", });
+                this.sendEvent(this.events.onGoto, { type: "forward" });
+                return;
+            default:
+                this.sendEvent(this.events.onGoto, { type: "unknown" });
+                return;
+        }
+    }
+    async getCurrentPageTitle() {
+        let title = "";
+        try {
+            title = await this.bvtContext?.page?.title();
+        }
+        catch (e) {
+            this.logger.error(`Error getting page title: ${getErrorMessage(e)}`);
+        }
+        return title;
+    }
+    getCurrentPageUrl() {
+        let url = "";
+        try {
+            url = this.bvtContext?.page?.url();
+        }
+        catch (e) {
+            this.logger.error(`Error getting page url: ${getErrorMessage(e)}`);
+        }
+        return url;
+    }
+    _addPagelisteners(context) {
+        context.on("page", async (page) => {
+            try {
+                if (page.isClosed())
+                    return;
+                this.pageSet.add(page);
+                await page.waitForLoadState("domcontentloaded");
+                // add listener for frame navigation on new tab
+                this._addFrameNavigateListener(page);
+            }
+            catch (error) {
+                this.logger.error(`Error in page event: ${getErrorMessage(error)}`, undefined, "_addPagelisteners");
+            }
+        });
+    }
+    async openBrowser(_input) {
+        const env = JSON.parse(readFileSync(this.envName, "utf8"));
+        const url = env.baseUrl;
+        await this._initBrowser({ url });
+        await this._openTab({ url });
+        process.env.TEMP_RUN = "true";
+    }
+    overlayLocators(event) {
+        const locatorsResults = [...(event.locators ?? [])];
+        for (const cssLocator of event.cssLocators ?? []) {
+            locatorsResults.push({ mode: "NO_TEXT", css: cssLocator });
+        }
+        if (event.digitLocators) {
+            for (const digitLocator of event.digitLocators) {
+                locatorsResults.push({ ...digitLocator, mode: "IGNORE_DIGIT" });
+            }
+        }
+        if (event.contextLocator) {
+            locatorsResults.push({
+                mode: "CONTEXT",
+                text: event.contextLocator.texts?.[0],
+                css: event.contextLocator.css,
+                climb: event.contextLocator.climbCount,
+            });
+        }
+        return locatorsResults;
+    }
+    setShouldTakeScreenshot(input) {
+        this.shouldTakeScreenshot = input?.value;
+    }
+    async getScreenShot() {
+        const client = await this.context.newCDPSession(this.web.page);
+        try {
+            // Using CDP to capture the screenshot
+            const { data } = await client.send("Page.captureScreenshot", { format: "png" });
+            return data;
+        }
+        catch (error) {
+            this.logger.error("Error in taking browser screenshot", { error });
+            console.error("Error in taking browser screenshot", error);
+        }
+        finally {
+            await client.detach();
+        }
+    }
+    async storeScreenshot(event) {
+        try {
+            // const spath = path.join(__dirname, "media", `${event.inputID}.png`);
+            const screenshotURL = await this.getScreenShot();
+            if (!event.element.inputID) {
+                return;
+            }
+            const inputId = event.element.inputID;
+            if (!screenshotURL) {
+                return;
+            }
+            this.screenshotMap.set(inputId, screenshotURL);
+            // writeFileSync(spath, screenshotURL, "base64");
+        }
+        catch (error) {
+            this.logger.error(`Error in storeScreenshot: ${getErrorMessage(error)}`, undefined, "storeScreenshot");
+        }
+    }
+    async generateLocators(event) {
+        const snapshotDetails = event.snapshotDetails;
+        if (!snapshotDetails) {
+            throw new Error("No snapshot details found");
+        }
+        const mode = event.mode;
+        const inputID = event.element.inputID;
+        const { id, contextId, doc } = snapshotDetails;
+        if (!doc) {
+            throw new Error("Snapshot details missing document content");
+        }
+        // const selector = `[data-blinq-id="${id}"]`;
+        if (!this.backgroundContext) {
+            throw new Error("Background context not initialized");
+        }
+        const newPage = await this.backgroundContext.newPage();
+        const htmlDoc = doc;
+        await newPage.setContent(htmlDoc, { waitUntil: "domcontentloaded" });
+        const locatorsObj = await newPage.evaluate(([id, contextId, mode]) => {
+            const recorder = window.__bvt_Recorder;
+            const contextElement = document.querySelector(`[data-blinq-context-id="${contextId}"]`);
+            const el = document.querySelector(`[data-blinq-id="${id}"]`);
+            if (!recorder || !el) {
+                return { locators: [], allStrategyLocators: [] };
+            }
+            if (contextElement && recorder.locatorGenerator.toContextLocators) {
+                const result = recorder.locatorGenerator.toContextLocators(el, contextElement);
+                return result ?? { locators: [], allStrategyLocators: [] };
+            }
+            const isRecordingText = mode === "recordingText";
+            return recorder.locatorGenerator.getElementLocators(el, {
+                excludeText: isRecordingText,
+            });
+        }, [id, contextId, mode]);
+        // console.log(`Generated locators: for ${inputID}: `, JSON.stringify(locatorsObj));
+        await newPage.close();
+        if (event.nestFrmLoc?.children) {
+            locatorsObj.nestFrmLoc = event.nestFrmLoc.children;
+        }
+        this.sendEvent(this.events.updateCommand, {
+            locators: {
+                locators: locatorsObj.locators,
+                nestFrmLoc: locatorsObj.nestFrmLoc,
+                iframe_src: !event.frame.isTop ? event.frame.url : undefined,
+            },
+            allStrategyLocators: locatorsObj.allStrategyLocators,
+            inputID,
         });
-      });
-
-      return output;
-    } catch (e) {
-      console.log(e);
-    }
-    return {};
-  }
-  getCommandsForImplementedStep({ stepName }) {
-    const step_definitions = loadStepDefinitions(this.projectDir);
-    const stepParams = parseStepTextParameters(stepName);
-    return getCommandsForImplementedStep(stepName, step_definitions, stepParams).commands;
-  }
-
-  loadExistingScenario({ featureName, scenarioName }) {
-    const step_definitions = loadStepDefinitions(this.projectDir);
-    const featureFilePath = path.join(this.projectDir, "features", featureName);
-    const gherkinDoc = this.parseFeatureFile(featureFilePath);
-    const scenario = gherkinDoc.feature.children.find((child) => child.scenario.name === scenarioName)?.scenario;
-
-    const steps = [];
-    const parameters = [];
-    if (scenario.examples && scenario.examples.length > 0) {
-      const example = scenario.examples[0];
-      example?.tableHeader?.cells.forEach((cell, index) => {
-        parameters.push({
-          key: cell.value,
-          value: unEscapeNonPrintables(example.tableBody[0].cells[index].value),
+        // const
+    }
+    async onAction(event) {
+        mixpanelTrackEvent(MIXPANEL_EVENTS.STEP_IN_SCENARIO, this.userId);
+        this._updateUrlPath();
+        // const locators = this.overlayLocators(event);
+        const cmdEvent = {
+            ...event.element,
+            ...transformAction(event.action, event.element, event.mode === "recordingText" || event.mode === "recordingContext", !!event.isPopupCloseClick, event.mode === "recordingHover", event.mode === "multiInspecting"),
+            // locators: {
+            //   locators: event.locators,
+            //   iframe_src: !event.frame.isTop ? event.frame.url : undefined,
+            // },
+            // allStrategyLocators: event.allStrategyLocators,
+            url: event.frame.url,
+            title: event.frame.title,
+            extract: {},
+            lastKnownUrlPath: this.lastKnownUrlPath,
+        };
+        // if (event.nestFrmLoc?.children) {
+        //   cmdEvent.locators.nestFrmLoc = event.nestFrmLoc.children;
+        // }
+        // this.logger.info({ event });
+        if (this.shouldTakeScreenshot) {
+            await this.storeScreenshot(event);
+        }
+        // this.sendEvent(this.events.onNewCommand, cmdEvent);
+        // this._updateUrlPath();
+        if (event.locators) {
+            Object.assign(cmdEvent, {
+                locators: {
+                    locators: event.locators,
+                    iframe_src: !event.frame.isTop ? event.frame.url : undefined,
+                    nestFrmLoc: event.nestFrmLoc?.children,
+                },
+                allStrategyLocators: event.allStrategyLocators,
+            });
+            this.sendEvent(this.events.onNewCommand, cmdEvent);
+            this._updateUrlPath();
+        }
+        else {
+            this.sendEvent(this.events.onNewCommand, cmdEvent);
+            this._updateUrlPath();
+            await this.generateLocators(event);
+        }
+    }
+    _updateUrlPath() {
+        try {
+            const url = this.bvtContext?.web?.page.url();
+            if (url && url !== "about:blank") {
+                this.lastKnownUrlPath = new URL(url).pathname;
+            }
+        }
+        catch (error) {
+            this.logger.error("Error in getting last known url path", { error });
+        }
+        return this.lastKnownUrlPath;
+    }
+    async closeBrowser(_input) {
+        delete process.env.TEMP_RUN;
+        await this.watcher?.close();
+        this.watcher = null;
+        this.previousIndex = null;
+        this.previousHistoryLength = null;
+        this.previousUrl = null;
+        this.previousEntries = null;
+        await closeContext();
+        this.pageSet.clear();
+    }
+    async reOpenBrowser(input) {
+        if (input && input.envName) {
+            this.envName = path.join(this.projectDir, "environments", input.envName + ".json");
+            process.env.BLINQ_ENV = this.envName;
+        }
+        await this.closeBrowser();
+        //   logger.log("closed");
+        await delay(1000);
+        await this.openBrowser();
+        //   logger.log("opened");
+    }
+    async getNumberOfOccurrences({ searchString, regex = false, partial = true, ignoreCase = false, tag = "*", }) {
+        this.isVerify = false;
+        //const script = `window.countStringOccurrences(${JSON.stringify(searchString)});`;
+        if (searchString.length === 0)
+            return -1;
+        let result = 0;
+        for (let i = 0; i < 3; i++) {
+            result = 0;
+            try {
+                // for (const page of this.context.pages()) {
+                const page = this.web.page;
+                for (const frame of page.frames()) {
+                    try {
+                        //scope, text1, tag1, regex1 = false, partial1, ignoreCase = true, _params: Params)
+                        const frameResult = await this.web._locateElementByText(frame, searchString, tag, regex, partial, ignoreCase, {});
+                        result += frameResult.elementCount;
+                    }
+                    catch (e) {
+                        console.log(e);
+                    }
+                }
+                // }
+                return result;
+            }
+            catch (e) {
+                console.log(e);
+                result = 0;
+            }
+        }
+    }
+    async startRecordingInput(_input) {
+        await this.setMode("recordingInput");
+    }
+    async stopRecordingInput(_input) {
+        await this.setMode("idle");
+    }
+    async startRecordingText(input) {
+        const isInspectMode = typeof input === "boolean" ? input : !!input?.isInspectMode;
+        if (isInspectMode) {
+            await this.setMode("inspecting");
+        }
+        else {
+            await this.setMode("recordingText");
+        }
+    }
+    async stopRecordingText(_input) {
+        await this.setMode("idle");
+    }
+    async startRecordingContext(_input) {
+        await this.setMode("recordingContext");
+    }
+    async stopRecordingContext(_input) {
+        await this.setMode("idle");
+    }
+    async abortExecution() {
+        await this.stepRunner.abortExecution();
+    }
+    async pauseExecution({ cmdId }) {
+        await this.stepRunner.pauseExecution(cmdId);
+    }
+    async resumeExecution({ cmdId }) {
+        await this.stepRunner.resumeExecution(cmdId);
+    }
+    async dealyedRevertMode() {
+        const timerId = setTimeout(async () => {
+            await this.revertMode();
+        }, 100);
+        this.timerId = timerId;
+    }
+    async runStep({ step, parametersMap, tags, isFirstStep = false, listenNetwork = false, AICode }, options) {
+        const { skipAfter = true, skipBefore = !isFirstStep } = options || {};
+        const env = path.basename(this.envName, ".json");
+        const envVars = {
+            TOKEN: this.TOKEN,
+            TEMP_RUN: "true",
+            REPORT_FOLDER: this.bvtContext?.reportFolder,
+            BLINQ_ENV: this.envName,
+            DEBUG: "blinq:route",
+        };
+        if (!step.isImplemented) {
+            envVars.BVT_TEMP_SNAPSHOTS_FOLDER = path.join(this.tempSnapshotsFolder, env);
+        }
+        this.bvtContext.navigate = true;
+        this.bvtContext.loadedRoutes = null;
+        this.bvtContext.STORE_DETAILED_NETWORK_DATA = !!listenNetwork;
+        for (const [key, value] of Object.entries(envVars)) {
+            process.env[key] = value;
+        }
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+        await this.setMode("running");
+        try {
+            step.text = step.text.trim();
+            const { result, info } = await this.stepRunner.runStep({
+                step,
+                parametersMap,
+                envPath: this.envName,
+                tags,
+                config: this.config,
+                AICode,
+            }, this.bvtContext, {
+                skipAfter,
+                skipBefore,
+            });
+            await this.revertMode();
+            return { info };
+        }
+        catch (error) {
+            await this.revertMode();
+            throw error;
+        }
+        finally {
+            for (const key of Object.keys(envVars)) {
+                delete process.env[key];
+            }
+            this.bvtContext.navigate = false;
+        }
+    }
+    async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env, AICode, }) {
+        const res = await this.workspaceService.saveScenario({
+            scenario,
+            featureName,
+            override,
+            isSingleStep,
+            branch,
+            isEditing,
+            projectId: path.basename(this.projectDir),
+            env: env ?? this.envName,
         });
-      });
-    }
-
-    for (const step of scenario.steps) {
-      const stepParams = parseStepTextParameters(step.text);
-      // console.log("Parsing step ", step, stepParams);
-      const _s = getCommandsForImplementedStep(step.text, step_definitions, stepParams);
-      delete step.location;
-      const _step = {
-        ...step,
-        ..._s,
-        keyword: step.keyword.trim(),
-      };
-      parseRouteFiles(this.projectDir, _step);
-      steps.push(_step);
+        if (res.success) {
+            await this.cleanup({ tags: scenario.tags });
+        }
+        else {
+            throw new Error(res.message || "Error saving scenario");
+        }
     }
-    return {
-      name: scenario.name,
-      tags: scenario.tags.map((tag) => tag.name),
-      steps,
-      parameters,
-    };
-  }
-  async findRelatedTextInAllFrames({ searchString, climb, contextText, params }) {
-    if (searchString.length === 0) return -1;
-    let result = 0;
-    for (let i = 0; i < 3; i++) {
-      result = 0;
-      try {
+    async getImplementedSteps(_input) {
+        const stepsAndScenarios = await getImplementedSteps(this.projectDir);
+        const implementedSteps = stepsAndScenarios.implementedSteps;
+        const scenarios = stepsAndScenarios.scenarios;
+        for (const scenario of scenarios) {
+            this.scenariosStepsMap.set(scenario.name, scenario.steps);
+            delete scenario.steps;
+        }
+        return {
+            implementedSteps,
+            scenarios,
+        };
+    }
+    async getStepsAndCommandsForScenario({ name, featureName }) {
+        const steps = this.scenariosStepsMap.get(name) || [];
+        for (const step of steps) {
+            if (step.isImplemented) {
+                step.commands = this.getCommandsForImplementedStep({ stepName: step.text });
+            }
+            else {
+                step.commands = [];
+            }
+        }
+        return steps;
+    }
+    async generateStepName({ commands, stepsNames, parameters, map, }) {
+        return await this.namesService.generateStepName({ commands, stepsNames, parameters, map });
+    }
+    async generateScenarioAndFeatureNames(scenarioAsText) {
+        return await this.namesService.generateScenarioAndFeatureNames(scenarioAsText);
+    }
+    async generateCommandName({ command }) {
+        return await this.namesService.generateCommandName({ command });
+    }
+    getCurrentChromiumPath() {
+        const env = JSON.parse(readFileSync(this.envName, "utf8"));
+        const baseURL = env.baseUrl;
+        let currentURL = null;
+        currentURL = this.bvtContext?.web?.page?.url();
+        let relativeURL = undefined;
+        if (typeof currentURL == "string") {
+            relativeURL = currentURL.startsWith(baseURL) ? currentURL.replace(baseURL, "/") : undefined;
+        }
+        return {
+            relativeURL,
+            baseURL,
+            currentURL,
+        };
+    }
+    getReportFolder() {
+        if (this.bvtContext.reportFolder) {
+            return this.bvtContext.reportFolder;
+        }
+        else
+            return "";
+    }
+    getSnapshotFolder() {
+        if (this.bvtContext.snapshotFolder) {
+            return path.join(process.cwd(), this.bvtContext.snapshotFolder);
+        }
+        else
+            return "";
+    }
+    async overwriteTestData(data) {
+        this.bvtContext.stable?.overwriteTestData(data.value, this.world);
+    }
+    _watchTestData() {
+        this.watcher = chokidar.watch(_getDataFile(this.world, this.bvtContext, this.web), {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 2000,
+                pollInterval: 100,
+            },
+        });
+        if (existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
+            try {
+                const testData = JSON.parse(readFileSync(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
+                // this.logger.info("Test data", testData);
+                this.sendEvent(this.events.getTestData, testData);
+            }
+            catch (e) {
+                // this.logger.error("Error reading test data file", e);
+                console.log("Error reading test data file", e);
+            }
+        }
+        this.logger.info("Watching for test data changes");
+        this.watcher.on("all", async (_event, _path) => {
+            try {
+                const testData = JSON.parse(await readFile(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
+                // this.logger.info("Test data", testData);
+                console.log("Test data changed", testData);
+                this.sendEvent(this.events.getTestData, testData);
+            }
+            catch (e) {
+                // this.logger.error("Error reading test data file", e);
+                console.log("Error reading test data file", e);
+            }
+        });
+    }
+    async loadTestData({ data, type }) {
+        if (type === "user") {
+            const username = data.username;
+            await this.web.loadTestDataAsync("users", username, this.world);
+        }
+        else {
+            const csv = data.csv;
+            const row = data.row;
+            // code = `await context.web.loadTestDataAsync("csv","${csv}:${row}", this)`;
+            await this.web.loadTestDataAsync("csv", `${csv}:${row}`, this.world);
+        }
+    }
+    async discardTestData({ tags }) {
+        resetTestData(this.envName, this.world);
+        await this.cleanup({ tags });
+    }
+    async addToTestData(obj) {
+        if (!existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
+            await writeFile(_getDataFile(this.world, this.bvtContext, this.web), JSON.stringify({}), "utf8");
+        }
+        let data = JSON.parse(await readFile(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
+        data = Object.assign(data, obj);
+        await writeFile(_getDataFile(this.world, this.bvtContext, this.web), JSON.stringify(data), "utf8");
+    }
+    getScenarios() {
+        const featureFiles = readdirSync(path.join(this.projectDir, "features"))
+            .filter((file) => file.endsWith(".feature"))
+            .map((file) => path.join(this.projectDir, "features", file));
         try {
-          const allFrameResult = await this.web.findRelatedTextInAllFrames(
-            contextText,
-            climb,
-            searchString,
-            params,
-            {},
-            this.world
-          );
-          for (const frameResult of allFrameResult) {
-            result += frameResult.elementCount;
-          }
-        } catch (e) {
-          console.log(e);
-        }
-
+            const parsedFiles = featureFiles.map((file) => this.parseFeatureFile(file));
+            const output = {};
+            parsedFiles.forEach((file) => {
+                if (!file.feature)
+                    return;
+                if (!file.feature.name)
+                    return;
+                output[file.feature.name] = [];
+                file.feature.children.forEach((child) => {
+                    if (child.scenario) {
+                        output[file.feature.name].push(child.scenario.name);
+                    }
+                });
+            });
+            return output;
+        }
+        catch (e) {
+            console.log(e);
+        }
+        return {};
+    }
+    getCommandsForImplementedStep({ stepName }) {
+        const step_definitions = loadStepDefinitions(this.projectDir);
+        const stepParams = parseStepTextParameters(stepName);
+        return getCommandsForImplementedStep(stepName, step_definitions, stepParams).commands;
+    }
+    loadExistingScenario({ featureName, scenarioName }) {
+        const step_definitions = loadStepDefinitions(this.projectDir);
+        const featureFilePath = path.join(this.projectDir, "features", featureName);
+        const gherkinDoc = this.parseFeatureFile(featureFilePath);
+        const scenario = gherkinDoc.feature.children.find((child) => child.scenario.name === scenarioName)?.scenario;
+        this.scenarioDoc = scenario;
+        const steps = [];
+        const parameters = [];
+        const datasets = [];
+        if (scenario.examples && scenario.examples.length > 0) {
+            const example = scenario.examples[0];
+            example?.tableHeader?.cells.forEach((cell, index) => {
+                parameters.push({
+                    key: cell.value,
+                    value: unEscapeNonPrintables(example.tableBody[0].cells[index].value),
+                });
+                // datasets.push({
+                //   data: example.tableBody[]
+                // })
+            });
+            for (let i = 0; i < example.tableBody.length; i++) {
+                const row = example.tableBody[i];
+                // for (const row of example.tableBody) {
+                const paramters = [];
+                row.cells.forEach((cell, index) => {
+                    paramters.push({
+                        key: example.tableHeader.cells[index].value,
+                        value: unEscapeNonPrintables(cell.value),
+                    });
+                });
+                datasets.push({
+                    data: paramters,
+                    datasetId: i,
+                });
+            }
+        }
+        for (const step of scenario.steps) {
+            const stepParams = parseStepTextParameters(step.text);
+            // console.log("Parsing step ", step, stepParams);
+            const _s = getCommandsForImplementedStep(step.text, step_definitions, stepParams);
+            delete step.location;
+            const _step = {
+                ...step,
+                ..._s,
+                keyword: step.keyword.trim(),
+            };
+            parseRouteFiles(this.projectDir, _step);
+            steps.push(_step);
+        }
+        return {
+            name: scenario.name,
+            tags: scenario.tags.map((tag) => tag.name),
+            steps,
+            parameters,
+            datasets,
+        };
+    }
+    async generateLocatorSummaries({ allStrategyLocators, element_name, }) {
+        const input = {
+            [element_name ?? "element"]: allStrategyLocators,
+        };
+        const result = await this.namesService.generateLocatorDescriptions({ locatorsObj: input });
+        return result[element_name ?? "element"];
+    }
+    async findRelatedTextInAllFrames({ searchString, climb, contextText, params, }) {
+        if (searchString.length === 0)
+            return -1;
+        let result = 0;
+        for (let i = 0; i < 3; i++) {
+            result = 0;
+            try {
+                try {
+                    const allFrameResult = await this.web.findRelatedTextInAllFrames(contextText, climb, searchString, params, {}, this.world);
+                    for (const frameResult of allFrameResult) {
+                        result += frameResult.elementCount;
+                    }
+                }
+                catch (e) {
+                    console.log(e);
+                }
+                return result;
+            }
+            catch (e) {
+                console.log(e);
+                result = 0;
+            }
+        }
         return result;
-      } catch (e) {
-        console.log(e);
-        result = 0;
-      }
-    }
-    return result;
-  }
-  async cleanup({ tags }) {
-    const noopStep = {
-      text: "Noop",
-      isImplemented: true,
-    };
-    const projectDir = this.projectDir;
-    console.log("Cleaning up project dir:", projectDir);
-
-    try {
-      // run a dummy scenario that will run after hooks
-      await this.runStep(
-        {
-          step: noopStep,
-          parametersMap: {},
-          tags: tags || [],
-        },
-        {
-          skipAfter: false,
-        }
-      );
-
-      // delete the temp folders (any folder that starts with __temp_features)
-      const tempFolders = readdirSync(projectDir).filter((folder) => folder.startsWith("__temp_features"));
-      for (const folder of tempFolders) {
-        const folderPath = path.join(projectDir, folder);
-        if (existsSync(folderPath)) {
-          this.logger.info(`Deleting temp folder: ${folderPath}`);
-          rmSync(folderPath, { recursive: true });
-        }
-      }
-    } catch (error) {
-      console.error("Error in cleanup", error);
-    }
-  }
-  async processAriaSnapshot(snapshot) {
-    try {
-      await this.evaluateInAllFrames(
-        this.context,
-        `window.__bvt_Recorder.processAriaSnapshot(${JSON.stringify(snapshot)});`
-      );
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  async deselectAriaElements() {
-    try {
-      await this.evaluateInAllFrames(this.context, `window.__bvt_Recorder.deselectAriaElements();`);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  async initExecution({ tags = [] }) {
-    // run before hooks
-    const noopStep = {
-      text: "Noop",
-      isImplemented: true,
-    };
-    await this.runStep(
-      {
-        step: noopStep,
-        parametersMap: {},
-        tags,
-      },
-      {
-        skipBefore: false,
-        skipAfter: true,
-      }
-    );
-  }
-  async cleanupExecution({ tags = [] }) {
-    // run after hooks
-    const noopStep = {
-      text: "Noop",
-      isImplemented: true,
-    };
-    await this.runStep(
-      {
-        step: noopStep,
-        parametersMap: {},
-        tags,
-      },
-      {
-        skipBefore: true,
-        skipAfter: false,
-      }
-    );
-  }
-  async resetExecution({ tags = [] }) {
-    // run after hooks followed by before hooks
-    await this.cleanupExecution({ tags });
-    await this.initExecution({ tags });
-  }
-
-  parseFeatureFile(featureFilePath) {
-    try {
-      let id = 0;
-      const uuidFn = () => (++id).toString(16);
-      const builder = new AstBuilder(uuidFn);
-      const matcher = new GherkinClassicTokenMatcher();
-      const parser = new Parser(builder, matcher);
-      const source = readFileSync(featureFilePath, "utf8");
-      const gherkinDocument = parser.parse(source);
-      return gherkinDocument;
-    } catch (e) {
-      this.logger.error(`Error parsing feature file: ${featureFilePath}`);
-      console.log(e);
-    }
-    return {};
-  }
-
-  stopRecordingNetwork(input) {
-    if (this.bvtContext) {
-      this.bvtContext.STORE_DETAILED_NETWORK_DATA = false;
-    }
-  }
+    }
+    async setStepCodeByScenario({ function_name, mjs_file_content, user_request, selectedTarget, page_context, AIMemory, steps_context, }) {
+        const runsURL = getRunsServiceBaseURL();
+        const url = `${runsURL}/process-user-request/generate-code-with-context`;
+        try {
+            const result = await axiosClient({
+                url,
+                method: "POST",
+                data: {
+                    function_name,
+                    mjs_file_content,
+                    user_request,
+                    selectedTarget,
+                    page_context,
+                    AIMemory,
+                    steps_context,
+                },
+                headers: {
+                    Authorization: `Bearer ${this.TOKEN}`,
+                    "X-Source": "recorder",
+                },
+            });
+            if (result.status !== 200) {
+                return { success: false, message: "Error while fetching code changes" };
+            }
+            return { success: true, data: result.data };
+        }
+        catch (error) {
+            // @ts-ignore
+            const reason = error?.response?.data?.error || "";
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new Error(`Failed to fetch code changes: ${errorMessage} \n ${reason}`);
+        }
+    }
+    async getStepCodeByScenario({ featureName, scenarioName, projectId, branch, }) {
+        try {
+            const runsURL = getRunsServiceBaseURL();
+            const ssoURL = runsURL.replace("/runs", "/auth");
+            const privateRepoURL = `${ssoURL}/isRepoPrivate?project_id=${projectId}`;
+            const isPrivateRepoReq = await axiosClient({
+                url: privateRepoURL,
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.TOKEN}`,
+                    "X-Source": "recorder",
+                },
+            });
+            if (isPrivateRepoReq.status !== 200) {
+                return { success: false, message: "Error while checking repo privacy" };
+            }
+            const isPrivateRepo = isPrivateRepoReq.data.isPrivate ? isPrivateRepoReq.data.isPrivate : false;
+            const workspaceURL = runsURL.replace("/runs", "/workspace");
+            const url = `${workspaceURL}/get-step-code-by-scenario`;
+            const result = await axiosClient({
+                url,
+                method: "POST",
+                data: {
+                    scenarioName,
+                    featureName,
+                    projectId,
+                    isPrivateRepo,
+                    branch,
+                },
+                headers: {
+                    Authorization: `Bearer ${this.TOKEN}`,
+                    "X-Source": "recorder",
+                },
+            });
+            if (result.status !== 200) {
+                return { success: false, message: "Error while getting step code" };
+            }
+            return { success: true, data: result.data.stepInfo };
+        }
+        catch (error) {
+            const axiosError = error;
+            const reason = axiosError?.response?.data?.error || "";
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new Error(`Failed to get step code: ${errorMessage} \n ${reason}`);
+        }
+    }
+    async getContext() {
+        await this.page.waitForLoadState("domcontentloaded");
+        await this.page.waitForSelector("body");
+        await this.page.waitForTimeout(500);
+        return await this.page.evaluate(() => {
+            return document.documentElement.outerHTML;
+        });
+    }
+    async deleteCommandFromStepCode({ scenario, AICode, command }) {
+        if (!AICode || AICode.length === 0) {
+            console.log("No AI code available to delete.");
+            return;
+        }
+        const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+        const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+        process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+        process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+        try {
+            await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+            await this.stepRunner.writeWrapperCode(tempFolderPath);
+            const codeView = AICode.find((f) => f.stepName === scenario.step.text);
+            if (!codeView) {
+                throw new Error("Step code not found for step: " + scenario.step.text);
+            }
+            const functionName = codeView.functionName;
+            const mjsPath = path
+                .normalize(codeView.mjsFile)
+                .split(path.sep)
+                .filter((part) => part !== "features")
+                .join(path.sep);
+            const codePath = path.join(tempFolderPath, mjsPath);
+            if (!existsSync(codePath)) {
+                throw new Error("Step code file not found: " + codePath);
+            }
+            const codePage = getCodePage(codePath);
+            const elements = codePage.getVariableDeclarationAsObject("elements");
+            const cucumberStep = getCucumberStep({ step: scenario.step });
+            cucumberStep.text = scenario.step.text;
+            const stepCommands = scenario.step.commands;
+            const cmd = _toRecordingStep(command, scenario.step.name);
+            const recording = new Recording();
+            recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+            const step = { ...(recording.steps[0] ?? {}), ...(cmd ?? {}) };
+            const result = _generateCodeFromCommand(step, elements, {});
+            codePage._removeCommands(functionName, result.codeLines);
+            codePage.removeUnusedElements();
+            codePage.save();
+            await rm(tempFolderPath, { recursive: true, force: true });
+            return { code: codePage.fileContent, mjsFile: codeView.mjsFile };
+        }
+        catch (error) {
+            await rm(tempFolderPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async addCommandToStepCode({ scenario, AICode }) {
+        if (!AICode || AICode.length === 0) {
+            console.log("No AI code available to add.");
+            return;
+        }
+        const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+        const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+        process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+        process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+        try {
+            await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+            await this.stepRunner.writeWrapperCode(tempFolderPath);
+            let codeView = AICode.find((f) => f.stepName === scenario.step.text);
+            if (codeView) {
+                scenario.step.commands = [scenario.step.commands.pop()];
+                const functionName = codeView.functionName;
+                const mjsPath = path
+                    .normalize(codeView.mjsFile)
+                    .split(path.sep)
+                    .filter((part) => part !== "features")
+                    .join(path.sep);
+                const codePath = path.join(tempFolderPath, mjsPath);
+                if (!existsSync(codePath)) {
+                    throw new Error("Step code file not found: " + codePath);
+                }
+                const codePage = getCodePage(codePath);
+                const elements = codePage.getVariableDeclarationAsObject("elements");
+                const cucumberStep = getCucumberStep({ step: scenario.step });
+                cucumberStep.text = scenario.step.text;
+                const stepCommands = scenario.step.commands;
+                const cmd = _toRecordingStep(scenario.step.commands[0], scenario.step.name);
+                const recording = new Recording();
+                recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+                const step = { ...(recording.steps[0] ?? {}), ...(cmd ?? {}) };
+                const result = _generateCodeFromCommand(step, elements, {});
+                codePage.insertElements(result.elements);
+                codePage._injectOneCommand(functionName, result.codeLines.join("\n"));
+                codePage.save();
+                await rm(tempFolderPath, { recursive: true, force: true });
+                return { code: codePage.fileContent, newStep: false, mjsFile: codeView.mjsFile };
+            }
+            console.log("Step code not found for step: ", scenario.step.text);
+            codeView = AICode[0];
+            const functionName = toMethodName(scenario.step.text);
+            const codeLines = [];
+            const mjsPath = path
+                .normalize(codeView.mjsFile)
+                .split(path.sep)
+                .filter((part) => part !== "features")
+                .join(path.sep);
+            const codePath = path.join(tempFolderPath, mjsPath);
+            if (!existsSync(codePath)) {
+                throw new Error("Step code file not found: " + codePath);
+            }
+            const codePage = getCodePage(codePath);
+            const elements = codePage.getVariableDeclarationAsObject("elements") || {};
+            let newElements = { ...elements };
+            const cucumberStep = getCucumberStep({ step: scenario.step });
+            cucumberStep.text = scenario.step.text;
+            const stepCommands = scenario.step.commands;
+            stepCommands.forEach((command) => {
+                const cmd = _toRecordingStep(command, scenario.step.name);
+                const recording = new Recording();
+                recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+                const step = { ...(recording.steps[0] ?? {}), ...(cmd ?? {}) };
+                const result = _generateCodeFromCommand(step, elements, {});
+                const elementUpdates = result.elements ?? {};
+                newElements = { ...elementUpdates };
+                codeLines.push(...(result.codeLines ?? []));
+            });
+            codePage.insertElements(newElements);
+            codePage.addInfraCommand(functionName, cucumberStep.text, cucumberStep.getVariablesList(), codeLines, false, "recorder");
+            const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
+            codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), functionName, stepCommands.length);
+            codePage.save();
+            await rm(tempFolderPath, { recursive: true, force: true });
+            return { code: codePage.fileContent, newStep: true, functionName, mjsFile: codeView.mjsFile };
+        }
+        catch (error) {
+            await rm(tempFolderPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async cleanup({ tags }) {
+        const noopStep = {
+            text: "Noop",
+            isImplemented: true,
+        };
+        const projectDir = this.projectDir;
+        console.log("Cleaning up project dir:", projectDir);
+        try {
+            // run a dummy scenario that will run after hooks
+            await this.runStep({
+                step: noopStep,
+                parametersMap: {},
+                tags: tags || [],
+            }, {
+                skipAfter: false,
+            });
+            // delete the temp folders (any folder that starts with __temp_features)
+            const tempFolders = readdirSync(projectDir).filter((folder) => folder.startsWith("__temp_features"));
+            for (const folder of tempFolders) {
+                const folderPath = path.join(projectDir, folder);
+                if (existsSync(folderPath)) {
+                    this.logger.info(`Deleting temp folder: ${folderPath}`);
+                    rmSync(folderPath, { recursive: true });
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error in cleanup", error);
+        }
+    }
+    async processAriaSnapshot(snapshot) {
+        try {
+            await this.evaluateInAllFrames(this.context, `window.__bvt_Recorder.processAriaSnapshot(${JSON.stringify(snapshot)});`);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async deselectAriaElements() {
+        try {
+            await this.evaluateInAllFrames(this.context, `window.__bvt_Recorder.deselectAriaElements();`);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async initExecution({ tags = [] }) {
+        // run before hooks
+        const noopStep = {
+            text: "Noop",
+            isImplemented: true,
+        };
+        await this.runStep({
+            step: noopStep,
+            parametersMap: {},
+            tags,
+        }, {
+            skipBefore: false,
+            skipAfter: true,
+        });
+    }
+    async cleanupExecution({ tags = [] }) {
+        // run after hooks
+        const noopStep = {
+            text: "Noop",
+            isImplemented: true,
+        };
+        await this.runStep({
+            step: noopStep,
+            parametersMap: {},
+            tags,
+        }, {
+            skipBefore: true,
+            skipAfter: false,
+        });
+    }
+    async resetExecution({ tags = [] }) {
+        // run after hooks followed by before hooks
+        await this.cleanupExecution({ tags });
+        await this.initExecution({ tags });
+    }
+    parseFeatureFile(featureFilePath) {
+        try {
+            let id = 0;
+            const uuidFn = () => (++id).toString(16);
+            const builder = new AstBuilder(uuidFn);
+            const matcher = new GherkinClassicTokenMatcher();
+            const parser = new Parser(builder, matcher);
+            const source = readFileSync(featureFilePath, "utf8");
+            const gherkinDocument = parser.parse(source);
+            return gherkinDocument;
+        }
+        catch (e) {
+            this.logger.error(`Error parsing feature file: ${featureFilePath}`, { error: e });
+            console.log(e);
+        }
+        return {};
+    }
+    stopRecordingNetwork(_input) {
+        if (this.bvtContext) {
+            this.bvtContext.STORE_DETAILED_NETWORK_DATA = false;
+        }
+    }
+    async fakeParams(params, faker) {
+        if (!faker) {
+            faker = await import("@faker-js/faker/locale/en_US").then((mod) => mod.faker);
+        }
+        const newFakeParams = {};
+        Object.keys(params).forEach((key) => {
+            if (!params[key].startsWith("{{") || !params[key].endsWith("}}")) {
+                newFakeParams[key] = params[key];
+                return;
+            }
+            try {
+                const value = params[key].substring(2, params[key].length - 2).trim();
+                const faking = value.split("(")[0].split(".");
+                let argument = value.substring(value.indexOf("(") + 1, value.lastIndexOf(")"));
+                argument = isNaN(Number(argument)) ? argument : Number(argument);
+                let fakeFunc = faker;
+                faking.forEach((f) => {
+                    fakeFunc = fakeFunc[f];
+                });
+                const newValue = fakeFunc(argument);
+                newFakeParams[key] = newValue;
+            }
+            catch (error) {
+                newFakeParams[key] = params[key];
+            }
+        });
+        return newFakeParams;
+    }
 }