ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.2

package/dist/core/constants/supportedActions.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELEMENTLESS_ACTION = exports.SKIPPED_ACTIONS = exports.INPUTLESS_ACTIONS = void 0;
+exports.INPUTLESS_ACTIONS = [
+    "open",
+    "openApp",
+    "navigateBack",
+    "refresh",
+    "navigate",
+    "maximize",
+    "minimize",
+    "close",
+    "closeApp",
+    "switchToAndroid",
+    "switchToWeb"
+];
+exports.SKIPPED_ACTIONS = [
+    "VerifyIfBrowserWindowIsClosed",
+    "VerifyAllBrowserWindowsClosed",
+];
+exports.ELEMENTLESS_ACTION = [
+    "Sleep",
+    "MOB_VerifyIfAppIsClosed",
+    "SwitchToNewTabBasedOnTitle",
+    "SwitchToNewTabBasedOnUrl",
+    "SwitchToNewWindowBasedOnTitle",
+    "SwitchToNewWindowBasedOnURL",
+    "SwitchToParentWindow",
+    "SwitchToWindowIfTitleContainsString",
+    "SwitchToNewWindowIfUrlContainsString",
+    "ScrollPageToSpecificLocation",
+    "GetPageTitle",
+    "GetBrowserVersion",
+    "GetAllWindowHandles",
+    "GetCurrentWindowHandle",
+    "GetURLPresentInAddressBar",
+    "GetHTMLCodeOfPage",
+    "GetHeightOfBrowserWindow",
+    "GetWidthOfBrowser",
+    "GetXLocationOfBrowserWindow",
+    "GetYLocationOfBrowserWindow",
+    "GetBrowserCount",
+    "GetImplicitTimeOut",
+    "GetDriverInstance",
+    "GetAllConsoleWarnings",
+    "GetAllConsoleInformation",
+    "GetAllConsoleErrors",
+    "GetAllConsoleLogs",
+    "GetAllCookieValues",
+    "GetAllCookieNames",
+    "GetTotalNumberOfCookies",
+    "GetClipBoardText",
+    "GetCurrentSystemDate",
+    "GetCurrentDayOfTheWeek",
+    "GetCurrentSystemTime",
+    "GetCurrentSecondsFromCurrentSystemTime",
+    "GetCurrentSystemYear",
+    "GetHourFromCurrentSystemTime",
+    "GetMinuteFromCurrentSystemTime",
+    "GetCurrentSystemMonth",
+    "GetCurrentSystemDay",
+    "GetNumberOfLinksPresentInCurrentPage",
+    "GetNumberOfWorkingLinksFromCurrentPage",
+    "GetSizeOfBrowserWindow",
+    "BrowserWindowGetPosition",
+    "GetFullPaintTime",
+    "GetFirstContentfulPaint",
+    "GetLargestContentfulPaint",
+    "GetNetworkRouteTime",
+    "GetPerformanceMetrics",
+    "GetUserHomeDirectory",
+    "ConcatString",
+    "GetLastModifiedFile",
+    "VerifyPDF",
+    "VerifyPDFExist",
+    "MOB_GetCurrentWindowHandle",
+    "MOB_GetDriverInstance",
+    "MOB_GetADBLogsForGivenAppPackage",
+    "MOB_GetAllContexts",
+    "MOB_GetAllWindowHandles",
+    "MOB_GetDeviceLocation",
+    "MOB_GetBatteryPercentage",
+    "MOB_GetLongitude",
+    "MOB_GetLatitude",
+    "MOB_GetCurrentDeviceDate",
+    "MOB_GetMinuteFromCurrentDeviceTime",
+    "MOB_GetCurrentAppPackage",
+    "MOB_GetHourFromCurrentDeviceTime",
+    "MOB_GetSecondFromCurrentDeviceTime",
+    "MOB_GetSupportedPerformanceDataTypes",
+    "MOB_GetCurrentOrientation",
+    "MOB_GetCurrentDeviceTime",
+    "MOB_GetCurrentContext",
+    "MOB_GetCurrentDeviceSettings",
+    "MOB_GetClipBoardText",
+    "MOB_GetCurrentDeviceStatus",
+    "MOB_GetSizeOfScreen",
+    "MOB_GetWidthOfScreen",
+    "MOB_GetBatteryStatus",
+    "MOB_GetCurrentActivity",
+    "MOB_GetDeviceOsVersion",
+    "MOB_GetDeviceUdid",
+    "MOB_GetDeviceName",
+    "MOB_GetCurrentSessionId",
+    "MOB_GetHeightOfScreen",
+    "MOB_GetAltitude",
+    "MOB_GetCurrentDeviceSystemBars",
+    "MOB_VerifyIfAirplaneModeOn",
+    "MOB_VerifyIfGpsOn",
+    "MOB_VerifyIfGpsOff",
+    "MOB_VerifyIfAirplaneModeOff",
+    "MOB_VerifyIfDeviceIsLocked",
+    "MOB_VerifyIfWifiOn",
+    "MOB_VerifyIfDeviceIsUnlocked",
+    "MOB_VerifyIfWifiOff",
+    "MOB_VerifyIfKeyboardIsShown",
+    "MOB_VerifyIfKeyboardIsHidden",
+    "MOB_VerifyBatteryLevel",
+    "VerifyElementIsNotDisplayed",
+    "MOB_SetContext",
+    "MOB_SetDeviceOrientationAsLandscape",
+    "MOB_SetEmulatorPowerPercentage",
+    "MOB_SetEmulatorPowerStateOn",
+    "MOB_SetEmulatorPowerStateOff",
+    "MOB_WaitTillAllElementsAreInvisible",
+    "MOB_PressBackKey",
+    "GetScreenshot",
+    "EnterURL",
+    "PressAnyKeyNTimes",
+    "SetClipBoardText",
+    "PressAnyKey",
+    "PressEnterKey",
+    "MOB_RunAppInBackground",
+    "MOB_PressBackSpaceKey",
+    "MOB_PressSpaceKey",
+    "MOB_RunAppInBackground",
+    "MOB_DoubleTapAtSpecifiedLocation",
+    // "MOB_WaitTillPresenceOfElement",
+    "MOB_WaitTillPresenceOfAllElements",
+    "MOB_OpenNotification",
+    "MOB_GetImplicitTimeOut",
+    "MOB_ResetApp",
+    "MOB_HideKeyboard",
+    "MOB_OpenChromeBrowser",
+    "MOB_SetDeviceOrientationAsPortrait",
+    "MOB_AirplaneModeSwitchOn",
+    "MOB_LockDevice",
+    "MOB_WifiSwitchOff",
+    "MOB_WifiSwitchOn",
+    "Continue",
+    "MOB_GpsSwitchOn",
+    "MOB_GpsSwitchOff",
+    "MOB_RestartCurrentDevice",
+    "MOB_AirplaneModeSwitchOff",
+    "Break",
+    "MOB_TapOnSpecifiedLocation",
+    "MOB_PressHomeKey",
+    "MOB_OpenMobileApplication",
+    "MOB_IsAppInstalled",
+    "MOB_ReceiveMessageOnEmulator",
+    "MOB_UninstallAPK",
+    "MOB_InstallAPK",
+    "MOB_TerminateAppUsingAppPackage",
+    "MOB_OpenAppWithApkFilePath",
+    "MOB_ActivateAppUsingAppPackage",
+    "VerifyLighthouseScore",
+    "VerifyAccessibilityScore",
+    "VerifyBrowserWindowYLocation",
+    "VerifyBrowserWindowXLocation",
+    "VerifyBrowserWindowWidth",
+    "VerifyBrowserWindowUrlIsString",
+    "VerifyUrlIsString",
+    "VerifyBrowserWindowUrlContainsExpectedUrl",
+    "VerifyBrowserWindowTitleIsString",
+    "VerifyBrowserWindowTitleContainsString",
+    "VerifyBrowserWindowHeight",
+    "VerifyBrowserHtmlCodeContainsString",
+    "VerifyBestPracticesScore",
+    "VerifyAllBrokenImages",
+    "VerifyIfCookieNameIsDeleted",
+    "VerifyIfCookieNameIsAdded",
+    "VerifyIfAllCookiesAreDeleted",
+    "VerifyIfCookieObjectIsPresent",
+    "VerifyIfImageIsBroken",
+    "VerifyIfLinkIsBroken",
+    "VerifyIfLinkIsWorking",
+    "VerifyIfLinksAreBroken",
+    "VerifyIfLinksAreWorking",
+    "VerifyIfStatusCodeOfALinkIsStatusCode",
+    "VerifyIfStatusCodeOfAllLinksIsStatusCode",
+    "VerifyLinkNavigatesToTitle",
+    "VerifyNavigateURL",
+    "VerifyNumberOfElementsByTagName",
+    "VerifyNumberOfElementsByXpath",
+    "VerifyPartialTitleOfCurrentPage",
+    "VerifyPerformanceScore",
+    "VerifyPwaScore",
+    "VerifySeoScore",
+    "VerifyTitleInAllPage",
+    "VerifyTitleOfCurrentPage",
+    "VerifyHexCodeForGivenXYCoordinates",
+    "GetSystemProperty",
+    "GetValueOfSystemVariable",
+    "GetStringDataFromLocalFile",
+    "GetValueFromXmlPath",
+    "GetAllBrokenImages",
+    "GetAllBrokenLinkCount",
+    "GetAllBrokenLinks",
+    "GetBestPracticesScore",
+    "GetCapabilityNames",
+    "GetCollectiveApiResponseTime",
+    "GetCollectiveApiStatusCode",
+    "GetDataFromApiRequestHeaderForJsonPath",
+    "GetDataFromApiResponseForJsonPath",
+    "GetDateWithGivenFormat",
+    "GetListOfElementsFromLocatorTypeLocatorValue",
+    "GetNumberOfBrokenImages",
+    "GetPwaScore",
+    "GetSeoScore",
+    "GetSingleApiRequestPayload",
+    "GetSingleApiResponse",
+    "GetSingleApiResponseTime",
+    "GetSingleApiStatusCode",
+    "GetTextPresentOnAlertPopup",
+    "GetTunnelIdentifier",
+    "GetValueByCookieName",
+    "GetValueFromLocalStorage",
+    "GetWorkingLinksFromCurrentPage",
+    "MOB_GetAltitude",
+    "MouseClickOnCurrentCursorPoint",
+    "MouseDoubleClickAtCursorPoint",
+    "MouseClickOnCurrentCursorPointNTimes",
+    "getOtp",
+    "arithmetic",
+];

