ff-automationv2 2.2.28 → 2.2.30

package/dist/tests/testkaf.js

@@ -1,56 +1,52 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fireflinkKafka_service_js_1 = require("../service/kafka/fireflinkKafka.service.js");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const certPath = path_1.default.join("D:", "Bitbucket", "automationV2", "Certificates", "certificate.crt");
-const ssl = {
-    ca: [fs_1.default.readFileSync(certPath, "utf-8")],
-    rejectUnauthorized: false,
-};
-const inst = new fireflinkKafka_service_js_1.KafkaProducerService(["test.fireflink.com:9222"], ssl);
-let payload = {
-    topic: `Topic-FIREFLINK-api-requests-test3`,
-    message: {
-        "stepData": [{
-                "nlpName": "OpenBrowser",
-                "elementsData": [],
-                "stepInputs": []
-            }
-        ],
-        "type": "web",
-        "scriptName": "NLPList6",
-        "version": "",
-        "scriptType": "Web & Mobile (Android & iOS)",
-        "projectId": "PJT1041",
-        "testCaseId": "SCR1930",
-        "promptId": "1f348fb3-b0f6-4eb4-b9a0-6c6cc33fea68",
-        "pageDetails": {
-            "Web": {
-                "pageId": "PAG025b6c68-9a55-46da-b353-0894f29c7f27",
-                "pageName": "ai-Page"
-            },
-            "Android": {
-                "pageId": "PAGb830f55d-077a-4d09-ae71-91fece6b0011",
-                "pageName": "ai-Android-Page"
-            },
-            "iOS": {
-                "pageId": "PAGcbb751fe-f056-4a09-a2ba-64c1092b5f89",
-                "pageName": "ai-Ios-Page"
-            }
-        },
-        "generatedBy": "",
-        "webSocketId": "",
-        "licenseType": "C-Professional",
-        "licenseId": "LIC3916",
-        "userId": "USR26696",
-        "projectType": "Web & Mobile",
-        "topic": "Topic-FIREFLINK-api-requests-performances",
-        "serverHost": "https://performances.fireflink.com",
-        "tokensConsumed": 1234,
-    }
-};
-inst.produceMessage(payload);
+// import { KafkaProducerService } from "../service/kafka/fireflinkKafka.service.js"
+// import path from "path";
+// import fs from "fs";
+// const certPath = path.join("D:", "Bitbucket", "automationV2", "Certificates", "certificate.crt");
+// const ssl = {
+//     ca: [fs.readFileSync(certPath, "utf-8")],
+//     rejectUnauthorized: false,
+// }
+// const inst = new KafkaProducerService(["test.fireflink.com:9222"], ssl);
+// let payload = {
+//     topic: `Topic-FIREFLINK-api-requests-test3`,
+//     message: {
+//         "stepData": [{
+//             "nlpName": "OpenBrowser",
+//             "elementsData": [],
+//             "stepInputs": []
+//         }
+//         ],
+//         "type": "web",
+//         "scriptName": "NLPList6",
+//         "version": "",
+//         "scriptType": "Web & Mobile (Android & iOS)",
+//         "projectId": "PJT1041",
+//         "testCaseId": "SCR1930",
+//         "promptId": "1f348fb3-b0f6-4eb4-b9a0-6c6cc33fea68",
+//         "pageDetails": {
+//             "Web": {
+//                 "pageId": "PAG025b6c68-9a55-46da-b353-0894f29c7f27",
+//                 "pageName": "ai-Page"
+//             },
+//             "Android": {
+//                 "pageId": "PAGb830f55d-077a-4d09-ae71-91fece6b0011",
+//                 "pageName": "ai-Android-Page"
+//             },
+//             "iOS": {
+//                 "pageId": "PAGcbb751fe-f056-4a09-a2ba-64c1092b5f89",
+//                 "pageName": "ai-Ios-Page"
+//             }
+//         },
+//         "generatedBy": "",
+//         "webSocketId": "",
+//         "licenseType": "C-Professional",
+//         "licenseId": "LIC3916",
+//         "userId": "USR26696",
+//         "projectType": "Web & Mobile",
+//         "topic": "Topic-FIREFLINK-api-requests-performances",
+//         "serverHost": "https://performances.fireflink.com",
+//         "tokensConsumed": 1234,
+//     }
+// }
+// inst.produceMessage(payload)

