@devassure/tpp-engine 0.0.0-stage → 1.8.1

package/src/actions.js

@@ -0,0 +1,3201 @@
+const { TppElement } = require("./models/tpp-element");
+const { expect } = require("@playwright/test");
+const { TppA11y, checkA11yAttachments } = require("./accessibility/tpp-a11y");
+const { TppVisualCompare } = require("./visual-test/tpp-visual-test");
+const { ApiService } = require("./api/api-service")
+const { ansiRegex } = require("./utils/log-utils");
+const { compare } = require("./utils/assert-utils");
+const { MySQLService } = require("./database/mysql/mysql-service");
+const { writeStorageStateToFile, loadStorageStateFromFile } = require("./utils/cookie-utils");
+const { PostgreSQLService } = require("./database/pg/pg-service");
+const { OracleService } = require("./database/oracle/oracle-service");
+const { EachTestHook } = require("./hooks/each-hook");
+const { TppLibrary } = require("./library/tpp-library");
+const { Logger, LOG_PREFIX } = require("./utils/logger");
+const { SliderUtils } = require("./library/web/slider-utils");
+const { getScreenshotPath, getScreenshotLog } = require("./utils/screenshot-utils");
+const { sleep, generateRandomString } = require("./utils/common-utils");
+const { FileUtils } = require("./library/file/file-utils");
+const os = require('os');
+const path = require('path');
+const { WebExecutorAgent } = require("./web/web-executor-agent");
+const fs = require('fs');
+const WebSocket = require('ws');
+const TokenConfig = require('./library/emailTesting/TokenConfig');
+const config = require('./app-config.json');
+const crypto = require('crypto');
+const { fetchWebState, takeElementScreenshot } = require('./web/web-executor-data-fetch');
+const { aiWebSocketCall, AI_ENDPOINTS } = require('./utils/ai-utils');
+const { AutohealActions } = require("./autoheal-actions");
+const { Neo4jService } = require("./database/neo4j/neo4j-service");
+const { getAutohealPath } = require('./utils/autoheal-utils');
+
+const WEBAPP_SOCKET_URL = config.webAppSocketUrl;
+
+class Actions {
+
+  constructor(page, request, fromAi, retry, totalRetries, customConfig, webComponents, mobileActions) {
+      this.request = request
+      this.page = page;
+      this.testType = !!mobileActions ? 'mobile' : 'web';
+      this.networkLogManager = webComponents?.networkLogManager;
+      this.consoleLogManager = webComponents?.consoleLogManager;
+      this.downloadsManager = webComponents?.downloadsManager;
+      this.extensionId = webComponents?.extensionId;
+      this.mobile = mobileActions;
+      this.fromAi = fromAi;
+      this.retry = retry;
+      this.totalRetries = totalRetries;
+      this.dialogFns = undefined;
+      this.library = new TppLibrary(this.caller, undefined, webComponents, customConfig, (label) => this.addScreenshot(label), page);
+      this.customConfig = customConfig;
+      this.curr_browser = undefined;
+      this.autoheal = new AutohealActions(this);
+      this.fallbackLocatorCache = {};
+      this.executionPreferences = this.customConfig?.executionPreference || {};
+      this.webAppPreferences = this.customConfig?.webAppPreference || {};
+      this.testData = undefined;
+  }
+
+  newChild(name) {
+    const webComponents = this.testType === 'web' 
+    ? {
+      networkLogManager: this.networkLogManager,
+      consoleLogManager: this.consoleLogManager,
+      downloadsManager: this.downloadsManager,
+      extensionId: this.extensionId,
+    }
+    : undefined;
+    const childMobile = this.mobile?.newChild(name);
+    const childActions = new Actions(this.page, this.request, this.fromAi, this.retry, this.totalRetries, this.customConfig, webComponents, childMobile);
+    childActions.testLabel = this.testLabel;
+    childActions.caller = this.caller + " :: " + name;
+    childActions.blacklistedLogs = this.blacklistedLogs;
+    childActions.library = new TppLibrary(childActions.caller, this.blacklistedLogs, webComponents, this.customConfig, (label) => this.addScreenshot(label), this.page);
+    childActions.embedToIframeMap = this.embedToIframeMap;
+    childActions.curr_browser = this.curr_browser;
+    if(this.remoteBrowserPort) childActions.remoteBrowserPort = this.remoteBrowserPort;
+    childActions.testData = this.testData;
+    childActions.tppTest = this.tppTest;
+    return childActions;
+  }
+
+  setBlacklistedLogs(blacklistedLogs) {
+    this.blacklistedLogs = blacklistedLogs;
+    this.library?.setBlacklistedLogs(blacklistedLogs);
+    this.mobile?.setBlacklistedLogs(blacklistedLogs);
+  }
+
+  setCaller(testType, caller, tppTest, testDataId) {
+    this.testType = testType;
+    this.testLabel = caller;
+    this.tppTest = tppTest;
+    //TODO fix caller init for API and Web
+    if(testType === 'web') {
+      const projId = tppTest.info()?.project?.name || tppTest.info()?._test?._projectId?.trim() || '';
+      let browserName;
+      if(["CHROME", "CHROMIUM", "EDGE", "SAFARI", "FIREFOX"].includes(projId.split(" ")[0])) {
+        browserName = projId.split(" ")[0];
+      } else {
+        browserName = projId.replaceAll(" ", "_");
+      }
+      this.curr_browser = browserName;
+      const xy = this.page.context()?._options?.viewport;
+      this.caller = browserName && xy 
+      ? `${caller} > ${browserName}-${xy.width}x${xy.height}`
+      : browserName ? `${caller} > ${browserName}`
+      : caller;
+    } else {
+      this.caller = caller;
+    }
+    if(!!testDataId) {
+      this.caller = `${this.caller} > ${testDataId}`;
+    }
+    this.mobile?.setCaller(this.caller);
+    this.library?.setCaller(this.caller);
+  }
+
+  setRemoteBrowserPort(port) {
+    this.remoteBrowserPort = port;
+  }
+
+  setTestData(testData) {
+    this.testData = testData;
+  }
+
+  async initializeConfig() {
+    if (!this.config) {
+        this.config = await TokenConfig.getConfig();
+    }
+    return this.config;
+  }
+
+  async getAuthHeaders() {
+      const config = await this.initializeConfig();
+      return {
+          'Authorization': `${config.token_type} ${config.access_token}`
+      };
+  }
+
+  async getOfflineStatus() {
+      const config = await this.initializeConfig();
+      return config.offline;
+  }
+
+  async startWebExecutorAgent(port) {
+    this.remoteBrowserPort = port;
+    try {
+        await (new WebExecutorAgent(this)).openWebExecutorAgent();
+    } catch(error) {
+        this.log(undefined, `[EXECUTOR-AGENT-ERROR] ${error?.message || 'Unable to read the web page!'}`);
+        throw error;
+    }
+  }
+
+  comment(text) {
+    this.action_log(`${LOG_PREFIX}${this.caller} :: [user_log] ${text}`);
+  }
+
+  async wait_for_flutter_app(timeout) {
+    const logLabel = `Wait for Flutter app within ${timeout} ms`;
+    this.startLog(logLabel);
+
+    if(timeout <= 0) {
+      timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+    }
+
+    try {
+      await this.page.waitForSelector('flt-glass-pane, flutter-view', {
+        state: 'visible',
+        timeout,
+      });
+    } catch (ex) {
+      console.log("Error waiting for Flutter app", ex);
+      this.failureLog(logLabel);
+      throw {message: `Flutter app not loaded within ${timeout} ms`};
+    }
+    this.endLog(logLabel);
+  }
+
+  async unlock_flutter_dom() {
+    const logLabel = `Unlock Flutter DOM`;
+    this.startLog(logLabel);
+
+    let timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+
+    try {
+      await this.page.waitForSelector('flt-glass-pane, flutter-view', {
+        state: 'visible',
+        timeout,
+      });
+    } catch (ex) {
+      console.log("Error waiting for Flutter app", ex);
+      this.failureLog(logLabel);
+      throw {message: `Flutter app not loaded within ${timeout} ms`};
+    }
+
+    try {
+      await this.page.evaluate(() => {
+        let pane = document.querySelector('flt-glass-pane');
+        if(pane?.shadowRoot) {
+          pane = pane.shadowRoot;
+        }
+        let semantics = pane?.querySelector('flt-semantics-placeholder');
+        if(!semantics) {
+          semantics = document.querySelector('flt-semantics-placeholder');
+        }
+        semantics?.click();
+      });
+    } catch (ex) {
+      console.log("Error unlocking Flutter DOM", ex);
+      this.failureLog(logLabel);
+      throw {message: `Error unlocking Flutter DOM - ${ex.message}`};
+    }
+
+    this.endLog(logLabel);
+  }
+
+  async unlockFlutterDom() {
+    this.page.on('load', async page => {
+      try {
+        await page.waitForSelector('flt-glass-pane, flutter-view', {
+          state: 'visible',
+          timeout: 1000 * (this.customConfig?.timeouts?.urlLoadTimeout || 20),
+        });
+        await page.evaluate(() => {
+          let pane = document.querySelector('flt-glass-pane');
+          if(pane?.shadowRoot) {
+            pane = pane.shadowRoot;
+          }
+          let semantics = pane?.querySelector('flt-semantics-placeholder');
+          if(!semantics) {
+            semantics = document.querySelector('flt-semantics-placeholder');
+          }
+          semantics?.click();
+        });
+      } catch (ex) {
+        console.log("Flutter DOM error", ex);
+        throw {message: `Unable to unlock Flutter DOM`};
+      }
+    });
+  }
+
+  async get_test_info() {
+    const logLabel = `Get test info`;
+    this.startLog(logLabel);
+    let data = this.customConfig.testInfo 
+    || {
+      status: 'running',
+      retry: 0,
+      maxRetries: 0,
+      threadIndex: 0
+    };
+    this.endLog(logLabel);
+    return data;
+  }
+
+  async get_test_data() {
+    const logLabel = `Get test data`;
+    this.startLog(logLabel);
+    let data = this.testData;
+    this.endLog(logLabel);
+    return data;
+  }
+
+  async open_url(url) {
+    const logLabel = `Open url - ${url}`;
+    this.startLog(logLabel);
+    await this.page.goto(url);
+    await this.page.waitForLoadState();
+    this.endLog(logLabel);
+  }
+
+  handleOfflineMode(){
+    throw {message: `Open ppt or pdf in browser action should not be proceeded with offline`}
+  }
+
+  async renderPresentationFromFile(filePath, validExtensions, logPrefix) {
+    const logLabel = `${logPrefix} - ${filePath}`;
+    const logger = new Logger(this.caller, this.blacklistedLogs);
+    this.startLog(logLabel);
+  
+    const offline = await this.getOfflineStatus();
+    if (offline) {
+      this.handleOfflineMode();
+      return;
+    }
+
+    filePath = new FileUtils().getFilePath(filePath);
+  
+    if (!fs.existsSync(filePath)) {
+      throw { message: `File not found: ${filePath}` };
+    }
+  
+    const fileExt = path.extname(filePath).toLowerCase();
+    if (!validExtensions.includes(fileExt)) {
+      throw { message: `Invalid file type. Allowed types: ${validExtensions.join(', ')}: ${filePath}` };
+    }
+  
+    try {
+      const authHeaders = await this.getAuthHeaders();
+      let htmlContent = '';
+      
+      const fileBuffer = fs.readFileSync(filePath);
+      const fileSizeInMB = fileBuffer.length / (1024 * 1024);
+
+      if (fileSizeInMB > 25) {
+        throw { message: `File size exceeds 25MB limit: ${fileSizeInMB.toFixed(2)}MB` };
+      }
+      const fileName = path.basename(filePath);
+      
+      const clientId = crypto.randomUUID();
+      
+      const token = authHeaders.Authorization;
+      const wsUrl = `${WEBAPP_SOCKET_URL}/cable?authorization=${encodeURIComponent(token)}&client_id=${clientId}`;
+      const ws = new WebSocket(wsUrl);
+      
+      const wsPromise = new Promise((resolve, reject) => {
+        ws.onopen = () => {
+          
+          ws.send(JSON.stringify({ 
+            command: 'subscribe',
+            identifier: JSON.stringify({
+              channel: 'PresentationChannel'
+            })
+          }));
+        };
+        
+        let subscribed = false;
+        
+        ws.onmessage = (event) => {
+          try {
+            const response = JSON.parse(event.data);
+            
+            if (response.type === 'confirm_subscription') {
+              subscribed = true;
+              
+              const fileData = {
+                fileName: fileName,
+                fileContent: fileBuffer.toString('base64'),
+                fileType: fileExt
+              };
+              
+              ws.send(JSON.stringify({
+                command: 'message',
+                identifier: JSON.stringify({
+                  channel: 'PresentationChannel'
+                }),
+                data: JSON.stringify({
+                  action: 'process_file',
+                  file_data: fileData
+                })
+              }));
+            }
+            
+            else if (response.message) {
+              const message = response.message;
+              
+              if (message.type === 'error') {
+                ws.close();
+                reject({ message: `${logPrefix}: ${message.data.error}` });
+              } else if (message.type === 'complete') {
+                htmlContent = message.data.html_content;
+                ws.close();
+                resolve(htmlContent);
+              }
+            }
+                        
+            else {
+              return;
+            }
+          } catch (e) {
+            throw { message: `${logPrefix}: ${e.message}` };
+          }
+        };
+        
+        ws.onerror = (error) => {
+          ws.close();
+          reject({ message: `${logPrefix}: Connection Failed` });
+        };
+        
+        ws.onclose = (event) => {
+          if (!event.wasClean && !htmlContent) {
+            reject({ message: `${logPrefix}: Connection closed unexpectedly (code: ${event.code})` });
+          }
+        };
+      });
+      
+      htmlContent = await wsPromise;
+      
+      await this.page.goto('about:blank');
+      await this.page.setContent(htmlContent, { waitUntil: 'networkidle' });
+      await this.page.evaluate(() => { document.title = "File Viewer"; });
+      
+    } catch (error) {
+      logger.failureLog(logLabel);
+      throw { message: `${logPrefix}: ${error.message}` };
+    }
+    
+    this.endLog(logLabel);
+  }
+
+  async open_ppt_in_browser(filePath) {
+    const validExtensions = ['.ppt', '.pptx'];
+    return this.renderPresentationFromFile(filePath, validExtensions, 'Open PPT in browser');
+  }
+
+  async open_pdf_in_browser(filePath) {
+    const validExtensions = ['.pdf'];
+    return this.renderPresentationFromFile(filePath, validExtensions, 'Open PDF in browser');
+  }
+
+  async save_page_as_pdf() {
+    const logLabel = `Save page as PDF`;
+    this.startLog(logLabel);
+    const filePath = `downloads/${generateRandomString(10)}.pdf`;
+    try {
+      await this.page.pdf({ path: filePath });
+    } catch (error) {
+      this.failureLog(logLabel);
+      throw { message: error.message || 'Unable to save page as PDF' };
+    }
+    const fullPath = path.resolve(filePath);
+    if(!fs.existsSync(fullPath)) {
+      this.failureLog(logLabel);
+      throw { message: 'Unable to save page as PDF' };
+    }
+    this.log(logLabel, `Page saved as PDF at ${fullPath}`);
+    this.endLog(logLabel);
+    return fullPath;
+  }
+
+  async get_browser_details() {
+    const logLabel = `Get browser details`;
+    this.startLog(logLabel);
+
+    const knownBrowsers = ["CHROME", "CHROMIUM", "EDGE", "SAFARI", "FIREFOX"];
+    const headless = this.page.context().browser()["_options"]?.headless ?? false; 
+
+    let browserName = "UNKNOWN";
+    let resolution = null;
+    let emulatedDevice = null;
+    let viewport = this.page.context()?._options?.viewport;
+
+    const matchedBrowser = knownBrowsers.find(browser =>
+        this.curr_browser.toUpperCase().includes(browser)
+    );
+
+    if (matchedBrowser) {
+        browserName = matchedBrowser;
+        if (viewport) {
+            resolution = { x: viewport.width, y: viewport.height };
+        }
+    } else {
+        browserName = "emulated_browser"; 
+        emulatedDevice = this.curr_browser; 
+    }
+
+    this.endLog(logLabel);
+    return browserName === "emulated_browser"
+        ? { browserName, emulatedDevice, headless }
+        : { browserName, resolution, headless};
+  }
+
+  async get_environment_name(){
+    const logLabel = `Get environment name`;
+    this.startLog(logLabel);
+    const environment = this.customConfig?.environment?.trim();
+    this.endLog(logLabel);
+    return environment ? environment : "NO_ENV_SELECTED";
+  }
+
+  async open_chrome_extension_html(htmlPath) {
+    const logLabel = `Open Chrome extension html - ${htmlPath}`;
+    this.startLog(logLabel);
+    if(this.extensionId === 'TPP_EXTN_NOT_LOADED') {
+      throw {message: 'Chrome extension ID not found. Extension will still work. If you want to Open UI html and test this extension, please raise a request to DevAssure support!'};
+    } else if(!this.extensionId) {
+      throw {message: 'Extension not enabled! Enable Chrome extension in Project Preferences > Web App Settings and upload you extension.'}
+    }
+    let filePath = htmlPath.startsWith('/') ? htmlPath : `/${htmlPath}`;
+    const pageUrl = `chrome-extension://${this.extensionId}${filePath}`
+    await this.page.goto(pageUrl);
+    await this.page.waitForLoadState();
+    this.endLog(logLabel);
+  }
+
+  get_page_url() {
+    const logLabel = `Get page url`;
+    this.startLog(logLabel);
+    this.endLog(logLabel);
+    return this.page.url();
+  }
+
+  async reload_page() {
+    const logLabel = `Reload page`;
+    this.startLog(logLabel);
+    await this.page.reload();
+    this.endLog(logLabel);
+  }
+
+  async go_back() {
+    const logLabel = `Go back`;
+    this.startLog(logLabel);
+    await this.page.goBack();
+    this.endLog(logLabel);
+  }
+
+  async go_forward() {
+    const logLabel = `Go forward`;
+    this.startLog(logLabel);
+    await this.page.goForward();
+    this.endLog(logLabel);
+  }
+
+  async wait_for_page_load(duration) {
+    const logLabel = `Wait for page to load within ${duration} ms`;
+    this.startLog(logLabel);
+    await this.page.waitForLoadState('domcontentloaded', {timeout: duration || 10000});
+    this.endLog(logLabel);
+  }
+
+  async wait_for_url(urlRegex) {
+    const logLabel = `Wait for URL - ${urlRegex}`;
+    this.startLog(logLabel);
+    let regex = urlRegex;
+    try {
+      regex = new RegExp(urlRegex);
+    } catch (e) {
+    }
+    await this.page.waitForURL(regex)
+    this.endLog(logLabel);
+  }
+
+  async wait_for_url_ms(urlRegex, timeout) {
+    const logLabel = `Wait for URL - ${urlRegex}, within ${timeout} ms`;
+    this.startLog(logLabel);
+    let regex = urlRegex;
+    try {
+      regex = new RegExp(urlRegex);
+    } catch (e) {
+    }
+    await this.page.waitForURL(regex, {timeout: timeout})
+    this.endLog(logLabel);
+  }
+
+  async get_cookie_value(url, cookieKey) {
+    const logLabel = `Get cookie value. Url - ${url}. Cookie key - ${cookieKey}`;
+    this.startLog(logLabel);
+    const cookies = await this.page.context().cookies(url);
+    let value = '';
+    if(!cookies?.length) {
+      this.log(logLabel, `No Cookies found for url ${url}`);
+    } else {
+      const cookie = cookies.find(cookie => cookie.name === cookieKey);
+      if(!cookie) {
+        this.log(logLabel, `No Cookie with key ${cookieKey} found`);
+      } else {
+        value = cookie?.value || '';
+      }
+    }
+    this.endLog(logLabel);
+    return value;
+  }
+
+  async set_cookie_value(url, cookieKey, cookieValue) {
+    const logLabel = `Set cookie value. Url - ${url}. Cookie key - ${cookieKey}. Cookie value - ${cookieValue}`;
+    this.startLog(logLabel);
+    const cookieData = {name: cookieKey, value: cookieValue, url: url};
+    if(this.remoteBrowserPort) {
+      const commandData = JSON.stringify(cookieData);
+      console.log(`[[TPP]] [[TPP Remote-Execution COMMAND add_cookie]] ${commandData}`);
+      await sleep(5000);
+    } else {
+      await this.page.context().addCookies([cookieData]);
+    }
+    this.endLog(logLabel);
+  }
+
+  async remove_cookies() {
+    const logLabel = `Remove all cookies`;
+    this.startLog(logLabel);
+    await this.page.context().clearCookies();
+    this.endLog(logLabel);
+  }
+
+  async save_storage_state(label) {
+    const logLabel = `Save storage state to file - ${label}`;
+    this.startLog(logLabel);
+    await writeStorageStateToFile(this.page, label);
+    this.endLog(logLabel);
+  }
+
+  async load_storage_state(label) {
+    const logLabel = `Load storage state from file - ${label}`;
+    this.startLog(logLabel);
+    const newPage = await loadStorageStateFromFile(
+      this.page,
+      label,
+      new Logger(this.caller, this.blacklistedLogs),
+      logLabel,
+      this.remoteBrowserPort,
+      this.customConfig,
+    );
+    if(newPage) {
+      this.networkLogManager?.startLogTracing(newPage);
+      this.consoleLogManager?.startLogTracing(newPage);
+      this.downloadsManager?.handleDownloads(newPage);
+      Object.assign(this.page, newPage);
+    }
+    this.endLog(logLabel);
+    return !!newPage;
+  }
+
+  async is_element_clickable(element, timeout) {
+    const logLabel = `Is element - ${element.label} clickable within ${timeout} ms`;
+    this.startLog(logLabel);
+    if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await tppElement.locator().click({trial: true, timeout: timeout})
+    } catch (ex) {
+      if(!ex.name?.includes('TimeoutError')) {
+        this.log(logLabel, `Returning false! Exception - ${ex}`);
+      }
+      this.endLog(logLabel);
+      return false;
+    }
+    this.endLog(logLabel);
+    return true;
+  }
+
+  async is_element_visible(element, timeout) {
+    const logLabel = `Is element - ${element.label} visible within ${timeout} ms`;
+    this.startLog(logLabel);
+    if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await tppElement.locator().waitFor({state: "visible", timeout: timeout});
+    } catch (ex) {
+      if(!ex.name?.includes('TimeoutError')) {
+        this.log(logLabel, `Returning false! Exception - ${ex}`);
+      }
+      this.endLog(logLabel);
+      return false;
+    }
+    this.endLog(logLabel);
+    return true;
+  }
+
+  async is_element_present(element, timeout) {
+    const logLabel = `Is element - ${element.label} present within ${timeout} ms`;
+    this.startLog(logLabel);
+    if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await tppElement.locator().waitFor({state: "attached", timeout: timeout});
+    } catch (ex) {
+      if(!ex.name?.includes('TimeoutError')) {
+        this.log(logLabel, `Returning false! Exception - ${ex}`);
+      }
+      this.endLog(logLabel);
+      return false;
+    }
+    this.endLog(logLabel);
+    return true;
+  }
+
+  async is_element_not_present(element, timeout) {
+    const logLabel = `Is element - ${element.label} not present within ${timeout} ms`;
+    this.startLog(logLabel);
+    if(timeout === -1) timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await expect(tppElement.locator()).toHaveCount(0, {timeout: timeout});
+    } catch (ex) {
+      if(!ex.name?.includes('TimeoutError')) {
+        this.log(logLabel, `Returning false! Exception - ${ex}`);
+      }
+      this.endLog(logLabel);
+      return false;
+    }
+    this.endLog(logLabel);
+    return true;
+  }
+
+  async is_nth_element_present(element, n) {
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await tppElement.locator().nth(n).waitFor({state: "attached", timeout: 10000});
+    } catch (e) {
+      this.log(logLabel, `Returning false! Exception - ${e}`);
+      return false;
+    }
+    return true;
+  }
+
+  async is_element_checked(element) {
+    const logLabel = `Is Element Checked - ${element.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    const checked = await tppElement.locator().isChecked();
+    this.endLog(logLabel);
+    return checked;
+  }
+
+  async wait_for_single_element(element, timeOutSeconds) {
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    let count = await tppElement.locator().count();
+    let i = 0;
+    while(count != 1 && i < timeOutSeconds) {
+      await this.page.waitForTimeout(1000);
+      count = await tppElement.locator().count();
+      i++;
+    }
+    return count === 1;
+  }
+
+  isNavigationError(exception) {
+    return exception?.message?.includes("Execution context was destroyed")
+    && exception?.message?.includes("most likely because of a navigation");
+  }
+
+    // If expected count is 1, wait when multiple elements are matching
+  async tpp_element_or_backup(element, logLabel, expectedCount, timeOutSeconds, autohealCallback, ignoreFailure) {
+    let i = 0;
+    let ex;
+    let fallback = await this.getFallbackLocators(element);
+    if (fallback) {
+      this.log(logLabel, `Using cached fallback locator for element: ${element.label}`);
+      if (element.params) {
+        fallback.locator = fallback.locator.replace('${rowId}', element.params.rowId).replace('${colId}', element.params.colId);
+        fallback.backupLocators = fallback.backupLocators.map(backup => {
+          return {
+            ...backup,
+            locator: backup.locator.replace('${rowId}', element.params.rowId).replace('${colId}', element.params.colId)
+          };
+        });
+      }
+      return { autoheal: false, element: new TppElement(fallback, this.page, this.fromAi) };
+    }
+    while(i < 7) {
+      try {
+        let res = await this.getTppElementOrBackup(element, logLabel, expectedCount, timeOutSeconds);
+        if (res.success) {
+          return res;
+        } else {
+          ex = await this.throwElementNotPresent(element, logLabel, expectedCount === 1);
+          break;
+        }
+      } catch (e) {
+        i++;
+        if(i < 7 && this.isNavigationError(e)) {
+          this.log(logLabel, `Page reloaded or redirected while checking for element. Retrying... #${i}`);
+          await sleep(2000);
+        } else {
+          ex = e;
+          break;
+        }
+      }
+    }
+    if (autohealCallback && element.snaps.length) {
+      this.log(logLabel, `${this.autohealLog(element)} :: [BEGIN]`);
+      const heal = await this.getAiAction(element, logLabel, ex ? ex.message: "" , autohealCallback);
+      if (!heal.success) {
+        this.failureLog(logLabel);
+        throw { message: `${ex?.message ? ex?.message + ".": "" } Fallback to auto-healing. Auto-heal Failed. AI Response - ${heal.message}` };
+      }
+      this.log(logLabel, `${this.autohealLog(element)} :: [END]`);
+      return { autoheal: true, element: undefined, message: heal.message || heal.verify };
+    }
+    if (!ignoreFailure && ex) { 
+      this.failureLog(logLabel);
+      throw ex;
+    };
+    return { autoheal: false, element: new TppElement(element, this.page, this.fromAi) };
+  }
+
+  autohealLog(element) {
+    return `Auto-healing for element: ${element.label}`;
+  }
+
+  async getTppElementOrBackup(element, logLabel, expectedCount, timeOutSeconds) {
+    if(element.chainedLocator?.length || expectedCount === 0) {
+      return { success: true, element: new TppElement(element, this.page, this.fromAi) };
+    }
+    const checkFn = (ele) => expectedCount === 1 
+    ? this.wait_for_single_element(ele, timeOutSeconds || (element.backupLocators?.length ? 10 : this.customConfig?.timeouts?.actionTimeout || 30))
+    : this.is_nth_element_present(ele, 0);
+
+    if(await checkFn(element)) {
+      return { success: true, element: new TppElement(element, this.page, this.fromAi) };
+    }
+
+    let i = 0;
+    let tppElement = new TppElement(element, this.page, this.fromAi);
+    while(i < element.backupLocators.length) {
+      new Logger(this.caller, this.blacklistedLogs).elementBackupRetryLog(tppElement, i, logLabel);
+      const backup = element.backupLocators[i]
+      tppElement = new TppElement(
+        {...element, ...backup},
+        this.page,
+        this.fromAi
+      );
+      if(await checkFn(tppElement.element)) {
+        new Logger(this.caller, this.blacklistedLogs).logBackupLocatorUsed(tppElement);
+        return { success: true, element: tppElement};
+      }
+      i++;
+    }
+    return { success: false, element: new TppElement(element, this.page, this.fromAi)}
+  }
+
+  async click_on_element(element) {
+    const logLabel = `Click on element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.click_on_element(x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().click();
+    } catch (e) {
+      if(await tppElement.locator().isVisible() && await tppElement.locator().isEnabled()) {
+        try {
+          await tppElement.locator().click({force: true});
+        } catch (e) {
+          await this.handleClickException(e, tppElement, logLabel);
+        }
+      } else {
+        await this.handleClickException(e, tppElement, logLabel);
+      }
+    }
+    this.endLog(logLabel);
+  }
+
+async click_on_element_if_present(element) {
+    const logLabel = `Click on element - ${element.label} if present`;
+    this.startLog(logLabel);
+    let tppElement;
+    try {
+      let { element: element1 } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, undefined, true);
+      tppElement = element1;
+      if(await tppElement.locator().count()>0) {
+        this.log(logLabel, 'Element present.');
+        try {
+          await this.takeAutohealScreenshot(tppElement);
+          await tppElement.locator().click();
+        } catch (e) {
+          await this.handleClickException(e, tppElement, logLabel);
+        }
+      } else {
+        this.log(logLabel, 'Element not present.');
+      }
+    } catch (e) {
+      this.log(logLabel, 'Element not present.');
+    } finally {
+      this.endLog(logLabel);
+    }
+    
+  }
+
+  async click_on_element_if_visible(element) {
+    const logLabel = `Click on element - ${element.label} if visible`;
+    this.startLog(logLabel);
+    let tppElement;
+    try {
+      const { element: element1 } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, undefined, true);
+      tppElement = element1;
+      await this.checkElementVisibility(tppElement, logLabel);
+    } catch (e) {
+      this.log(logLabel, 'Element is not visible.');
+      this.endLog(logLabel);
+      return;
+    }
+    this.log(logLabel, 'Element visible.');
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().click();
+    } catch (e) {
+      await this.handleClickException(e, tppElement, logLabel);
+    }
+    this.endLog(logLabel);
+  }
+
+  async click_on_nth_element(element, n) {
+    const logLabel = `Click on nth element - ${element.label}, n - ${n}`;
+    this.startLog(logLabel);
+    n = Number(n);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 2);
+    try {
+      await tppElement.locator().nth(n).click();
+    } catch (e) {
+      if(await tppElement.locator().nth(n).isVisible() && await tppElement.locator().nth(n).isEnabled()) {
+        try {
+          await tppElement.locator().nth(n).click({force: true});
+        } catch (e) {
+          await this.handleClickException(e, tppElement, logLabel);
+        }
+      } else {
+        await this.handleClickException(e, tppElement, logLabel);
+      }
+    }
+    this.endLog(logLabel);
+  }
+
+  async double_click_on_element(element) {
+    const logLabel = `Double Click on element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.double_click_on_element(x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().dblclick();
+    } catch (e) {
+      await this.handleClickException(e, tppElement, logLabel);
+    } 
+    this.endLog(logLabel);
+  }
+
+  async right_click_on_element(element) {
+    const logLabel = `Right Click on element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.right_click_on_element(x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().click({button: 'right'});
+    } catch (e) {
+      await this.handleClickException(e, tppElement, logLabel);
+    }
+    this.endLog(logLabel);
+  }
+
+  async click_at_point_on_element(x, y, element) {
+    const logLabel = `Click at point (${x}, ${y}) of element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.click_on_element(x, y);
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().waitFor({state: "visible"});
+      const box = await tppElement.locator().boundingBox();
+      if(!box) {
+        throw {message: 'Unable to find element position!'}
+      }
+
+      const clickX = x < 0 ? box.x + box.width + x : box.x + x;
+      const clickY = y < 0 ? box.y + box.height + y : box.y + y;
+
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(clickX, clickY);
+
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  async click_at_point_on_element_and_move(x, y, toX, toY, element) {
+    const logLabel = `Click and hold at point (${x}, ${y}) move to (${toX}, ${toY}) on element - ${element.label} and release`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    const boundingBox = await tppElement.locator().boundingBox();
+    this.takeAutohealScreenshot(tppElement);
+
+    const startX = boundingBox.x + x;
+    const startY = boundingBox.y + y;
+    const endX = boundingBox.x + toX;
+    const endY = boundingBox.y + toY;
+
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+
+    await page.mouse.move(startX, startY);
+    await page.mouse.down();
+    await page.mouse.move(endX, endY, { steps: 5 });
+    await page.mouse.up();
+    this.endLog(logLabel);
+  }
+
+  async right_click_at_point_on_element(x, y, element) {
+    const logLabel = `Right Click at point (${x}, ${y}) on element - ${element.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().click({button: 'right', position: {x: x, y: y}});
+    } catch (e) {
+      await this.handleClickException(e, tppElement, logLabel);
+    }
+    this.endLog(logLabel);
+  }
+
+  async double_click_at_point_on_element(x, y, element) {
+    const logLabel = `Double Click at point (${x}, ${y}) on element - ${element.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await this.takeAutohealScreenshot(tppElement);
+      await tppElement.locator().dblclick({position: {x: x, y: y}});
+    } catch (e) {
+      await this.handleClickException(e, tppElement, logLabel);
+    }
+    this.endLog(logLabel);
+  }
+
+  async input_value(value, element) {
+    const logLabel = `Input - ${value}, on element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.input_value(value, x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      const options = this.fromAi ? {delay: 50} : {};
+      await tppElement.locator().type(`${value}`, {...options});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async type_text(text, userOptions) {
+    const logLabel = `Type text - ${text}`;
+    this.startLog(logLabel);
+    const options = this.fromAi ? {delay: 50} : {};
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.keyboard.type(`${text}`, {...options, ...(userOptions || {}) });
+    this.endLog(logLabel);
+  }
+
+  async clear_text(element) {
+    const logLabel = `Clear text from element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.clear_text(x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return; 
+    }
+    try {
+      await tppElement.locator().clear();
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async press_keys_on_element(keys, element) {
+    const logLabel = `Press Keyboard Keys - ${keys}, on element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.press_keys_on_element(keys, x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      await tppElement.locator().press(keys);
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async press_keys(keys) {
+    const logLabel = `Press Keyboard Keys - ${keys}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.keyboard.press(keys);
+    this.endLog(logLabel);
+  }
+
+  async select_value(value, element) {
+    const logLabel = `Select - ${value}, on element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.select_value(value, x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      const options = this.fromAi ? {delay: 50} : {};
+      await tppElement.locator().selectOption(`${value}`, {...options});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async pick_value_in_slider(element, value, start, end) {
+    const logLabel = `Pick Value on slider element ${element.label}, value = ${value}, start = ${start}, end = ${end}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await new SliderUtils(this.page).pickValueInSlider(tppElement, value, start, end);
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async pick_value_in_slider_with_step(element, value, start, end, step) {
+    const logLabel = `Pick Value on slider element ${element.label}, value = ${value}, start = ${start}, end = ${end}, step = ${step}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await new SliderUtils(this.page).pickValueInSlider(tppElement, value, start, end, step);
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async click_slider_at_ratio(element, ratio) {
+    const logLabel = `Click slider element ${element.label}, at ratio ${ratio}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await new SliderUtils(this.page).clickSliderAtRatio(tppElement, ratio);
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async set_geo_location(latitude, longitude) {
+    const logLabel = `Set Geolocation - ${latitude} , ${longitude}`;
+    this.startLog(logLabel);
+    await this.page.context().setGeolocation({latitude: latitude, longitude: longitude});
+    this.endLog(logLabel);
+  }
+
+  async set_element_attribute(key, value, element) {
+    const logLabel = `Set attribute - ${key} with value - ${value}, on element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.set_element_attribute(key, value, x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      await tppElement.locator().evaluate((node, {key, value}) => {
+        node.setAttribute(key, value);
+      }, {key, value});
+      await this.takeAutohealScreenshot(tppElement);
+      this.endLog(logLabel);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+  }
+
+  async get_element_attribute(key, element) {
+    const logLabel = `Get attribute ${key} from element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.get_element_attribute(key, x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      const val = await tppElement.locator().getAttribute(key, {timeout: 10000});
+      await this.takeAutohealScreenshot(tppElement);
+      this.endLog(logLabel);
+      return val;
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+  }
+
+  async is_element_attribute_present(key, element) {
+    const logLabel = `Is attribute ${key} present in element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.is_element_attribute_present(key, x, y, logLabel, element)
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return callback;
+    }
+    try {
+      const val = await tppElement.locator().getAttribute(key, {timeout: 10000});
+      await this.takeAutohealScreenshot(tppElement);
+      this.endLog(logLabel);
+      return !!val;
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+  }
+
+  async set_input_files(files, element) {
+    const logLabel = `Set input files - ${files} on element ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.set_input_files(files, x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    const fileUtils = new FileUtils();
+    const filePaths = files.map(file => fileUtils.getFilePath(file));
+    try {
+      await tppElement.locator().setInputFiles(filePaths);
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async scroll_element_into_view(element) {
+    const logLabel = `Scroll element ${element.label} into view`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await tppElement.locator().scrollIntoViewIfNeeded();
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  isWebKitMobile() {
+    let browserConfig = this.tppTest.info()?.project?.use;
+    return (browserConfig?.isMobile || browserConfig?.hasTouch) && browserConfig?.defaultBrowserType === 'webkit';
+  }
+
+  async scroll_to_end_of_page() {
+    const logLabel = 'Scroll to end of the page';
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+
+    if(this.isWebKitMobile()) {
+      await page.evaluate(() => window.scrollTo(0, 20000));
+    } else {
+      await page.mouse.wheel(0, 20000); //TODO check if there is any other approach
+    }
+    this.endLog(logLabel);
+  }
+
+  async scroll_by_xy(x, y) {
+    const logLabel = `Scroll page by pixels x: ${x}, y: ${y}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    if(this.isWebKitMobile()) {
+      await page.evaluate(([x, y]) => window.scrollTo(x, y), [x, y]);
+    } else {
+      await page.mouse.wheel(x, y);
+    }
+    this.endLog(logLabel);
+  }
+
+  async hover_on_element(element) {
+    const logLabel = `Hover on element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.hover_on_element(x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      await tppElement.locator().hover();
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async drag_and_drop_on_element(element, targetElement) {
+    const logLabel = `Drag element - ${element.label} and drop on - ${targetElement.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    const { element: tppTargetElement } = await this.tpp_element_or_backup(targetElement, logLabel, 1);
+    await tppElement.locator().dragTo(tppTargetElement.locator());
+    await this.takeAutohealScreenshot(tppElement);
+    await this.takeAutohealScreenshot(tppTargetElement);
+    this.endLog(logLabel);
+  }
+
+  async switch_to_iframe(element) {
+    const logLabel = `Switch to iframe - ${element.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    const iframe = await this.page.waitForSelector(tppElement.getSelector());
+    // Switch to the iframe context
+    const frame = await iframe.contentFrame();
+    if(!frame) {
+      this.failureLog(logLabel);
+      throw {
+        message: `iframe is not loaded: ${tppElement.element.label}`,
+      };
+    }
+    // Wait for the iframe to be fully loaded
+    await frame.waitForLoadState('load');
+    this.page = frame;
+    this.endLog(logLabel);
+  }
+
+  async switch_to_embed(element) {
+    const logLabel = `Switch to embed - ${element.label}`;
+    this.startLog(logLabel);
+
+    let newClassName;
+    const existingClassMapping = this.embedToIframeMap?.find(classMap => classMap.element === element.label);
+    if(existingClassMapping) {
+      newClassName = existingClassMapping.frameClass;
+    } else {
+      const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+      const embed = await this.page.waitForSelector(tppElement.getSelector());
+      newClassName = `devassure_embed_iframe_${Date.now()}`;
+
+      //Changing the embed to an iframe element
+      await embed.evaluate((node, {newClassName}) => {
+        const iframe = document.createElement('iframe');
+        for (const attr of node.attributes) {
+          iframe.setAttribute(attr.name, attr.value);
+        }
+        iframe.className = node.className;
+        iframe.classList.add(newClassName);
+        iframe.innerHTML = node.innerHTML;
+        node.replaceWith(iframe);
+      }, {newClassName});
+      this.embedToIframeMap = [...(this.embedToIframeMap || []), {element: element.label, frameClass: newClassName}];
+    }
+
+    // Switch to the iframe context
+    let iframe =  await this.page.waitForSelector(`.${newClassName}`);
+    const frame = await iframe.contentFrame();
+    if(!frame) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Failed swtiching to embed!`,
+      };
+    }
+    // Wait for the iframe to be fully loaded
+    await frame.waitForLoadState('load');
+    this.page = frame;
+    this.endLog(logLabel);
+  }
+
+  async switch_to_parent_frame() {
+    const logLabel = `Switch to Parent frame`;
+    this.startLog(logLabel);
+    this.page = this.page.page();
+    await this.page.waitForLoadState('load');
+    this.endLog(logLabel);
+  }
+
+  async open_new_tab() {
+    const logLabel = `Open new Tab`;
+    this.startLog(logLabel);
+    this.page = await this.page.context().newPage();
+    this.library.setPage(this.page);
+    this.endLog(logLabel);
+  }
+
+  async close_current_tab() {
+    const logLabel = `Close current tab`;
+    this.startLog(logLabel);
+    await this.page.close();
+    const pages = this.page.context().pages();
+    if(pages.length > 0) {
+      this.page = pages[0];
+      this.library.setPage(this.page);
+    }
+    this.endLog(logLabel);
+  }
+
+  //Index starts from 1
+  async close_tab(index) {
+    const logLabel = `Close tab ${index}`;
+    this.startLog(logLabel);
+    let pages = this.page.context().pages();
+    if(pages.length < index) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Only ${pages.length} tabs are opened ---- Trying to close tab with index ${index}`,
+      };
+    }
+    const isCurrentPage = this.page === pages[index-1];
+    await pages[index-1].close();
+    pages = this.page.context().pages();
+    if(pages.length > 0 && isCurrentPage) {
+      this.page = pages[0];
+      this.library.setPage(this.page);
+    }
+    this.endLog(logLabel);
+  }
+
+  //Index starts from 1
+  async switch_to_tab_i(index) {
+    const logLabel = `Switch to Tab - ${index}`;
+    this.startLog(logLabel);
+    let pages = [];
+    const timeout = this.customConfig?.timeouts?.urlLoadTimeout || 30;
+    let count = 0;
+    while(pages.length < index) {
+      if(count === timeout) {
+        this.failureLog(logLabel);
+        throw {
+          message: `Only ${pages.length} tabs are opened ---- Trying to switch to tab with index ${index}`,
+        };
+      }
+      pages = this.page.context().pages();
+      await this.page.waitForTimeout(1000);
+      count++;
+    }
+    this.page = pages[index-1];
+    this.library.setPage(this.page);
+    await this.page.waitForLoadState('load');
+    this.endLog(logLabel);
+  }
+
+  async switch_to_tab_title(title) {
+    const logLabel = `Switch to Tab - ${title}`;
+    this.startLog(logLabel);
+    let pages = [];
+    const timeout = this.customConfig?.timeouts?.urlLoadTimeout || 30;
+    let count = 0;
+    while(true) {
+      let success;
+      for(let i=0; i < pages.length; i++) {
+        try {
+          if(await pages[i].title() === title) {
+            this.page = pages[i];
+            this.library.setPage(this.page);
+            success = true;
+            break;
+          }
+        } catch(e) {
+          if(this.isNavigationError(e)) {
+            this.log(logLabel, `Page reloaded or redirected while checking for title. Retrying...`);
+            await sleep(2000);
+          }
+        }
+      }
+      if(success) break;
+      if(count === timeout) {
+        this.failureLog(logLabel);
+        throw {
+          message: `Tab with title ${title} is not present`,
+        };
+      }
+      pages = this.page.context().pages();
+      await this.page.waitForTimeout(1000);
+      count++;
+    }
+    this.endLog(logLabel);
+  }
+
+  async get_tab_names() {
+    const logLabel = `Get tab names`;
+    this.startLog(logLabel);
+    const pages = this.page.context().pages();
+    const titles = await Promise.all(pages.map(page => page.title()));
+    this.endLog(logLabel);
+    return titles;
+  }
+
+  async get_tab_count() {
+    const logLabel = `Get tab count`;
+    this.startLog(logLabel);
+    const count = this.page.context().pages().length;
+    this.endLog(logLabel);
+    return count;
+  }
+
+  async open_new_window() {
+    const logLabel = `Open new Window`;
+    this.startLog(logLabel);
+    const browser = this.page.context().browser();
+    if(!browser) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Error opening a new window`,
+      };
+    }
+    if(this.remoteBrowserPort) {
+      console.log(`[[TPP]] [[TPP Remote-Execution COMMAND launch_new_window]]`);
+      await sleep(4000);
+      this.page = browser.contexts()?.at(-1)?.pages()?.at(0);
+      this.library.setPage(this.page);
+    } else {
+
+      let recordProp = {};
+      const recordVideo = this.customConfig?.advancedRunConfig?.recordVideo;
+      if(!!recordVideo?.trim() && recordVideo !== 'OFF') {
+        recordProp = {recordVideo: {dir: 'tpp_temp_videos'}};
+      }
+
+      this.page = await (await browser.newContext({
+        ignoreHTTPSErrors: true,
+        ...recordProp,
+      })).newPage();
+      this.library.setPage(this.page);
+    }
+    this.networkLogManager?.startLogTracing(this.page);
+    this.consoleLogManager?.startLogTracing(this.page);
+    this.downloadsManager?.handleDownloads(this.page);
+    this.endLog(logLabel);
+  }
+
+  async close_current_window() {
+    const logLabel = `Close current Window`;
+    this.startLog(logLabel);
+    const browser = this.page.context().browser();
+    if(!browser) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Error closing window`,
+      };
+    }
+    await this.page.context().close();
+    const contexts = browser.contexts();
+    if(contexts.length > 0 && contexts[0]?.pages().length > 0) {
+      this.page = contexts[0].pages()[0];
+      this.library.setPage(this.page);
+    }
+    this.endLog(logLabel);
+  }
+  
+  //Index starts from 1
+  async close_window(index) {
+    const logLabel = `Close Window ${index}`;
+    this.startLog(logLabel);
+    const browser = this.page.context().browser();
+    if(!browser) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Error closing window`,
+      };
+    }
+    let contexts = browser.contexts();
+    if(contexts.length < index) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Only ${pages.length} windows are opened ---- Trying to close window with index ${index}`,
+      };
+    }
+    const isCurrentContext = this.page.context() === contexts[index-1];
+    await contexts[index - 1].close();
+    contexts = browser.contexts();
+    if(isCurrentContext && contexts.length > 0 && contexts[0]?.pages().length > 0) {
+      this.page = contexts[0].pages()[0];
+      this.library.setPage(this.page);
+    }
+    this.endLog(logLabel);
+  }
+
+  async close_all_windows() {
+    const logLabel = `Close All Windows`;
+    this.startLog(logLabel);
+    const browser = this.page.context().browser();
+    if(!browser) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Error closing windows`,
+      };
+    }
+    let contexts = browser.contexts();
+    for (let i = 0; i < contexts.length; i++) {
+      await contexts[i].close();
+    }
+    this.endLog(logLabel);
+  }
+
+  async switch_to_window_i(index) {
+    const logLabel = `Switch to Window - ${index}`;
+    this.startLog(logLabel);
+    const browser = this.page.context().browser();
+    if(!browser) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Error siwtching windows`,
+      }
+    }
+    let contexts = [];
+    const timeout = this.customConfig?.timeouts?.urlLoadTimeout || 30;
+    let count = 0;
+    while(contexts.length < index) {
+      if(count === timeout) {
+        this.failureLog(logLabel);
+        throw {
+          message: `Only ${pages.length} windows are opened ---- Trying to switch to window with index ${index}`,
+        };
+      }
+      contexts = browser.contexts();
+      await this.page.waitForTimeout(1000);
+      count++;
+    }
+    this.page = contexts[index-1].pages()[0];
+    this.library.setPage(this.page);
+    await this.page.waitForLoadState('load');
+    this.endLog(logLabel);
+  }
+
+  async addDialogListener() {
+    this.dialogFns = [];
+    this.page.once('dialog', dialog => {
+      this.dialogFns?.forEach(async fn => fn(dialog));
+      this.dialogFns = undefined;
+    });
+  }
+
+  async wait_for_dialog() {
+    const logLabel = `Wait for dialog`;
+    this.startLog(logLabel);
+    let timeout = this.customConfig?.timeouts?.actionTimeout || 30;
+    while(!!this.dialogFns) {
+      if(count === timeout) {
+        this.failureLog(logLabel);
+        throw {
+          message: `Error waiting for dialog. Dialog was not opened after ${timeout}s!`
+        }
+      }
+      await this.page.waitForTimeout(1000);
+      count++;
+    }
+    this.endLog(logLabel);
+  }
+
+  async dismiss_dialog() {
+    if(!this.dialogFns) this.addDialogListener();
+    this.dialogFns.push((dialog) => {
+      const logLabel = `Dismiss Dialog`;
+      this.startLog(logLabel);
+      dialog.dismiss().catch(() => {})
+      this.endLog(logLabel);
+    })
+  }
+
+  async accept_dialog() {
+    if(!this.dialogFns) this.addDialogListener();
+    this.dialogFns.push((dialog) => {
+      const logLabel = `Accept Dialog`;
+      this.startLog(logLabel);
+      dialog.accept().catch(() => {})
+      this.endLog(logLabel);
+    })
+  }
+
+  async accept_dialog_with_input(input) {
+    if(!this.dialogFns) this.addDialogListener();
+    this.dialogFns.push((dialog) => {
+      const logLabel = `Accept Dialog with input - ${input}`;
+      this.startLog(logLabel);
+      dialog.accept(input).catch(() => {})
+      this.endLog(logLabel);
+    })
+  }
+
+  async verify_dialog_message(comparator, expected) {
+    if(!this.dialogFns) this.addDialogListener();
+    this.dialogFns.push((dialog) => {
+      const logLabel = `Validate Dialog message, ${comparator}, expected: ${expected}`;
+      this.startLog(logLabel);
+      const msg = dialog.message();
+      if(!compare(msg, comparator, expected)) {
+        this.failureLog(logLabel);
+        throw {
+          message: `Dialog message is not as expected. actual: ${msg} ---- comparator: ${comparator} ---- expected: ${expected}`,
+        };
+      }
+      this.endLog(logLabel);
+    })
+  }
+
+  async get_input_element_value(element) {
+    const logLabel = `Get value of input element- ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.get_input_element_value(x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    const value = await tppElement.locator().inputValue();
+    await this.takeAutohealScreenshot(tppElement);
+    this.endLog(logLabel);
+    return value;
+  }
+
+  async get_element_text(element) {
+    const logLabel = `Get text of - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.get_element_text(x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    const text = await tppElement.locator().innerText();
+    await this.takeAutohealScreenshot(tppElement);
+    this.endLog(logLabel);
+    return text;
+  }
+
+  async get_element_count(element) {
+    const logLabel = `Get count of - ${element.label}`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 0);
+    const count = await tppElement.locator().count();
+    this.endLog(logLabel);
+    return count;
+  }
+
+  async get_element_dimensions(element) {
+    const logLabel = `Get dimensions of - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.get_element_dimensions(x, y, logLabel, element)
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 0, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    const dimensions = await tppElement.locator().boundingBox();
+    await this.takeAutohealScreenshot(tppElement);
+    this.endLog(logLabel);
+    return dimensions;
+  }
+
+  get_nth_element(element, n) {
+    const logLabel = `Get nth element of ${element.label}. n = ${n}`;
+    n = Number(n);
+    this.startLog(logLabel);
+    if(n < 0) {
+      this.failureLog(logLabel);
+      throw {
+        message: `index n = ${n} is invalid. should be >= 0`,
+      };
+    }
+    this.endLog(logLabel);
+    return {...element, index: n};
+  }
+
+  async verify_element_text(element, text) {
+    const logLabel = `Verify if text of - ${element.label} == ${text.replaceAll("\n", " ")}`;
+    this.startLog(logLabel);
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, () => {});
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      let timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+      await expect(tppElement.locator()).toHaveText(text, {timeout: timeout});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.checkElementVisibility(tppElement, logLabel);
+      this.handleExpectException(e, logLabel)
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_if_element_present(element) {
+    const logLabel = `Verify if element - ${element.label} is present`;
+    this.startLog(logLabel);
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, () => {});
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      await tppElement.locator().waitFor({state: "attached"});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_if_element_visible(element) {
+    const logLabel = `Verify if element - ${element.label} is visible`;
+    this.startLog(logLabel);
+    const { autoheal, element: tppElement, message } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, () => {});
+    if (autoheal) {
+      this.endLog(logLabel);
+      return message;
+    }
+    try {
+      await tppElement.locator().waitFor({state: "visible"});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  handle_disappear_exceptiom(exception, tppElement, logLabel) {
+    const exceptionLines = exception.toString().split('\n');
+    const message = exceptionLines[0].replace(ansiRegex(), '');
+    if(message.includes('toHaveCount')) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Element is present -- ${exceptionLines[2]} -- ${exceptionLines[4]?.replace(ansiRegex(), '')}`,
+      }
+    }
+    this.handleExpectException(exception, tppElement, logLabel); 
+  }
+
+  async wait_for_element_to_disappear(element) {
+    const logLabel = `Wait for elment - ${element.label} to disappear`;
+    this.startLog(logLabel);
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      let timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+      await expect(tppElement.locator()).toHaveCount(0, {timeout: timeout});
+    } catch (e) {
+      this.handle_disappear_exceptiom(e, tppElement, logLabel); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async wait_for_element_to_disappear_ms(element, duration) {
+    const logLabel = `Wait for elment - ${element.label} to disappear within ${duration} ms`;
+    this.startLog(logLabel);
+    const tppElement = new TppElement(element, this.page, this.fromAi);
+    try {
+      await expect(tppElement.locator()).toHaveCount(0,  {timeout: duration});
+    } catch (e) {
+      this.handle_disappear_exceptiom(e, tppElement, logLabel); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async wait_for_element(element) {
+    const logLabel = `Wait for - ${element.label} to be present`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await tppElement.locator().waitFor({state: "attached"});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  async wait_for_element_ms(element, duration) {
+    const logLabel = `Wait for - ${element.label} to be present within ${duration} ms`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, duration/1000);
+    try {
+      await tppElement.locator().waitFor({state: "attached", timeout: duration});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async wait_for_element_visible(element) {
+    const logLabel = `Wait for - ${element.label} to be visible`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+    try {
+      await tppElement.locator().waitFor({state: "visible"});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  async wait_for_element_visible_ms(element, duration) {
+    const logLabel = `Wait for - ${element.label} to be visible within ${duration} ms`;
+    this.startLog(logLabel);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, duration/1000);
+    try {
+      await tppElement.locator().waitFor({state: "visible", timeout: duration});
+      await this.takeAutohealScreenshot(tppElement);
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true); 
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_element_count(element, count) {
+    const logLabel = `Verify if count of - ${element.label} == ${count}`;
+    this.startLog(logLabel);
+    count = Number(count);
+    const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, count);
+    try {
+      let timeout = (this.customConfig?.timeouts?.actionTimeout || 30) * 1000;
+      await expect(tppElement.locator()).toHaveCount(count, {timeout: timeout});
+    } catch (e) {
+      this.handleExpectException(e, logLabel)
+    }
+    this.endLog(logLabel);
+  }
+
+  async get_page_title() {
+    const logLabel = `Get page title`;
+    this.startLog(logLabel);
+    let retry = 0;
+    let title;
+    while(retry < 7) {
+      try {
+        title = await this.page.title();
+      } catch(e) {
+        if(this.isNavigationError(e)) {
+          this.log(logLabel, `Page reloaded or redirected while checking for title. Retrying...`);
+          await sleep(2000);
+        }
+      }
+      retry++;
+      await sleep(1000);
+    }
+    if(title == null) {
+      this.failureLog(logLabel);
+      throw {message: `Error getting page title`};
+    }
+    this.endLog(logLabel);
+    return title;
+  }
+
+  async verify_page_title(text) {
+    const logLabel = `Verify if title of page is equal to ${text}`;
+    this.startLog(logLabel);
+    try {
+      let timeout = (this.customConfig?.timeouts?.urlLoadTimeout || 30) * 1000;
+      await expect(this.page).toHaveTitle(text, {timeout: timeout});
+    } catch (e) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Text is not as expected. actual: ${await this.page.title()} ---- expected: ${text}`
+      };
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_page_a11y() {
+    const logLabel = `Verify accessibility of page`;
+    this.startLog(logLabel);
+    try {
+      await new TppA11y(this.page, this.caller).analysePage();
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_page_a11y_soft_assert(softAssert, assertMessage) {
+    const logLabel = `Soft Assert accessibility of page`;
+    this.startLog(logLabel);
+    try {
+      let logMessage = (msg) => new Logger(this.caller, this.blacklistedLogs).log(logLabel, msg);
+      await new TppA11y(this.page, this.caller, {softAssert, assertMessage, logMessage}).analysePage();
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async verify_element_a11y(element) {
+    const logLabel = `Verify accessibility of ${element.label}`;
+    this.startLog(logLabel);
+    try {
+      const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+      await this.takeAutohealScreenshot(tppElement);
+      await new TppA11y(this.page, this.caller).analyseElement(tppElement);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async visual_compare_page(label) {
+    const logLabel = `Visual comparison of page to base snapshot - ${label}`;
+    this.startLog(logLabel);
+    try {
+      await new TppVisualCompare(this.page, this.caller, this.customConfig?.timeouts).comparePage(label);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async visual_compare_element(element, label) {
+    const logLabel = `Visual comparison of ${element.label} to base snapshot - ${label}`;
+    this.startLog(logLabel);
+    try {
+      const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+      await this.takeAutohealScreenshot(tppElement);
+      await new TppVisualCompare(this.page, this.caller, this.customConfig?.timeouts).compareElement(tppElement, label);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async visual_compare_page_soft_assert(label, softAssert, assertMessage) {
+    const logLabel = `Visual comparison of page to base snapshot - ${label} Soft Assert`;
+    this.startLog(logLabel);
+    try {
+      let logMessage = (msg) => new Logger(this.caller, this.blacklistedLogs).log(logLabel, msg);
+      await new TppVisualCompare(this.page, this.caller, this.customConfig?.timeouts, {softAssert, assertMessage, logMessage})
+      .comparePage(label);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async visual_compare_element_soft_assert(element, label, softAssert, assertMessage) {
+    const logLabel = `Visual comparison of ${element.label} to base snapshot - ${label} Soft Assert`;
+    this.startLog(logLabel);
+    try {
+      const { element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1);
+      await this.takeAutohealScreenshot(tppElement);
+      let logMessage = (msg) => new Logger(this.caller, this.blacklistedLogs).log(logLabel, msg);
+      await new TppVisualCompare(this.page, this.caller, this.customConfig?.timeouts, {softAssert, assertMessage, logMessage})
+      .compareElement(tppElement, label);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async advanced_visual_comparison(data) {
+    const logLabel = `Advanced Visual Comparison`;
+    this.startLog(logLabel);
+    try {
+      const tppElement = data?.element 
+      ? (await this.tpp_element_or_backup(data.element, logLabel, 1)).element
+      : undefined;
+      let logMessage = (msg) => new Logger(this.caller, this.blacklistedLogs).log(logLabel, msg);
+      await new TppVisualCompare(this.page, this.caller, this.customConfig?.timeouts, {logMessage})
+      .advancedCompare(tppElement, data);
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+    this.endLog(logLabel);
+  }
+
+  async select_date_in_date_picker(data) {
+    const logLabel = `Select date in date picker`;
+    this.startLog(logLabel);
+    try {
+      // Get format, default to 'MM/DD/YYYY'
+      const format = data.format || 'MM/DD/YYYY';
+
+      // Use DateUtils to calculate target date
+      const targetDate = this.library.date.getTargetDate({
+        date: data.date,
+        offsetDays: data.offsetDays,
+        format: format
+      });
+
+      // Calculate month difference using DateUtils
+      const diff = this.library.date.getMonthDifference(targetDate);
+      // this.log(logLabel, `Month difference: ${diff}`);
+
+      // Get date formats for picker matching
+      const dateFormats = this.library.date.getDatePickerFormats(targetDate, format);
+
+      // Navigate to the correct month
+      if (diff > 0) {
+        // Click next button diff times
+        for (let i = 0; i < diff; i++) {
+          if (!data.nextMonthButtonLocator) {
+            throw new Error('nextMonthButtonLocator is required to navigate to future months');
+          }
+          await this.click_on_element(data.nextMonthButtonLocator);
+          await sleep(200); // Small delay between clicks
+        }
+      } else if (diff < 0) {
+        // Click previous button |diff| times
+        for (let i = diff; i < 0; i++) {
+          if (!data.prevMonthButtonLocator) {
+            throw new Error('prevMonthButtonLocator is required to navigate to past months');
+          }
+          await this.click_on_element(data.prevMonthButtonLocator);
+          await sleep(200); // Small delay between clicks
+        }
+      }
+
+      // Wait a bit for date picker to update after navigation
+      await sleep(300);
+
+      let dateClicked = false;
+
+      // Strategy: Use dateLocator if provided, otherwise use dynamic search
+      if (data.dateLocator) {
+
+        this.log(logLabel, 'Using provided dateLocator with text-based filtering to click date');
+        
+        const baseElement = new TppElement(data.dateLocator, this.page, this.fromAi);
+        const baseLocator = baseElement.locator();
+        
+        // Try each date format with text filtering within the provided dateLocator
+        for (const dateFormat of dateFormats) {
+          if (dateClicked) break;
+          
+          try {
+            // Filter the base locator by text to find the specific date
+            const dateElementWithText = baseLocator.getByText(dateFormat, { exact: false }).first();
+            
+            // Check if element exists and is visible
+            if (await dateElementWithText.count() > 0) {
+              await dateElementWithText.waitFor({ state: 'visible', timeout: 2000 }).catch(() => {});
+              if (await dateElementWithText.isVisible()) {
+                await dateElementWithText.click();
+                dateClicked = true;
+                this.log(logLabel, `Successfully clicked date "${dateFormat}" using provided dateLocator with text filter`);
+                break;
+              }
+            }
+          } catch (e) {
+            continue;
+          }
+        }
+      }  
+      
+      if (!dateClicked) {
+        // Dynamically identify and click the date element
+        // Common date picker container and cell selectors
+        const datePickerContainers = [
+          '.calendar', '.datepicker', '.react-datepicker', '.flatpickr-calendar',
+          '[role="grid"]', '[role="table"]', '.mat-calendar-body',
+          '.ant-picker-dropdown', '.rc-calendar', '[class*="calendar"]', '[class*="datepicker"]'
+        ];
+        
+        const dateCellSelectors = [
+          'td[role="gridcell"]', 'td.calendar-day', 'td', 
+          'button[role="gridcell"]', 'button.calendar-day', 
+          '.calendar-day', '[role="gridcell"]', 'button', 'div[role="gridcell"]'
+        ];
+        
+        for (const dateFormat of dateFormats) {
+          if (dateClicked) break;
+          
+          // Strategy 1: Search within date picker containers first
+          for (const container of datePickerContainers) {
+            if (dateClicked) break;
+            
+            for (const cellSelector of dateCellSelectors) {
+              try {
+                const dateElement = this.page.locator(container).locator(cellSelector).getByText(dateFormat, { exact: false }).first();
+                
+                // Check if element exists and is visible
+                if (await dateElement.count() > 0) {
+                  await dateElement.waitFor({ state: 'visible', timeout: 2000 }).catch(() => {});
+                  if (await dateElement.isVisible()) {
+                    await dateElement.click();
+                    dateClicked = true;
+                    this.log(logLabel, `Successfully clicked date "${dateFormat}" found in container ${container} with selector ${cellSelector}`);
+                    break;
+                  }
+                }
+              } catch (e) {
+                continue;
+              }
+            }
+          }
+          
+          // Strategy 2: Direct search for date cells (if container search failed)
+          if (!dateClicked) {
+            for (const cellSelector of dateCellSelectors) {
+              try {
+                const dateElement = this.page.locator(cellSelector).getByText(dateFormat, { exact: false }).first();
+                
+                // Check if element exists and is visible
+                if (await dateElement.count() > 0) {
+                  await dateElement.waitFor({ state: 'visible', timeout: 2000 }).catch(() => {});
+                  if (await dateElement.isVisible()) {
+                    await dateElement.click();
+                    dateClicked = true;
+                    this.log(logLabel, `Successfully clicked date "${dateFormat}" found with selector ${cellSelector}`);
+                    break;
+                  }
+                }
+              } catch (e) {
+                continue;
+              }
+            }
+          }
+          
+          // Strategy 3: Broader text search (fallback)
+          if (!dateClicked) {
+            try {
+              const dateElement = this.page.getByText(dateFormat, { exact: false }).first();
+              
+              // Check if element exists and is visible
+              if (await dateElement.count() > 0) {
+                await dateElement.waitFor({ state: 'visible', timeout: 2000 }).catch(() => {});
+                if (await dateElement.isVisible()) {
+                  await dateElement.click();
+                  dateClicked = true;
+                  this.log(logLabel, `Successfully clicked date "${dateFormat}" found via text search`);
+                  break;
+                }
+              }
+            } catch (e) {
+              continue;
+            }
+          }
+        }
+
+        // If dynamic search failed, throw error
+        if (!dateClicked) {
+          throw new Error(`Unable to find or click date "${targetDate.format(format)}". Dynamic search failed. Consider providing dateLocator for more reliable date selection.`);
+        }
+      }
+
+    } catch (ex) {
+      this.failureLog(logLabel);
+      throw new Error(`Failed to select date in date picker: ${ex?.message || ex}`);
+    }
+    this.endLog(logLabel);
+  }
+  
+
+  async run_js_script(code) {
+    const logLabel = `Run JavaScript in browser`;
+    this.startLog(logLabel);
+    try {
+      const result = await this.page.evaluate((code) => {
+        return eval(code);
+      }, code);
+      this.endLog(logLabel);
+      return result;
+    } catch(ex) {
+      this.failureLog(logLabel);
+      throw ex;
+    }
+  }
+
+  async checkElementVisibility(tppElement, label) {
+    const isVisible = await tppElement.locator().isVisible();
+    if(!isVisible) {
+      let message = 'Element is not visible';
+      const count = await tppElement.locator().count()
+      if(count > 1) {
+        message = 'More than one element is matching in the DOM';
+      } else if(count === 0) {
+        message = 'Element is not present';
+      }
+      throw {
+        message: `${message}: ${tppElement.element.label} : ${tppElement.getSelector()}${new Logger().getIndexLog(tppElement)}`,
+      };
+    }
+  }
+
+  async call_api(api_request) {
+    const path = !api_request.path?.trim() ? '' : `/${api_request.path.trim()}`;
+    const logLabel = `Calling api, method: ${api_request.method}, path: ${api_request.baseUrl}${path}`;
+    this.startLog(logLabel);
+    const apiService = new ApiService(this.request);
+    const response = await apiService.apiCall(api_request);
+    if(this.customConfig?.apiSettings?.testLogs) {
+      let logs = await apiService.getApiDetailsPretty(api_request, response);
+      this.print_log(logs);
+    }
+    this.endLog(logLabel);
+    return response;
+  }
+
+  async call_api_with_json(api_request,data) {
+    const path = !api_request.path?.trim() ? '' : `/${api_request.path.trim()}`;
+    const logLabel = `Calling api with json, method: ${api_request.method}, path: ${api_request.baseUrl}${path}`;
+    this.startLog(logLabel);
+    const apiService = new ApiService(this.request);
+    const response = await apiService.apiCallwithJson(api_request,data);
+    if(this.testType === 'api') {
+      if(api_request.devassureMetadata && typeof api_request.devassureMetadata === "object") {
+        this.print_log("---------------------------------TEST DETAILS---------------------------------");
+        Object.entries(api_request.devassureMetadata || {}).forEach(([key, value]) => {
+          this.print_log(`${key}: ${value}`);
+        });
+        this.print_log("_______________________________________________________________________________");
+      }
+    }
+    if(this.customConfig?.apiSettings?.testLogs) {
+      let logs = await apiService.getApiDetailsPretty(api_request, response);
+      this.print_log(logs);
+    }
+    this.endLog(logLabel);
+    return response;
+  }
+
+  async verify_http_response_status(response, comparator, expectedStatus) {
+    const logLabel = `Validate API response status, ${comparator}, expectedStatus: ${expectedStatus}`;
+    this.startLog(logLabel);
+    new ApiService(this.request).validateStatus(response, comparator, expectedStatus);
+    this.endLog(logLabel);
+  }
+
+  async verify_http_response_text(response, comparator, expected) {
+    const logLabel = `Validate API response text, ${comparator}, expected: ${expected}`;
+    this.startLog(logLabel);
+    await new ApiService(this.request).validateText(response, comparator, expected);
+    this.endLog(logLabel);
+  }
+
+  async verify_http_response_json(response, jsonKey, comparator, expected) {
+    const logLabel = `Validate API response text, key: ${jsonKey}, ${comparator}, expectedValue: ${expected}`;
+    this.startLog(logLabel);
+    await new ApiService(this.request).validateJson(response, jsonKey, comparator, expected);
+    this.endLog(logLabel);
+  }
+
+  async get_http_response_url(apiResponse) {
+    const logLabel = `Get API response URL`;
+    this.startLog(logLabel);
+    const status = new ApiService(this.request).getResponseUrl(apiResponse);
+    this.endLog(logLabel);
+    return status;
+  }
+
+  async get_http_response_staus(apiResponse) {
+    const logLabel = `Get API response status`;
+    this.startLog(logLabel);
+    const status = new ApiService(this.request).getResponseStaus(apiResponse);
+    this.endLog(logLabel);
+    return status;
+  }
+
+  async get_http_response_json(apiResponse) {
+    const logLabel = `Get API response json`;
+    this.startLog(logLabel);
+    const data = await new ApiService(this.request).getResponseBodyJson(apiResponse);
+    this.endLog(logLabel);
+    return data;
+  }
+
+  async get_http_response_text(apiResponse) {
+    const logLabel = `Get API response text`;
+    this.startLog(logLabel);
+    const data = await new ApiService(this.request).getResponseBodyText(apiResponse);
+    this.endLog(logLabel);
+    return data;
+  }
+
+  async get_http_response_headers(apiResponse) {
+    const logLabel = `Get API response headers`;
+    this.startLog(logLabel);
+    const headers = new ApiService(this.request).getResponseHeaders(apiResponse);
+    this.endLog(logLabel);
+    return headers;
+  }
+
+  async get_http_response_header_value(apiResponse, key) {
+    const logLabel = `Get API response header value for key: ${key}`;
+    this.startLog(logLabel);
+    const value = new ApiService(this.request).getResponseHeaderValue(apiResponse, key);
+    this.endLog(logLabel);
+    return value;
+  }
+
+  async invoke_query(dbConfig, query, params, paramValues) {
+    const logLabel = `Invoking DB query, config: ${dbConfig.connection_type}, query: ${query}`;
+    let response;
+    this.startLog(logLabel);
+    try {
+      if(dbConfig.connection_type == "mysql") {
+        response = await new MySQLService().executeQuery(dbConfig, query, params, paramValues);
+      }
+      else if(dbConfig.connection_type == "postgresql") {
+        response = await new PostgreSQLService().executeQuery(dbConfig, query, params, paramValues);
+      } else if (dbConfig.connection_type == "neo4j") {
+        response = await new Neo4jService().executeQuery(dbConfig, query, params, paramValues);
+      } else if (dbConfig.connection_type == "oracle") {
+        response = await new OracleService().executeQuery(dbConfig, query, params, paramValues);
+      }
+      this.endLog(logLabel);
+    } catch (err) {
+      this.log(logLabel, err.message || err);
+      this.failureLog(logLabel);
+      throw {message: err.message || err || 'Error executing DB query!'}
+    }
+    return response;
+  }
+
+  async verify_db_query_response(queryResponse, rowIndex, columnName, comparator, expected) {
+    const logLabel = `Validate DB Query response, key: ${rowIndex},${columnName}, ${comparator}, expectedValue: ${expected}`;
+    this.startLog(logLabel);
+    if(!queryResponse || queryResponse.length <= rowIndex) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Row index ${rowIndex} is invalid!! Number of rows from DB Query = ${queryResponse.length}`,
+      };
+    }
+    if(!queryResponse[rowIndex].hasOwnProperty(columnName)) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Column '${columnName}' is not present!! Available columns = [${Object.keys(queryResponse[rowIndex])?.join(', ')}]`,
+      };
+    }
+    const value = queryResponse[rowIndex][columnName];
+    this.verify_text(value, comparator, expected);
+    this.endLog(logLabel);
+  }
+
+  async verify_db_query_row_count(queryResponse, comparator, expected) {
+    const logLabel = `Validate DB Query row count, ${comparator}, expectedValue: ${expected}`;
+    this.startLog(logLabel);
+    const rowCount = queryResponse == undefined? -1 : queryResponse.length;
+    this.verify_number(rowCount, comparator, expected);
+    this.endLog(logLabel);
+  }
+
+  verify_text(text, comparator, expected) {
+    const logLabel = `Validate text, text: ${text?.toString()?.replaceAll("\n", " ")}, ${comparator}, expected: ${expected}`;
+    this.startLog(logLabel);
+    if(!compare(text, comparator, expected)) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Text is not as expected. actual: ${text} ---- comparator: ${comparator} ---- expected: ${expected}`,
+      };
+    }
+    this.endLog(logLabel);
+  }
+
+  verify_number(number, comparator, expected) {
+    const logLabel = `Validate number, number: ${number}, ${comparator}, expected: ${expected}`;
+    this.startLog(logLabel);
+    if(!compare(number, comparator, expected)) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Number is not as expected. actual: ${number} ---- comparator: ${comparator} ---- expected: ${expected}`,
+      };
+    }
+    this.endLog(logLabel);
+  }
+
+  verify_boolean(value, expected) {
+    const logLabel = `Validate boolean, value: ${value}, expected: ${expected}`;
+    this.startLog(logLabel);
+    if(!!value != !!expected) {
+      this.failureLog(logLabel);
+      throw {
+        message: `Boolean value is not as expected. actual: ${value} ---- expected: ${expected}`,
+      };
+    }
+    this.endLog(logLabel);
+  }
+
+  async take_screenshot(label) {
+    const logLabel = `Take Screenshot with label ${label}`;
+    this.startLog(logLabel);
+    await this.addScreenshot(label);
+    this.endLog(logLabel);
+  }
+
+async dumpWebPageData(url) {
+  await this.open_url(url);
+  await this.page.waitForLoadState('domcontentloaded');
+
+  let html;
+  let retry = 0;
+
+  while (!html && retry < 5) {
+    try {
+      html = await this.page.evaluate(() => {
+        const bannedPatterns = ['style', 'src', 'value', 'data-tpp-background-color', 'data-tpp-cursor'];
+
+        function shouldRemove(attrName, attrValue) {
+          return bannedPatterns.some((pattern) => pattern === attrName) || /\d/.test(attrValue);
+        }
+
+        function cleanNode(node) {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            // Remove banned attributes
+            for (const attr of Array.from(node.attributes)) {
+              if (shouldRemove(attr.name)) {
+                node.removeAttribute(attr.name, attr.value);
+              }
+            }
+          }
+          // Recurse into children
+          for (const child of Array.from(node.childNodes)) {
+            cleanNode(child);
+          }
+        }
+
+        // Remove unwanted nodes entirely
+        document.querySelectorAll("script, style, iframe, object, link[rel=preload], link[rel=prefetch]")
+          .forEach(el => el.remove());
+
+        cleanNode(document.body);
+
+        // Return the full document HTML after cleaning
+        return document.documentElement.outerHTML;
+      });
+    } catch (e) {
+      retry++;
+      await this.page.waitForTimeout(1000);
+    }
+  }
+
+  let data = { html };
+  this.log('', `[WEB-DUMP-DATA-RESULT] ${JSON.stringify(data)}`);
+}
+
+
+  async click_at_center_of_element(element) {
+    const logLabel = `Click at center of element - ${element.label}`;
+    this.startLog(logLabel);
+    let callback = async (x, y) => await this.autoheal.click_on_element(x, y);
+    const { autoheal, element: tppElement } = await this.tpp_element_or_backup(element, logLabel, 1, undefined, callback);
+    if (autoheal) {
+      this.endLog(logLabel);
+      return;
+    }
+    try {
+      await tppElement.locator().waitFor({state: "visible"});
+      const box = await tppElement.locator().boundingBox();
+      if(!box) {
+        throw {message: 'Unable to find element position!'}
+      }
+
+      const x = box.x + box.width / 2;
+      const y = box.y + box.height / 2;
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(x, y);
+
+    } catch (e) {
+      await this.handleElementException(e, tppElement, logLabel, true);
+    }
+    this.endLog(logLabel);
+  }
+
+  async click_on_xy(x, y, options) {
+    const logLabel = options?.button === 'right' 
+    ? `Right Clicking at ${x}, ${y}`
+    : options?.clickCount === 2
+    ? `Double Clicking at ${x}, ${y}`
+    : `Clicking at ${x}, ${y}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.mouse.click(x, y, options);
+    this.endLog(logLabel);
+  }
+
+  async input_on_xy(x, y, data) {
+    const logLabel = `Inputting ${data} on ${x}, ${y}`;
+    this.startLog(logLabel);
+    const targetSelector = `${Date.now()}`;
+    // find the elements at x,y and check if any one of them is of type input/textarea or has roles combobox/textbox or has contentEditableSetto true
+    const element = await this.page.evaluate(([x, y, targetSelector]) => {
+      const element = document.elementsFromPoint(x, y);
+      for(let i=0; i<element.length; i++) {
+        const tagName = element[i].tagName.toLowerCase();
+        const type = element[i].getAttribute('type');
+        const role = element[i].getAttribute('role');
+        const nonTextTypes = ['checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'image', 'color', 'range'];
+        const contentEditable = element[i].getAttribute('contentEditable');
+        if((tagName === 'input' && !nonTextTypes.includes(type)) || tagName === 'textarea' || (role && role.toLowerCase() === 'combobox') || (role && role.toLowerCase() === 'textbox') || (contentEditable && contentEditable.toLowerCase() === 'true')) {
+          element[i].setAttribute('tpp-data-target', targetSelector);
+          return element[i];
+        }
+      }
+    }, [x, y, targetSelector]);
+    if(!element) {
+      let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+      await page.mouse.click(x, y);
+      await this.page.waitForTimeout(100);
+      const fallbackElement = await this.page.evaluate(([x, y, targetSelector]) => {
+        const element = document.activeElement;
+        const tagName = element.tagName.toLowerCase();
+        const type = element.getAttribute('type');
+        const role = element.getAttribute('role');
+        const nonTextTypes = ['checkbox', 'radio', 'button', 'submit', 'reset', 'file', 'image', 'color', 'range'];
+        const contentEditable = element.getAttribute('contentEditable');
+        if((tagName === 'input' && !nonTextTypes.includes(type)) || tagName === 'textarea' || (role && role.toLowerCase() === 'combobox') || (role && role.toLowerCase() === 'textbox') || (contentEditable && contentEditable.toLowerCase() === 'true')) {
+          element.setAttribute('tpp-data-target', targetSelector);
+          return element;
+        }
+      }
+      , [x, y, targetSelector]);
+      // If there is no fallback element, then simply type the data 
+      if (!fallbackElement) {
+        this.endLog(logLabel);
+        return;
+      }
+    }
+    const locator = await this.page.locator(`[tpp-data-target="${targetSelector}"]`);
+    await locator.fill(data);
+
+    this.endLog(logLabel);
+  }
+
+  async clear_input(x, y) {
+    const logLabel = `Clearing input on ${x}, ${y}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.mouse.click(x, y);
+    const selectAllKey = process.platform === 'darwin' ? 'Meta' : 'Control';
+    await page.keyboard.down(selectAllKey);
+    await page.keyboard.press('A');
+    await page.keyboard.up(selectAllKey);
+    await page.keyboard.press('Delete');
+    await page.keyboard.press('Backspace');
+    this.endLog(logLabel);
+  }
+
+  async hover_xy(x, y) {
+    const logLabel = `Hovering over ${x}, ${y}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.mouse.move(x, y);
+    this.endLog(logLabel);
+  }
+  
+  async key_down_xy(value) {
+    const logLabel = `Key Down on ${value}`;
+    this.startLog(logLabel);
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.keyboard.down(value);
+    this.endLog(logLabel);
+  }
+
+  sleep(millis) {
+    return new Promise((resolve) => setTimeout(resolve, millis));
+  }
+
+  async wait_time(millis) {
+    const logLabel = `Wait for ${millis} milliseconds`;
+    this.startLog(logLabel);
+    await sleep(millis);
+    this.endLog(logLabel);
+  }
+
+  async get_clipboard_content() {
+    const logLabel = `Get clipboard content`;
+    this.startLog(logLabel);
+    var ncp = require('node-clipboardy');
+    const text = await ncp.read();
+    this.endLog(logLabel);
+    return text || '';
+  }
+
+  async wait_for_breakpoint(testFile, stepIndex, fnKey) {
+    let content = {
+      filePath: testFile,
+      stepIndex: stepIndex
+    };
+
+    if(fnKey?.trim()) {
+      const secSuffix = "__secondary";
+      if(fnKey.endsWith(secSuffix)) {
+        content.fnKey = fnKey.slice(0, -secSuffix.length);
+        content.secondaryFn = true;
+      } else {
+        content.fnKey = fnKey;
+      }
+    }
+
+    const breakpointFilePath = `.breakpoint/breakpoint_${Date.now()}`;
+    (new FileUtils()).writeTextContent(breakpointFilePath, JSON.stringify(content));
+    
+    this.log(undefined, `[WAIT_FOR_BREAKPOINT] ${path.resolve(breakpointFilePath)}`);
+  
+    //Wait for breakpoint file to be removed
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(() => {
+        if (!fs.existsSync(breakpointFilePath)) {
+          clearInterval(interval);
+          resolve();
+        }
+      }, 500);
+    });
+  }
+
+  action_log(log) {
+    new Logger(this.caller, this.blacklistedLogs).action_log(log);
+  }
+
+  print_log(log) {
+    if(typeof log === 'object') {
+      try {
+       log = JSON.stringify(log, null, 4);
+      } catch (_e) {
+        this.log(undefined, log);
+        return;
+      }
+    } else if(typeof log !== 'string') {
+      this.log(undefined, log);
+      return;
+    }
+    log.split('\n').forEach(line => this.log(undefined, line));
+  }
+
+  log(stepName, msg) {
+    new Logger(this.caller, this.blacklistedLogs).log(stepName, msg);
+  }
+
+  startLog(stepName) {
+    new Logger(this.caller, this.blacklistedLogs).startLog(stepName);
+  }
+
+  endLog(stepName) {
+    new Logger(this.caller, this.blacklistedLogs).endLog(stepName);
+  }
+
+  failureLog(stepName) {
+    new Logger(this.caller, this.blacklistedLogs).failureLog(stepName);
+  }
+
+  async addAllPageScreenshots() {
+    const browser = this.page.context()?.browser();
+    let windowI = 1;
+    for (const context of browser.contexts()) {
+      let tabI = 0;
+      for (const page of context.pages()) {
+        tabI += 1
+        const imageName = windowI === 1 
+        ? (tabI === 1 ? undefined : `tab${tabI}`) 
+        : `window${windowI}_tab${tabI}`;
+        const filePath = getScreenshotPath(imageName, this.caller, this.retry);
+        try {
+          await page.screenshot({ animations: 'disabled', path: filePath, timeout: 5000 });
+        } catch (_e) {
+          await await page.waitForTimeout(5000);
+          try {
+            await page.screenshot({ animations: 'disabled', path: filePath, timeout: 5000 });
+          } catch (ex) {
+            this.exceptionLog(`Error capturing screenshot - ${ex?.message || 'screenshot failed'}.`);
+          }
+        }
+        this.action_log(getScreenshotLog(imageName, filePath, this.caller));
+      }
+      if(tabI > 0) windowI += 1;
+    }
+  }
+
+  async addScreenshot(imageName, allPages) {
+    if(this.testType === 'api') {
+      return;
+    }
+
+    if(allPages && this.testType === 'web') {
+      await this.addAllPageScreenshots();
+      return;
+    }
+
+    const filePath = getScreenshotPath(imageName, this.caller, this.retry);
+    let frame = undefined;
+    if(this.page.page && this.page.page()) {
+      frame = this.page;
+      this.page = this.page.page();
+    }
+    try {
+      if(this.testType === 'mobile') {
+        if(!this.mobile?.driver) {
+          return;
+        }
+        await this.mobile.addScreenshot(filePath);
+      } else {
+        try {
+          await this.page.screenshot({ animations: 'disabled', path: filePath, timeout: 5000 });
+        } catch (_e) {
+          await await this.page.waitForTimeout(5000);
+          await this.page.screenshot({ animations: 'disabled', path: filePath, timeout: 5000 });
+        }
+      }
+      this.action_log(getScreenshotLog(imageName, filePath, this.caller));
+    } catch (ex) {
+      this.exceptionLog(`Error capturing screenshot - ${ex.message || 'screenshot failed'}.`);
+    } finally {
+      if(frame) {
+        this.page = frame;
+      }
+    }
+  }
+
+  exceptionLog(message) {
+    this.action_log(`${LOG_PREFIX}${this.caller} :: [EXCEPTION] ${message}`);
+  }
+
+  testStartLog() {
+    if(this.retry) {
+      this.action_log(`${LOG_PREFIX}${this.caller} :: [RETRY-${this.retry}] :: [BEGIN]`);
+    } else {
+      this.action_log(`${LOG_PREFIX}${this.caller} :: [START]`);
+    }
+    if(this.extensionId === 'TPP_EXTN_NOT_LOADED') {
+      this.action_log(`${LOG_PREFIX}${this.caller} :: Chrome extension ID not found. Extension will still work. If you want to Open UI html and test this extension, please raise a request to DevAssure support!`);
+    }
+  }
+
+    async getAiAction(element, label, exception, autohealCallback) {
+    const screenshots = element.snaps;
+    let config = await this.initializeConfig();
+    if (!config.access_token) {
+      return { success: false, message: 'AI access token is not configured' };
+    }
+    let image = screenshots.filter(snap => snap.testLabel === this.testLabel);
+    if (!image.length) {
+      image = screenshots;
+    }
+    if (!image.length) {
+      return { success: false, message: 'No image found for auto-healing' };
+    }
+    
+    let oldScreenshotPath = element.label.split(/ > /g);
+    oldScreenshotPath.pop()
+    const screenshotFolder = oldScreenshotPath.pop();
+    let completed = undefined;
+    let count = 0;
+    while (!completed && count < 4) {
+      let webState;
+      try {
+        webState = await fetchWebState(this.page);
+      } catch (error) {
+        return { success: false, message: `Error fetching web state: ${error.message}` };
+      }
+
+      const request = {};
+      let oldScreenshotBase64, webStateBase64;
+      oldScreenshotBase64 = []
+      try {
+        for (let screenshot of image) {
+          const screenshotPath = path.join(this.customConfig.projPath, 'page', oldScreenshotPath.join(path.sep), 'da__autoheal', screenshotFolder, screenshot.snapshot);
+          if (!fs.existsSync(screenshotPath)) {
+            continue;
+          }          
+          oldScreenshotBase64.push("data:image/png;base64," + await new FileUtils().pngToBase64(screenshotPath));
+        }
+        webStateBase64 = await new FileUtils().pngToBase64(webState.screenshot);
+      } catch (error) {
+        continue;
+      }
+
+      if (oldScreenshotBase64.length === 0) {
+        return { success: false, message: 'No valid screenshot found for auto-healing' };
+      }
+
+      request.images = [...oldScreenshotBase64, "data:image/png;base64," + webStateBase64];
+      request.elements = webState.elementsData.map(el => {
+          let attributes = '';
+          for (const [key, value] of Object.entries(el)) {
+              if (!['x', 'y', 'index', 'width', 'height', 'top', 'left', 'right', 'bottom'].includes(key)) {
+                if (key && value) {
+                  attributes += ` ${key}="${value}"`;
+                }
+              }
+          }
+          return `<${el.type} ${attributes}>${el.text || ''}</${el.type}>`;
+      });     
+      request.step = label;
+      request.request_id = `${this.caller} - ${Date.now()}`;
+      request.project_id = this.customConfig?.projectId || 'default_project';
+      request.exception = exception;
+      request.attrs = [
+        ...(image.map(snap => snap.attrs || "")),
+      ];
+      const res = await aiWebSocketCall(AI_ENDPOINTS.AUTOHEAL, config, request);
+      if (!res.success) {
+        return { success: false, message: `Error in auto-heal request: ${res.message || res.error}` };
+      }
+      if (!res.data.success && !res.data.followupPrompt) {
+        return { success: false, message: `${res.data.error}` };
+      }
+      if (res?.data?.verification) {
+        if (res?.data?.verification?.response) {
+          return { success: true, verify: true };
+        } else {
+          return { success: false, verify: true, };
+        }
+      } else if (res?.data?.index) {
+        const ele  = webState.elementsData[res?.data?.index];
+        if (!ele) { 
+          return { success: false, message: `Element not found at index ${res.index}` };
+        }
+        let autohealRes;
+        try {
+          autohealRes = await autohealCallback(ele.x, ele.y);
+          return { success: true,  message: `Element auto-heal at coordinates (${ele.x}, ${ele.y})`, message: autohealRes };
+        } catch (e) {
+          if (!e?.message.toLowerCase().includes('navigation')) {
+            return { success: true, message: `Error auto-healing element at index ${res.data.index}: ${e.message || e}` };
+          } 
+          return { success: true, message: `Element auto-heal at coordinates (${ele.x}, ${ele.y})`, message: autohealRes };
+        }
+      } else {
+        for (let action of (res.data?.actions || [])) {
+          let element = webState.elementsData[action.index];
+          if (!element) return { success: false, message: `Element not found at index ${action.index}` };
+          const command = `${action.action} { "x": ${element.x}, "y": ${element.y}, "value": "${action.value}" }`;
+          try {
+              await new WebExecutorAgent(this).processWebExecutorCommand(command);
+          } catch (e) {
+            
+          }
+        }
+      }
+      if (!res.data.followupPrompt) {
+        completed = true;
+        break;
+      }
+      count ++;
+    }
+    if (!completed) {
+      return { success: false, message: 'Auto-healing failed after maximum retries' };
+    }
+    return { success: true, message: "Auto-healing completed successfully" };
+  }
+
+  async handleElementException(ex, tppElement, label, expectSingle) {
+    if(ex.source === 'tpp') {
+      this.failureLog(label);
+      throw ex;
+    }
+    const regex = /^elements_\d+\.(\w+) is not a function(?:.*)?$/;
+    const match = ex.message.match(regex);
+    if(match){
+      const missingElement = match[1];
+      this.failureLog(`Element : ${missingElement} not defined in Page file`);
+      throw {message : `Element : ${missingElement} not defined in Page file`};
+    }
+    if(expectSingle && await tppElement.locator().count() > 1) {
+      throw {message: "More than one element is matching in the DOM"};
+    }
+    this.action_log("Element exception: ", ex);
+    this.failureLog(label);
+    const exceptionLines = (ex?.message || ex.toString()).split('\n');
+    const message = exceptionLines[0].replace(ansiRegex(), '');
+    if(message.includes('Target closed')) {
+      throw {
+        message: `Unable to find element : ${tppElement.element.label} : ${tppElement.getSelector()}${new Logger().getIndexLog(tppElement)}`,
+      };
+    } else {
+      throw ex;
+    }
+  }
+
+  async getSpecialExceptionMessage(tppElement, ignoreCount) {
+    const eleCount = await tppElement.locator().count();
+    if(eleCount <= 0) {
+      return undefined;
+    }
+    if(!ignoreCount && eleCount > 1) {
+      return {message: "More than one element is matching in the DOM"};
+    } else if(!await tppElement.locator().isVisible()) {
+      return {message: "Element is present in DOM but not Visible"};
+    } else if(!await tppElement.locator().isEnabled()) {
+      return {message: "Element is present in DOM but not Enabled"};
+    } else {
+      return {message: "Element is present in DOM but not Clickable"};
+    }
+  }
+
+  async handleClickException(e, tppElement, logLabel, ignoreCount) {
+    let ex = e;
+    console.log("Click exception: ", ex);
+    const specilExcpetion = await this.getSpecialExceptionMessage(tppElement, ignoreCount);
+    if(specilExcpetion) ex = specilExcpetion;
+    await this.handleElementException(ex, tppElement, logLabel); 
+  }
+
+  async throwElementNotPresent(element, label, expectSingle) {
+    const tppElement = new TppElement(element, this.page, this.fromAi)
+    const specilExcpetion = await this.getSpecialExceptionMessage(tppElement, !expectSingle);
+    let ex = specilExcpetion || {message: `Unable to find element : ${element.label} : ${tppElement.getSelector()}${new Logger().getIndexLog(tppElement)}`}
+    return ex;
+  }
+
+  async takeAutohealScreenshot(tppElement) {
+    const shouldTakeScreenshot = this.webAppPreferences?.autoheal && this.executionPreferences?.collectAutohealData && !tppElement.element.snaps?.filter(s => s.testLabel === this.testLabel).length && this.customConfig?.isIde;
+    if (!shouldTakeScreenshot) return;
+    await this.page.waitForTimeout(200);
+    await takeElementScreenshot(this.page, tppElement.element, path.resolve("./"), Date.now(), this);
+  }
+
+  handleExpectException(ex, label) {
+    console.log("Expect exception: ", ex);
+    this.failureLog(label);
+    const exceptionLines = ex.toString().split('\n');
+    const message = exceptionLines[0].replace(ansiRegex(), '');
+    if(message.includes('toHaveText')) {
+      throw {
+        message: `Text is not as expected. actual: ${ex.matcherResult.actual.replaceAll('\n', '')} ---- expected: ${ex.matcherResult.expected}`,
+      };
+    } else if(message.includes('toHaveCount')) {
+      throw {
+        message: `Count is not as expected -- ${exceptionLines[2]} -- ${exceptionLines[3]}`,
+      };
+    } else if(message.includes('toHaveTitle')) {
+      throw {
+        message: `Page title is not as expected -- ${exceptionLines[2]} -- ${exceptionLines[3]}`,
+      };
+    } else {
+      throw ex;
+    }
+  }
+
+  async getFallbackLocators(element) {
+    if (this.fallbackLocatorCache[element.label]) {
+      return this.fallbackLocatorCache[element.label];
+    }
+    this.fallbackLocatorCache = await new FileUtils().readJSONContent(getAutohealPath(), true);
+    return this.fallbackLocatorCache[element.label];
+  }
+
+  async setFallbackLocators(element, locator) {
+    this.fallbackLocatorCache = await new FileUtils().readJSONContent(getAutohealPath());
+    this.fallbackLocatorCache[element.label] = locator;
+    await new FileUtils().writeJSONContent(getAutohealPath(), this.fallbackLocatorCache);
+  }
+
+  async saveVideos(testPass) {
+    if(this.testType === 'web' && this.customConfig?.keepBrowserOpen) {
+      return;
+    }
+    const recordVideo = this.customConfig?.advancedRunConfig?.recordVideo;
+    if(!recordVideo || recordVideo === 'OFF') {
+      return;
+    }
+
+    if(recordVideo !== 'ALWAYS' && testPass) {
+      return;
+    }
+
+    let windowI = 1;
+    const browser = this.page.context()?.browser();
+    for (const context of browser.contexts()) {
+      let tabI = 0;
+      for (const page of context.pages()) {
+        tabI += 1;
+        try {
+          await page.close();
+        } catch (ex) {
+          console.log("Exception closing page for saving video : ", ex);
+        } finally {
+          const video = page.video();
+          if (video) {
+            const videoName = windowI === 1 
+            ? (tabI === 1 ? undefined : `tab${tabI}`) 
+            : `window${windowI}_tab${tabI}`;
+            const dest = getScreenshotPath(videoName, this.caller, this.retry, true);
+            try {
+              await video.saveAs(dest);
+              if(this.customConfig?.isIde && os.platform() === 'linux') {
+                try {
+                  const tempFileName = `${Date.now()}_${generateRandomString(4)}.webm`;
+                  const linuxTempFile = path.join(os.homedir() || '', 'devassure', 'temp_video_recordings', tempFileName);
+                  new FileUtils().copyFile(dest, linuxTempFile);
+                  this.action_log(getScreenshotLog(videoName, linuxTempFile, this.caller, true));
+                } catch (_error) {
+                  this.action_log(getScreenshotLog(videoName, dest, this.caller, true));
+                }
+              } else {
+                this.action_log(getScreenshotLog(videoName, dest, this.caller, true));
+              }
+            } catch (error) {
+              console.log(error);
+              this.log(undefined, "Browser is unable to create video recording!");
+            }
+          }
+        }
+      }
+      if(tabI > 0) windowI += 1;
+      if(this.totalRetries && this.retry !== this.totalRetries) {
+        continue;
+      }
+      try{ context.close(); } catch (_ex) {}
+    }
+  }
+
+
+  async handleResult(e, tppTest) {
+    if(this.page.page && this.page.page()) {
+      this.page = this.page.page(); //Handle if current context is frame
+    }
+
+    tppTest && checkA11yAttachments(tppTest, this.caller);
+    let status;
+    let parsedError;
+    if(!e) {
+      if(this.retry) {
+        this.action_log(`${LOG_PREFIX}${this.caller} :: [RETRY-${this.retry}] :: [END]`);
+      }
+      if(this.customConfig) {
+        this.customConfig.testInfo = {
+          ...this.customConfig.testInfo || {},
+          status: 'passed',
+        }
+      }
+      tppTest && await new EachTestHook(this).runAfterEach();
+
+      await this.saveVideos(true);
+
+      this.action_log(`${LOG_PREFIX}${this.caller} :: [PASS]`);
+      status = {pass: true};
+    } else {
+      const timedout = tppTest?.info()?.status === "timedOut";
+      if(timedout) {
+        const durationMsg = tppTest.info().duration ? ` ${tppTest.info().duration} ms` : '';
+        e = {message: `Test timed out!`, logs: [`Time out${durationMsg} exceeded!`, 'You can increase test timeout in run profiles.']};
+      }
+      if(typeof e === 'object' && e.stack) {
+        parsedError = {message: e.stack.split("\n").filter(line => !line.includes('node_modules')).join(" --> ")};
+      } else {
+        parsedError = e;
+      }
+      if(this.customConfig) {
+        this.customConfig.testInfo = {
+          ...this.customConfig.testInfo || {},
+          status: 'failed',
+          error: parsedError?.message || parsedError,
+        }
+      }
+      console.error("Result exception: ", e);
+      this.exceptionLog(parsedError.message);
+      status = {pass: false, message: parsedError.message};
+      e.logs?.forEach(log => {
+        this.action_log(`${LOG_PREFIX}${this.caller} :: ${log}`);
+      });
+      if(this.testType !== 'api' && !timedout) {
+        await this.addScreenshot(undefined, true);
+      }
+      tppTest && await new EachTestHook(this).runAfterEach();
+
+      await this.saveVideos(false);
+
+      if(this.totalRetries && this.retry !== this.totalRetries) {
+        const tryLabel = this.retry ? `[RETRY-${this.retry}]` : '[FIRST_TRY]'
+        this.action_log(`${LOG_PREFIX}${this.caller} :: ${tryLabel} :: [ERROR]`);
+      } else {
+        this.action_log(`${LOG_PREFIX}${this.caller} :: [FAIL]`);
+      }
+    }
+
+    try {
+      if(
+        (this.testType === 'web' && this.customConfig?.keepBrowserOpen)
+        || (this.testType === 'mobile' && this.customConfig?.keepMobileAppOpen)
+      ) {
+        const entity = this.testType === 'mobile' ? 'mobile app session' : 'browser'
+        this.action_log(`${LOG_PREFIX}${this.caller} :: Keeping ${entity} open!`);
+        for (let i = 0; i < 2 * 60 * 60; i++) { //Sleep for 2 hours
+          await sleep(1000);
+        }
+      }
+      if(this.testType === 'mobile') {
+        await this.mobile.shutdown(status);
+      }
+      await this.page?.context()?.close();
+    } catch (_e) {
+      try {await this.page?.context()?.close();} catch (_e) {}
+    };
+
+    if(e && status?.pass === false) {
+      if(tppTest) {
+        this.logAutohealSkip();
+        tppTest.fail(true, parsedError?.message || parsedError || e);
+      } else {
+        this.logAutohealSkip();
+        throw e
+      };
+    }
+  }
+
+  logAutohealSkip() {
+    if (this.webAppPreferences?.autoheal) {
+      this.log(undefined, `Skipped autoheal for the rest of the actions due to test failure.`);
+    }
+  }
+
+  get_constant_value = (val) => val;
+}
+
+exports.Actions = Actions;