package/dist/core/helpers/elementSelectorResolver.d.ts

@@ -0,0 +1,13 @@
+import { platform as PlatformType } from "../types/scriptTypesType.js";
+import { ShadowIframeResult } from "../interfaces/automationRunnerInterface.js";
+import { FrameMeta } from "../../utils/iframesExtraction/iframeInterface.js";
+import { findCrossOriginIframeForElement } from "../../utils/crossOrigin/crossOriginHelper.js";
+export { ShadowIframeResult, FrameMeta, findCrossOriginIframeForElement };
+export declare function generateUniqueName(currentName: string | undefined, usedNames: string[], suffix?: string): string | undefined;
+export declare function normalizeSvgSelector(selector: string): string;
+export declare function resolveElementSelector(doc: any, domInfo: any, fireflinkIndex: string, platform: PlatformType, driver: any, fallbackAttempt: number, driverContext?: any): Promise<{
+    selector: string;
+    doc: any;
+    domInfo: any;
+}>;
+export declare function handleShadowAndIframe(driver: any, stepAction: string, selector: string, fireflinkIndex: string, domInfo: any, actionHandlers: Record<string, any>, elementName: string, elementType: string, usedElementNames?: string[], skipRecording?: boolean): Promise<ShadowIframeResult>;

package/dist/core/helpers/elementSelectorResolver.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCrossOriginIframeForElement = void 0;
+exports.generateUniqueName = generateUniqueName;
+exports.normalizeSvgSelector = normalizeSvgSelector;
+exports.resolveElementSelector = resolveElementSelector;
+exports.handleShadowAndIframe = handleShadowAndIframe;
+const xpathcreation_js_1 = require("../../utils/helpers/xpathcreation.js");
+const jsForAttributeInjection_js_1 = require("../../utils/DomExtraction/jsForAttributeInjection.js");
+const jsFindElement_js_1 = require("../../utils/javascript/jsFindElement.js");
+const runnerDomPipeline_js_1 = require("./runnerDomPipeline.js");
+const logData_js_1 = require("../../utils/logger/logData.js");
+const crossOriginHelper_js_1 = require("../../utils/crossOrigin/crossOriginHelper.js");
+Object.defineProperty(exports, "findCrossOriginIframeForElement", { enumerable: true, get: function () { return crossOriginHelper_js_1.findCrossOriginIframeForElement; } });
+function generateUniqueName(currentName, usedNames, suffix) {
+    if (!currentName) {
+        return currentName;
+    }
+    const baseName = suffix ? `${currentName}${suffix}` : currentName;
+    let newName = baseName;
+    let count = 0;
+    while (usedNames.includes(newName)) {
+        count++;
+        newName = `${baseName}_${count}`;
+    }
+    usedNames.push(newName);
+    return newName;
+}
+function normalizeSvgSelector(selector) {
+    if (selector.includes("svg")) {
+        const match = /svg\[(\d+)\]/.exec(selector);
+        const svgIndex = match ? match[1] : "1";
+        return selector.replace(/svg\[\d+\]/, `*[name()='svg'][${svgIndex}]`);
+    }
+    return selector;
+}
+async function resolveElementSelector(doc, domInfo, fireflinkIndex, platform, driver, fallbackAttempt, driverContext) {
+    let selector;
+    let updatedDoc = doc;
+    let updatedDomInfo = domInfo;
+    if (platform === "web" || (driverContext && fallbackAttempt > 1)) {
+        if (!updatedDoc) {
+            logData_js_1.logger.info("doc is undefined. Rebuilding document from domInfo.");
+            if (!updatedDomInfo || !updatedDomInfo.dom) {
+                updatedDomInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+            }
+            updatedDoc = runnerDomPipeline_js_1.RunnerDomPipeline.parseDomDocument(updatedDomInfo.dom, "web");
+        }
+        const ele = updatedDoc.querySelector(`[ff-inspect="${fireflinkIndex}"]`);
+        if (ele) {
+            selector = ele.getAttribute("ff-xpath") || "";
+        }
+        else {
+            const result = (0, xpathcreation_js_1.getWebXPathByFFIndex)(updatedDomInfo.dom, fireflinkIndex);
+            selector = result.xpathPath;
+        }
+    }
+    else {
+        const result = await (0, xpathcreation_js_1.getFFIndexAndXPath)(updatedDomInfo.dom, fireflinkIndex);
+        selector = result.xpathPath;
+    }
+    selector = normalizeSvgSelector(selector);
+    selector = selector.replace(/\/div\[0\]\/div\[0\]/g, "/div[1]").replace(/\/div\[0\]/g, "/div[1]");
+    return { selector, doc: updatedDoc, domInfo: updatedDomInfo };
+}
+async function handleShadowAndIframe(driver, stepAction, selector, fireflinkIndex, domInfo, actionHandlers, elementName, elementType, usedElementNames, skipRecording) {
+    let updatedStepAction = stepAction;
+    let updatedSelector = selector;
+    let iframeDomHtml = null;
+    if (updatedSelector.includes("shadow")) {
+        updatedStepAction = updatedStepAction + "_shadow";
+        logData_js_1.logger.info(updatedStepAction);
+    }
+    else {
+        const crossOriginInfo = (0, crossOriginHelper_js_1.findCrossOriginIframeForElement)(domInfo?.dom, fireflinkIndex);
+        if (crossOriginInfo && crossOriginInfo.frameMeta) {
+            const frameHandler = actionHandlers["switchToFrame"];
+            await frameHandler({
+                selector: updatedSelector,
+                frames: [crossOriginInfo.frameMeta],
+                elementName,
+                elementType,
+                pageDOM: domInfo.dom,
+                fireflinkIndex,
+                usedElementNames,
+                skipRecording,
+            });
+            return {
+                stepAction: updatedStepAction,
+                selector: updatedSelector,
+                iframeDomHtml: crossOriginInfo.iframeDom || null,
+                handled: true,
+                isIframe: true,
+            };
+        }
+        else if (updatedSelector.includes("iframe")) {
+            const result_if = await driver.executeAsyncScript(jsFindElement_js_1.Find_element_by_ff_js_script, [fireflinkIndex]);
+            if (!result_if?.success) {
+                logData_js_1.logger.info("Not found");
+                return {
+                    stepAction: updatedStepAction,
+                    selector: updatedSelector,
+                    iframeDomHtml: null,
+                    handled: false,
+                    isIframe: false,
+                };
+            }
+            const { xpath_if, frames, iframe_dom_html } = result_if;
+            updatedSelector = xpath_if;
+            iframeDomHtml = iframe_dom_html;
+            const frameHandler = actionHandlers["switchToFrame"];
+            await frameHandler({
+                selector: updatedSelector,
+                frames: frames,
+                elementName,
+                elementType,
+                pageDOM: domInfo.dom,
+                fireflinkIndex,
+                usedElementNames,
+                skipRecording,
+            });
+            return {
+                stepAction: updatedStepAction,
+                selector: updatedSelector,
+                iframeDomHtml,
+                handled: true,
+                isIframe: true,
+            };
+        }
+    }
+    return {
+        stepAction: updatedStepAction,
+        selector: updatedSelector,
+        iframeDomHtml,
+        handled: true,
+        isIframe: false,
+    };
+}