package/dist/tests/testss.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/testss.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_https_1 = __importDefault(require("node:https"));
+const node_tls_1 = __importDefault(require("node:tls"));
+const undici_1 = require("undici");
+// Augment tls type for getCACertificates (Node >= 22.14)
+const tlsWithNewAPI = node_tls_1.default;
+const existingCa = node_https_1.default.globalAgent.options.ca;
+const existingArr = Array.isArray(existingCa)
+    ? existingCa
+    : existingCa ? [existingCa] : [];
+const sysCerts = tlsWithNewAPI.getCACertificates?.("system") ?? [];
+const caBundle = [...new Set([...existingArr, ...node_tls_1.default.rootCertificates, ...sysCerts])];
+(0, undici_1.setGlobalDispatcher)(new undici_1.Agent({
+    connect: {
+        ca: caBundle,
+        rejectUnauthorized: true
+    }
+}));
+console.log("Done");

package/dist/utils/DomExtraction/jsForAttributeInjection.d.ts

@@ -2,4 +2,6 @@ export interface AnnotatedDOMResult {
     dom: string;
 }
 export declare function getAnnotatedDOM(browser: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;
+export declare function getReactAnnotatedDOM(browser: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;
+export declare function getAngularAnnotatedDOM(browser: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;
 export declare function getAnnotatedDOMForMobile(driver: WebdriverIO.Browser, existingDom?: string): Promise<AnnotatedDOMResult>;

package/dist/utils/DomExtraction/jsForAttributeInjection.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAnnotatedDOM = getAnnotatedDOM;
+exports.getReactAnnotatedDOM = getReactAnnotatedDOM;
+exports.getAngularAnnotatedDOM = getAngularAnnotatedDOM;
 exports.getAnnotatedDOMForMobile = getAnnotatedDOMForMobile;
+const xmldom_1 = require("@xmldom/xmldom");
 const logData_js_1 = require("../../utils/logger/logData.js");
+const frameWorkDetector_js_1 = require("../frameWorkDetector/frameWorkDetector.js");
 async function getAnnotatedDOM(browser) {
+    const isAngular = await frameWorkDetector_js_1.frameWorkDetector.isAngular(browser);
+    if (isAngular) {
+        return getAngularAnnotatedDOM(browser);
+    }
+    return getReactAnnotatedDOM(browser);
+}
+async function getReactAnnotatedDOM(browser) {
     return await browser.execute(() => {
         let nodeIndex = 0;
         // const xpaths: Record<string, string> = {};
@@ -221,7 +232,211 @@ async function getAnnotatedDOM(browser) {
         };
     });
 }
-const xmldom_1 = require("@xmldom/xmldom");
+const INJECT_AND_SERIALIZE_DOM_JS = `
+return (function () {
+  let nodeIndex = 0;
+function getCoverageStatus(el) {
+    if (!el || !el.getBoundingClientRect) return "unknown";
+    const s = getComputedStyle(el);
+    if (s.pointerEvents === "none") return "false";
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return "false";
+    // Off-screen element — check if something is blocking the viewport
+    const isOffScreen =
+        rect.bottom < 0 ||
+        rect.right < 0 ||
+        rect.top > window.innerHeight ||
+        rect.left > window.innerWidth;
+    if (isOffScreen) {
+        const centerEl = document.elementFromPoint(
+            window.innerWidth / 2,
+            window.innerHeight / 2
+        );
+        if (centerEl && centerEl !== document.body && centerEl !== document.documentElement) {
+            // Something is at center of viewport — check if el and centerEl
+            // share the same scrollable container
+            const elScrollParent = getScrollParent(el);
+            const centerScrollParent = getScrollParent(centerEl);
+            if (elScrollParent !== centerScrollParent) return "true";
+        }
+        return "false";
+    }
+    // On-screen element — use elementFromPoint
+    const testPoints = [
+        [rect.left + 5, rect.top + 5],
+        [rect.right - 5, rect.top + 5],
+        [rect.left + 5, rect.bottom - 5],
+        [rect.right - 5, rect.bottom - 5],
+        [rect.left + rect.width / 2, rect.top + rect.height / 2]
+    ];
+    for (const [x, y] of testPoints) {
+        if (x < 0 || y < 0 || x > window.innerWidth || y > window.innerHeight) continue;
+        const topEl = document.elementFromPoint(x, y);
+        if (!topEl) continue;
+        if (topEl === el || el.contains(topEl)) continue;
+        if (topEl.contains(el)) continue; // topEl is ancestor, not a cover
+        return "true";
+    }
+    return "false";
+}
+function getScrollParent(node) {
+    if (!node || node === document.body) return document.body;
+    const s = getComputedStyle(node);
+    if (
+        s.overflow === "auto" || s.overflow === "scroll" ||
+        s.overflowY === "auto" || s.overflowY === "scroll"
+    ) return node;
+    return getScrollParent(node.parentElement);
+}
+function isUsable(node) {
+    const s = getComputedStyle(node);
+    if (s.display === "none" || s.visibility === "hidden" || s.opacity === "0") return false;
+    const rect = node.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    return true;
+}
+
+function isSelectRelated(node) {
+    return (
+        node.matches?.("select, option") ||
+        node.closest?.("select, [role='listbox'], [role='combobox']")
+    );
+}
+  function annotate(node) {
+    const s = getComputedStyle(node);
+    node.setAttribute("element-visibility", s.visibility || "");
+    node.setAttribute("element-pointer-events", s.pointerEvents || "");
+    node.setAttribute("element-zindex", s.zIndex || "");
+     if (isSelectRelated(node)) {
+        node.setAttribute("element-covered", "false");
+        return;
+    }
+
+    if (!isUsable(node)) {
+        node.setAttribute("element-covered", "true");
+        return;
+    }
+     try {
+        node.setAttribute("element-covered", getCoverageStatus(node));
+        
+    } catch {
+        node.setAttribute("element-covered", "unknown");
+    }
+  }
+  function getXPath(node) {
+    if (!node || node.nodeType !== 1) return "";
+    let segments = [];
+    let current = node;
+    while (current && current.nodeType === 1) {
+        const parent = current.parentNode;
+        if (parent instanceof ShadowRoot) {
+            const host = parent.host;
+            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
+            const index = siblings.indexOf(current) + 1;
+            segments.unshift("shadow/" + current.tagName.toLowerCase() + "[" + index + "]");
+            current = host;
+            continue;
+        }
+        let index = 1;
+        if (parent && parent.children) {
+            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
+            index = siblings.indexOf(current) + 1;
+        }
+        segments.unshift(current.tagName.toLowerCase() + "[" + index + "]");
+        if (!parent || parent.nodeType !== 1) break;
+        current = parent;
+    }
+    let path = "/" + segments.join("/");
+    if (node.ownerDocument !== document) {
+        const frameEl = node.ownerDocument.defaultView && node.ownerDocument.defaultView.frameElement;
+        if (frameEl) {
+            let framePath = frameEl.getAttribute("ff-xpath");
+            if (!framePath) framePath = getXPath(frameEl);
+            path = framePath + path;
+        }
+    }
+    return path;
+  }
+  function walk(root) {
+     const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+    let node = walker.currentNode;
+    while (node) {
+        if (node.nodeType === 1 
+            && typeof node.setAttribute === 'function'
+            && !["META", "STYLE", "SCRIPT"].includes(node.tagName)) {
+            node.setAttribute("ff-inspect", "Fire-Flink-" + nodeIndex++);
+            node.setAttribute("ff-xpath", getXPath(node));
+            annotate(node);
+        }
+        if (node.shadowRoot) walk(node.shadowRoot);
+        if (node.tagName === "IFRAME") {
+            try {
+                const doc = node.contentDocument;
+                if (doc && doc.documentElement) walk(doc.documentElement);
+            } catch {
+                node.setAttribute("ff-cross-origin", "true");
+            }
+        }
+        node = walker.nextNode();
+    }
+  }
+function cleanup(root) {
+    const startNode = (root.nodeType === 1) ? root : null;
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+    let node = walker.currentNode;
+    while (node) {
+     if (node.nodeType === 1 && typeof node.removeAttribute === 'function') {
+        node.removeAttribute("ff-inspect");
+        node.removeAttribute("ff-xpath");
+        node.removeAttribute("element-visibility");
+        node.removeAttribute("element-pointer-events");
+        node.removeAttribute("element-zindex");
+        node.removeAttribute("element-covered");
+        node.removeAttribute("ff-cross-origin");
+}
+        if (node.shadowRoot) cleanup(node.shadowRoot);
+        node = walker.nextNode();
+    }
+}
+cleanup(document.documentElement);
+// Force browser to settle DOM after cleanup
+void document.documentElement.offsetHeight;
+walk(document.documentElement);
+  function serializeNode(node) {
+    if (node.nodeType === Node.TEXT_NODE) return node.textContent;
+    if (node.nodeType !== Node.ELEMENT_NODE) return "";
+    const tag = node.tagName.toLowerCase();
+    let html = "<" + tag;
+    for (const attr of node.attributes) {
+        if (attr.name === "srcdoc") continue;
+        html += " " + attr.name + "=\\"" + attr.value.replace(/"/g, "&quot;") + "\\"";
+    }
+    html += ">";
+    if (node.shadowRoot) {
+        html += "<!--#shadow-root-->";
+        node.shadowRoot.childNodes.forEach(child => { html += serializeNode(child); });
+        html += "<!--#/shadow-root-->";
+    }
+    if (tag === "iframe" && node.getAttribute("ff-cross-origin") !== "true") {
+        try {
+            const doc = node.contentDocument;
+            if (doc) html += serializeNode(doc.documentElement);
+        } catch {}
+    }
+    node.childNodes.forEach(child => { html += serializeNode(child); });
+    html += "</" + tag + ">";
+    return html;
+  }
+  return "<!DOCTYPE html>\\n" + serializeNode(document.documentElement);
+})();
+`;
+async function getAngularAnnotatedDOM(browser) {
+    const fn = new Function(INJECT_AND_SERIALIZE_DOM_JS);
+    const result = await browser.execute(fn);
+    return {
+        dom: result
+    };
+}
 async function getAnnotatedDOMForMobile(driver, existingDom) {
     try {
         let pageSource = "";
@@ -230,9 +445,7 @@ async function getAnnotatedDOMForMobile(driver, existingDom) {
         }
         else {
             await driver.pause(1000);
-            const startTime = Date.now();
             pageSource = await driver.getPageSource();
-            logData_js_1.logger.info(`Page source captured in ${Date.now() - startTime}ms`);
         }
         if (!pageSource) {
             throw new Error("Unable to capture DOM");
@@ -249,12 +462,11 @@ async function getAnnotatedDOMForMobile(driver, existingDom) {
         const serializer = new xmldom_1.XMLSerializer();
         let annotatedXML = serializer.serializeToString(xmlDoc);
         // Preserve XML declaration if present
-        if (pageSource.trim().startsWith("<?xml")) {
+        if (pageSource.trim().startsWith("<?xml") &&
+            !annotatedXML.trim().startsWith("<?xml")) {
             const declarationEnd = pageSource.indexOf("?>");
-            if (declarationEnd !== -1) {
-                const declaration = pageSource.substring(0, declarationEnd + 2).trim();
-                annotatedXML = `${declaration}\n${annotatedXML}`;
-            }
+            const declaration = pageSource.substring(0, declarationEnd + 2).trim();
+            annotatedXML = `${declaration}\n${annotatedXML}`;
         }
         return {
             dom: annotatedXML

package/dist/utils/InstancesDetails/getInstancesInfo.d.ts

@@ -1 +1,26 @@
-export declare function getAiInstanceInfo(responseObject: any): Record<string, string>;
+export interface GoogleServiceAccount {
+    type: string;
+    project_id: string;
+    private_key_id: string;
+    private_key: string;
+    client_email: string;
+    client_id: string;
+    auth_uri: string;
+    token_uri: string;
+    auth_provider_x509_cert_url: string;
+    client_x509_cert_url: string;
+    universe_domain: string;
+}
+export interface AIInstanceInfo {
+    serviceProvider: string;
+    apiKey: string;
+    apiUrl: string;
+    visionApiKey: string;
+    model: string;
+    resource: string;
+    accountType: string;
+    enterpriseConfigFile: GoogleServiceAccount;
+    projectId: string;
+    region: string;
+}
+export declare function getAiInstanceInfo(responseObject: any): AIInstanceInfo;

package/dist/utils/InstancesDetails/getInstancesInfo.js

@@ -4,10 +4,16 @@ exports.getAiInstanceInfo = getAiInstanceInfo;
 function getAiInstanceInfo(responseObject) {
     return {
         serviceProvider: responseObject.serviceProvider,
-        apiKey: responseObject.instanceDetails.apiKey,
-        apiUrl: responseObject.instanceDetails.apiUrl,
-        visionApiKey: responseObject?.instanceDetails?.visionApiKey,
-        model: responseObject.model,
-        resource: responseObject.resource ?? null,
+        apiKey: responseObject.instanceDetails?.apiKey,
+        apiUrl: responseObject.instanceDetails?.apiUrl,
+        visionApiKey: responseObject.serviceProvider === "DefaultFireFlink" ? responseObject.visionKey : "",
+        model: responseObject.serviceProvider === "DefaultFireFlink"
+            ? "openai/gpt-oss-20b"
+            : responseObject.model,
+        resource: responseObject.resourceName ?? null,
+        accountType: responseObject.accountType ?? null,
+        enterpriseConfigFile: responseObject.enterpriseConfigFile ?? null,
+        projectId: responseObject.enterpriseConfigFile?.project_id ?? null,
+        region: responseObject.region ?? null,
     };
 }

package/dist/utils/browserCap/capability.d.ts

@@ -1,22 +1,26 @@
 import { BrowserId } from "../../core/types/browserType.js";
-export declare function getCapabilities(browserName: BrowserId): {
-    'goog:chromeOptions'?: {
-        args: string[];
-    } | undefined;
+export declare function getCapabilities(browserName: BrowserId, path?: string, profile?: string, customCaps?: string[]): {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
-} | {
-    'moz:firefoxOptions'?: {
+    "goog:chromeOptions": {
         args: string[];
-    } | undefined;
+        prefs: Record<string, any>;
+    };
+} | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
-} | {
-    'ms:edgeOptions'?: {
+    acceptInsecureCerts: boolean;
+    "moz:firefoxOptions": {
         args: string[];
-    } | undefined;
+        prefs: Record<string, any>;
+    };
+} | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;
+    "ms:edgeOptions": {
+        args: string[];
+        prefs: Record<string, any>;
+    };
 } | {
     browserName: string;
     "wdio:enforceWebDriverClassic": boolean;

package/dist/utils/browserCap/capability.js

@@ -1,35 +1,116 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCapabilities = getCapabilities;
-function getCapabilities(browserName) {
+function getCapabilities(browserName, path, profile, customCaps = []) {
     const isLinux = process.platform === 'linux';
+    const caps = customCaps.map(c => c.toLowerCase());
+    const hasCap = (name) => caps.includes(name.toLowerCase());
+    const getChromiumArgs = (isEdge) => {
+        const args = [
+            ...(path ? [`--user-data-dir=${path}`] : []),
+            ...(profile ? [`--profile-directory=${profile}`] : []),
+            ...(isLinux ? ['--ozone-platform=x11'] : []),
+        ];
+        if (hasCap("headless"))
+            args.push('--headless=new');
+        if (hasCap("incognito"))
+            args.push(isEdge ? '--inprivate' : '--incognito');
+        if (hasCap("ignoreCertificates"))
+            args.push('--ignore-certificate-errors');
+        if (hasCap("startMaximized"))
+            args.push('--start-maximized');
+        if (hasCap("disableGpu"))
+            args.push('--disable-gpu');
+        if (hasCap("disableNotifications"))
+            args.push('--disable-notifications');
+        if (hasCap("disableExtensions"))
+            args.push('--disable-extensions');
+        if (hasCap("disablePopups"))
+            args.push('--disable-popup-blocking');
+        if (hasCap("muteAudio"))
+            args.push('--mute-audio');
+        if (hasCap("noSandbox"))
+            args.push('--no-sandbox', '--disable-dev-shm-usage');
+        if (hasCap("disableWebSecurity"))
+            args.push('--disable-web-security');
+        if (hasCap("disableLocalNetwork"))
+            args.push('--disable-local-network-saving-common-name');
+        return args;
+    };
+    const getChromiumPrefs = () => {
+        const prefs = {};
+        if (hasCap("geolocation"))
+            prefs["profile.default_content_setting_values.geolocation"] = 2;
+        if (hasCap("camera"))
+            prefs["profile.default_content_setting_values.media_stream_camera"] = 2;
+        if (hasCap("microphone"))
+            prefs["profile.default_content_setting_values.media_stream_mic"] = 2;
+        if (hasCap("popups") || hasCap("disablePopups"))
+            prefs["profile.default_content_settings.popups"] = 0;
+        if (hasCap("passwordManager")) {
+            prefs["credentials_enable_service"] = false;
+            prefs["profile.password_manager_enabled"] = false;
+        }
+        return prefs;
+    };
+    const getFirefoxOptions = () => {
+        const args = [
+            ...(path ? ['-profile', path] : []),
+            ...(isLinux ? ['--ozone-platform=x11'] : []),
+        ];
+        if (hasCap("headless"))
+            args.push('-headless');
+        if (hasCap("incognito"))
+            args.push('-private');
+        if (hasCap("disableGpu"))
+            args.push('--disable-gpu');
+        if (hasCap("disableExtensions"))
+            args.push('-safe-mode');
+        const prefs = {};
+        if (hasCap("disableNotifications") || hasCap("notifications"))
+            prefs["dom.webnotifications.enabled"] = false;
+        if (hasCap("disablePopups") || hasCap("popups"))
+            prefs["dom.disable_open_during_load"] = false;
+        if (hasCap("muteAudio"))
+            prefs["media.volume_scale"] = "0.0";
+        if (hasCap("disableWebSecurity"))
+            prefs["security.fileuri.strict_origin_policy"] = false;
+        if (hasCap("geolocation"))
+            prefs["geo.enabled"] = false;
+        if (hasCap("camera"))
+            prefs["media.navigator.permission.disabled"] = true;
+        if (hasCap("microphone"))
+            prefs["media.peerconnection.enabled"] = false;
+        if (hasCap("passwordManager"))
+            prefs["signon.rememberSignons"] = false;
+        return { args, prefs };
+    };
+    const firefoxOptions = getFirefoxOptions();
     const browserCapabilities = {
         chrome: {
             browserName: 'chrome',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'goog:chromeOptions': {
-                    args: ['--ozone-platform=x11']
-                },
-            })
+            "goog:chromeOptions": {
+                args: getChromiumArgs(false),
+                prefs: getChromiumPrefs()
+            },
         },
         firefox: {
             browserName: 'firefox',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'moz:firefoxOptions': {
-                    args: ['--ozone-platform=x11']
-                }
-            })
+            acceptInsecureCerts: hasCap("ignoreCertificates"),
+            "moz:firefoxOptions": {
+                args: firefoxOptions.args,
+                prefs: firefoxOptions.prefs
+            },
         },
         edge: {
             browserName: 'MicrosoftEdge',
             "wdio:enforceWebDriverClassic": true,
-            ...(isLinux && {
-                'ms:edgeOptions': {
-                    args: ['--ozone-platform=x11']
-                }
-            })
+            "ms:edgeOptions": {
+                args: getChromiumArgs(true),
+                prefs: getChromiumPrefs()
+            },
         },
         safari: {
             browserName: 'safari',

package/dist/utils/frameWorkDetector/frameWorkDetector.d.ts

@@ -0,0 +1,6 @@
+import { frameWorkDetectorInterface } from "./frameWorkDetectorInterface.js";
+export declare class frameWorkDetector {
+    static detectFramework(driver: any): Promise<frameWorkDetectorInterface>;
+    static isAngular(driver: any): Promise<boolean>;
+    static isReact(driver: any): Promise<boolean>;
+}