package/dist/core/helpers/mobileSwipeHelper.d.ts

@@ -0,0 +1,3 @@
+import { MobileSwipeSliderParams, MobileSwipeSliderResult } from "../interfaces/mobileSwipeSliderInterface.js";
+export { MobileSwipeSliderParams, MobileSwipeSliderResult };
+export declare function checkMobileSwipeSlider(params: MobileSwipeSliderParams): Promise<MobileSwipeSliderResult>;

package/dist/core/helpers/mobileSwipeHelper.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMobileSwipeSlider = checkMobileSwipeSlider;
+const annotatedScreenshotMobile_js_1 = require("../../imageAnalysisMobile/annotatedScreenshotMobile.js");
+const jsForAttributeInjection_js_1 = require("../../utils/DomExtraction/jsForAttributeInjection.js");
+const promptType_js_1 = require("../types/promptType.js");
+const xpathcreation_js_1 = require("../../utils/helpers/xpathcreation.js");
+async function checkMobileSwipeSlider(params) {
+    const { driver, currentPlatform, stepAction, step, stepProcessor, priorAndNextSteps, } = params;
+    let domInfo = params.domInfo;
+    const doc = params.doc;
+    if (stepAction !== "MOB_SwipeToElement" || (currentPlatform !== "android" && currentPlatform !== "ios")) {
+        return { isSlider: false, domInfo, doc };
+    }
+    if (!domInfo?.dom) {
+        domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOMForMobile)(driver);
+    }
+    let visionAnnotationResult;
+    if (currentPlatform === "android") {
+        visionAnnotationResult = await (0, annotatedScreenshotMobile_js_1.annotateScreenshot)(driver, domInfo.dom);
+    }
+    else if (currentPlatform === "ios") {
+        visionAnnotationResult = await (0, annotatedScreenshotMobile_js_1.annotateIosScreenshot)(driver, domInfo.dom);
+    }
+    const stepResultVision = await stepProcessor.getLLMResponse({
+        platform: currentPlatform,
+        type: promptType_js_1.PromptType.SWIPE_VISION_PROMPT,
+        args: { priorAndNextSteps },
+        input: {
+            currentStep: step,
+            annotatedScreenshot: visionAnnotationResult?.boxedImageBuffer,
+        },
+        isVision: true,
+    });
+    const NormalSwipe = stepResultVision.response.NormalSwipe;
+    const parentIndex = stepResultVision.response.parentIndex || stepResultVision.response.fireflinkIndex;
+    const targetIndex = stepResultVision.response.targetIndex || stepResultVision.response.fireflinkIndex;
+    const direction = stepResultVision.response.direction?.toLowerCase()?.trim() || "right";
+    if (!NormalSwipe &&
+        parentIndex &&
+        targetIndex &&
+        parentIndex !== "Fire-Flink-0" &&
+        targetIndex !== "Fire-Flink-0") {
+        const bounds = visionAnnotationResult?.boxes;
+        const resolveBoundsAndXpath = (idxStr) => {
+            const idxNum = Number(idxStr.split("-").pop());
+            const box = bounds?.[idxNum - 1];
+            if (!box) {
+                throw new Error(`No bounds found for index ${idxStr} (${idxNum})`);
+            }
+            const { x1, y1, x2, y2 } = box;
+            const boundsStr = `[${x1},${y1}][${x2},${y2}]`;
+            const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(domInfo.dom, boundsStr, currentPlatform);
+            if (!result.xpathPath) {
+                throw new Error(`Unable to resolve xpath for element ${idxStr}`);
+            }
+            return {
+                xpath: result.xpathPath,
+                resolvedIndex: result.ffInspector ?? idxStr,
+            };
+        };
+        const parentResult = resolveBoundsAndXpath(parentIndex);
+        const targetResult = resolveBoundsAndXpath(targetIndex);
+        return {
+            isSlider: true,
+            parentXpath: parentResult.xpath,
+            targetXpath: targetResult.xpath,
+            sliderXpath: targetResult.xpath,
+            parentIndex: parentResult.resolvedIndex,
+            targetIndex: targetResult.resolvedIndex,
+            fireflinkIndex: targetResult.resolvedIndex,
+            direction,
+            domInfo,
+            doc,
+        };
+    }
+    return { isSlider: false, domInfo, doc };
+}

package/dist/core/helpers/runnerDomPipeline.d.ts

@@ -0,0 +1,9 @@
+import { DomProcessingEngine } from "../../domAnalysis/getRelaventElements.js";
+import { platform as PlatformType } from "../types/scriptTypesType.js";
+import { DomCaptureResult, DomProcessResult } from "../interfaces/automationRunnerInterface.js";
+export { DomCaptureResult, DomProcessResult };
+export declare class RunnerDomPipeline {
+    static parseDomDocument(domHtml: string, platform: PlatformType): any;
+    static captureAndParseDom(driver: any, platform: PlatformType, stepCount: number, action: string, isRetry?: boolean, driverContext?: any): Promise<DomCaptureResult>;
+    static processRelevantDom(domProcessor: DomProcessingEngine, domInfo: any, keywords: any, stepCount: number, action: string, currentStep: string, platform: PlatformType, driver: any, isRetry?: boolean, driverContext?: any): Promise<DomProcessResult>;
+}

package/dist/core/helpers/runnerDomPipeline.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerDomPipeline = void 0;
+const jsdom_1 = require("jsdom");
+const toon_1 = require("@toon-format/toon");
+const jsForAttributeInjection_js_1 = require("../../utils/DomExtraction/jsForAttributeInjection.js");
+const domSanitizer_js_1 = require("../../utils/helpers/domSanitizer.js");
+const logData_js_1 = require("../../utils/logger/logData.js");
+class RunnerDomPipeline {
+    static parseDomDocument(domHtml, platform) {
+        if (platform === "web") {
+            const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domHtml));
+            return parser.window.document;
+        }
+        else {
+            const parser = new jsdom_1.JSDOM(domHtml, {
+                contentType: "text/xml",
+            });
+            return parser.window.document;
+        }
+    }
+    static async captureAndParseDom(driver, platform, stepCount, action, isRetry = false, driverContext) {
+        try {
+            let domInfo;
+            let doc;
+            if (platform === "web") {
+                domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                const fileName = isRetry
+                    ? `annotated-dom-retry-${stepCount}`
+                    : `annotated-dom-${stepCount}`;
+                logData_js_1.logger.saveDOM(domInfo.dom, fileName);
+                doc = RunnerDomPipeline.parseDomDocument(domInfo.dom, "web");
+            }
+            else {
+                if (driverContext) {
+                    await driver.switchContext(driverContext);
+                    domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                    const fileName = isRetry
+                        ? `annotated-dom-retry-webview-${stepCount}`
+                        : `annotated-dom-${stepCount}`;
+                    logData_js_1.logger.saveDOM(domInfo.dom, fileName);
+                    doc = RunnerDomPipeline.parseDomDocument(domInfo.dom, "web");
+                }
+                else {
+                    domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOMForMobile)(driver);
+                    const fileName = isRetry
+                        ? `annotated-dom-Mob-retry-${stepCount}`
+                        : `annotated-dom-Mob-${stepCount}`;
+                    logData_js_1.logger.saveDOM(domInfo.dom, fileName);
+                    doc = RunnerDomPipeline.parseDomDocument(domInfo.dom, platform);
+                }
+            }
+            return { domInfo, doc };
+        }
+        catch (error) {
+            if (action === "verify") {
+                return { domInfo: null, doc: null };
+            }
+            throw error;
+        }
+    }
+    static async processRelevantDom(domProcessor, domInfo, keywords, stepCount, action, currentStep, platform, driver, isRetry = false, driverContext) {
+        try {
+            let extractedRelevantDom;
+            let toonDom;
+            if (platform === "web" || driverContext) {
+                extractedRelevantDom = await domProcessor.webProcess({
+                    keywords: keywords,
+                    rawDom: domInfo?.dom,
+                    stepCount: stepCount,
+                    stepAction: action,
+                    step: currentStep,
+                    platform: platform,
+                    driver: driver,
+                });
+                toonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                const fileName = isRetry
+                    ? `relevant-dom-toon-retry-${stepCount}`
+                    : `relevant-dom-toon-${stepCount}`;
+                logData_js_1.logger.saveText(toonDom, fileName);
+            }
+            else {
+                extractedRelevantDom = await domProcessor.mobileProcess({
+                    keywords: keywords,
+                    rawDom: domInfo?.dom,
+                    stepCount: stepCount,
+                    stepAction: action,
+                    step: currentStep,
+                    platform: platform,
+                    driver: driver,
+                });
+                toonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                const fileName = isRetry
+                    ? `relevant-dom-toon-Mob-retry-${stepCount}`
+                    : `relevant-dom-toon-Mob-${stepCount}`;
+                logData_js_1.logger.saveText(toonDom, fileName);
+            }
+            return { extractedRelevantDom, toonDom };
+        }
+        catch (error) {
+            if (action === "verify") {
+                return { extractedRelevantDom: null, toonDom: undefined };
+            }
+            throw error;
+        }
+    }
+}
+exports.RunnerDomPipeline = RunnerDomPipeline;

package/dist/core/helpers/runnerKafkaReporter.d.ts

@@ -0,0 +1,17 @@
+import { fireflinkService } from "../../service/fireflink.service.js";
+import { AutomationRequest } from "../interfaces/executionDetails.js";
+import { IKafkaPayload } from "../interfaces/fireflinkScriptPayloadInterface.js";
+export declare class RunnerKafkaReporter {
+    private fireflinkServiceInstance;
+    private request;
+    constructor(fireflinkServiceInstance: fireflinkService, request: AutomationRequest);
+    sendLiveLog(message: any, messageType: string): Promise<void>;
+    sendOngoing(message: string): Promise<void>;
+    sendRetry(message: string): Promise<void>;
+    sendTermination(): Promise<void>;
+    sendError(errorDescription?: string): Promise<void>;
+    sendExecutionStopped(): Promise<void>;
+    sendNextBatch(): Promise<void>;
+    sendCompleted(): Promise<void>;
+    sendMetadata(kafkaPayload: IKafkaPayload): Promise<void>;
+}

package/dist/core/helpers/runnerKafkaReporter.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerKafkaReporter = void 0;
+const messageType_js_1 = require("../types/messageType.js");
+const logData_js_1 = require("../../utils/logger/logData.js");
+class RunnerKafkaReporter {
+    constructor(fireflinkServiceInstance, request) {
+        this.fireflinkServiceInstance = fireflinkServiceInstance;
+        this.request = request;
+    }
+    async sendLiveLog(message, messageType) {
+        await this.fireflinkServiceInstance.produceMessageToKafka(this.request.kafkaMessageKey, {
+            topic: this.request.topic,
+            message: {
+                topic: "",
+                service: "",
+                chatId: "",
+                aiPromptPayload: {
+                    display: false,
+                    message: "",
+                    messageId: "",
+                    branchId: "",
+                    userId: this.request.userId,
+                    scriptId: "",
+                    scriptType: "",
+                    type: "logs",
+                    sessionId: "",
+                    licenseId: this.request.licenseId,
+                    projectId: this.request.projectId,
+                    liveLogs: {
+                        executionId: this.request.kafkaMessageKey,
+                        message,
+                        messageType,
+                    },
+                    attachment: [],
+                },
+            },
+        });
+    }
+    async sendOngoing(message) {
+        await this.sendLiveLog(message, messageType_js_1.MessageType.LiveLog.Ongoing);
+        logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Ongoing })}`);
+    }
+    async sendRetry(message) {
+        await this.sendLiveLog(message, messageType_js_1.MessageType.LiveLog.retry);
+    }
+    async sendTermination() {
+        logData_js_1.logger.info(`Execution terminated successfully. Script: ${this.request.scriptName}, Test Case ID: ${this.request.testCaseId}`);
+        await this.sendLiveLog("Execution terminated by the user", messageType_js_1.MessageType.LiveLog.Termination);
+    }
+    async sendError(errorDescription) {
+        await this.sendLiveLog(errorDescription ?? "errorDescription unknown", messageType_js_1.MessageType.LiveLog.Error);
+        logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Error })}`);
+    }
+    async sendExecutionStopped() {
+        await this.sendLiveLog("Execution stopped", messageType_js_1.MessageType.LiveLog.ExecutionStopped);
+        logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.ExecutionStopped })}`);
+    }
+    async sendNextBatch() {
+        await this.sendLiveLog("Invoke the generate_script_from_scenario tool with the remaining test steps to continue the automation execution from where it left off.", messageType_js_1.MessageType.nextBatch);
+        logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.nextBatch })}`);
+    }
+    async sendCompleted() {
+        await this.sendLiveLog("Execution completed", messageType_js_1.MessageType.LiveLog.Completed);
+        logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Completed })}`);
+    }
+    async sendMetadata(kafkaPayload) {
+        await this.sendLiveLog(kafkaPayload, messageType_js_1.MessageType.AutomationScriptMetaData);
+    }
+}
+exports.RunnerKafkaReporter = RunnerKafkaReporter;