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

package/dist/core/main/runAutomationScript.js

@@ -0,0 +1,878 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationRunner = void 0;
+require("../../utils/sslConfig/apiCallPatch.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const platformContext_js_1 = require("../../utils/helpers/platformContext.js");
+const llmConfiguration_js_1 = require("../../llmConfig/llmConfiguration.js");
+const llmAction_js_1 = require("../../ai/llmcalls/llmAction.js");
+const actionHandlerFactory_js_1 = require("../../core/main/actionHandlerFactory.js");
+const stepProcessor_js_1 = require("./stepProcessor.js");
+const fireflinkApi_service_js_1 = require("../../service/api/fireflinkApi.service.js");
+const fireflink_service_js_1 = require("../../service/fireflink.service.js");
+const promptType_js_1 = require("../types/promptType.js");
+const supportedActions_js_1 = require("../constants/supportedActions.js");
+const getRelaventElements_js_1 = require("../../domAnalysis/getRelaventElements.js");
+const allAction_js_1 = require("../constants/allAction.js");
+const newTabTracker_js_1 = require("../../utils/newTab/newTabTracker.js");
+const getInstancesInfo_js_1 = require("../../utils/InstancesDetails/getInstancesInfo.js");
+const isAlertPresent_js_1 = require("../../utils/alertPopup/isAlertPresent.js");
+const logData_js_1 = require("../../utils/logger/logData.js");
+const sameActionsHelper_js_1 = require("../../utils/helpers/sameActionsHelper.js");
+const messageType_js_1 = require("../types/messageType.js");
+const driverState_js_1 = require("../../automation/driverState.js");
+const SessionManager_js_1 = require("./SessionManager.js");
+const runnerKafkaReporter_js_1 = require("../helpers/runnerKafkaReporter.js");
+const runnerDomPipeline_js_1 = require("../helpers/runnerDomPipeline.js");
+const stepActionInspector_js_1 = require("../helpers/stepActionInspector.js");
+const elementSelectorResolver_js_1 = require("../helpers/elementSelectorResolver.js");
+const runnerPostActionHelper_js_1 = require("../helpers/runnerPostActionHelper.js");
+const visionFallbackHandler_js_1 = require("../helpers/visionFallbackHandler.js");
+const mobileSwipeHelper_js_1 = require("../helpers/mobileSwipeHelper.js");
+class AutomationRunner {
+    constructor() {
+        this.KafkaPayload = {};
+    }
+    static getSessionTerminationInfo(testCaseId) {
+        return AutomationRunner.sessionTerminationDetails[testCaseId];
+    }
+    static updateSessionTerminationInfo(testCaseId) {
+        AutomationRunner.sessionTerminationDetails[testCaseId] = true;
+    }
+    static sessionName(testCaseId, sessionName) {
+        AutomationRunner.sessionNames[testCaseId] = sessionName;
+    }
+    static getSessionName(testCaseId) {
+        return AutomationRunner.sessionNames[testCaseId];
+    }
+    static resolveDetectedPlatform(detectedPlatform, previousPlatform) {
+        const value = (detectedPlatform ?? "").trim().toLowerCase();
+        if (value === "ios")
+            return "ios";
+        if (value === "android")
+            return "android";
+        if (value === "web")
+            return "web";
+        if (previousPlatform)
+            return previousPlatform;
+        return "web";
+    }
+    static normalizeScriptType(scriptType) {
+        const rawValue = (scriptType ?? "Web").trim();
+        if (!rawValue) {
+            return "Web";
+        }
+        const value = rawValue.toLowerCase();
+        if (value.includes("web") && value.includes("android")) {
+            return "Web";
+        }
+        if (value.includes("android") && value.includes("ios")) {
+            return "Android";
+        }
+        if (value.includes("android")) {
+            return "Android";
+        }
+        if (value.includes("ios")) {
+            return "iOS";
+        }
+        if (value.includes("web")) {
+            return "Web";
+        }
+        return "Web";
+    }
+    async cleanup(context, domInfo, extractedRelevantDom, stepProcessor, stepsInputData, fireflinkServiceInstance, request, currentPlatform) {
+        try {
+            logData_js_1.logger.info("Starting cleanup process...");
+            domInfo = null;
+            extractedRelevantDom = null;
+            stepsInputData.length = 0;
+            try {
+                if (context?.session) {
+                    const webDriver = await context.session.getCurrentDriver().catch(() => null);
+                    if (webDriver?.sessionId) {
+                        if (request.isCloud) {
+                            await webDriver.deleteSession();
+                            logData_js_1.logger.info("Cloud web session deleted successfully");
+                        }
+                        else {
+                            logData_js_1.logger.info("Local web session kept alive.");
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logData_js_1.logger.error("Error closing Web session:", err);
+            }
+            try {
+                if (context?.mobileSession) {
+                    const mobileDriver = await context.mobileSession.getCurrentDriver().catch(() => null);
+                    if (mobileDriver?.sessionId) {
+                        if (request.isCloud) {
+                            if (currentPlatform === "ios") {
+                                logData_js_1.logger.info("iOS session is not deleted");
+                            }
+                            else {
+                                await mobileDriver.deleteSession();
+                                logData_js_1.logger.info("Mobile session deleted successfully");
+                            }
+                        }
+                        else {
+                            logData_js_1.logger.info("Local mobile session kept alive.");
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logData_js_1.logger.error("Error closing Mobile session:", err);
+            }
+            if (stepProcessor) {
+                stepProcessor.llm = null;
+            }
+            fireflinkServiceInstance = null;
+            delete AutomationRunner.sessionTerminationDetails[request.testCaseId];
+            try {
+                const tempFileDir = path_1.default.resolve(process.cwd(), "session", "tempFile");
+                if (fs_1.default.existsSync(tempFileDir)) {
+                    fs_1.default.rmSync(tempFileDir, { recursive: true, force: true });
+                    logData_js_1.logger.info(`Cleaned up tempFile directory: ${tempFileDir}`);
+                }
+            }
+            catch (err) {
+                logData_js_1.logger.error("Error cleaning up tempFile directory:", err);
+            }
+            if (global.gc) {
+                global.gc();
+            }
+            logData_js_1.logger.info("Cleanup completed successfully.");
+        }
+        catch (error) {
+            logData_js_1.logger.error("Cleanup error:", error);
+        }
+    }
+    async saveSessionStepData(context, kafkaMessageKey) {
+        await context.scriptAppender.waitForAllSteps();
+        if (driverState_js_1.UserSessionAutomationTestCase[kafkaMessageKey]) {
+            driverState_js_1.UserSessionAutomationTestCase[kafkaMessageKey].push(...context.scriptAppender.getData());
+        }
+        else {
+            driverState_js_1.UserSessionAutomationTestCase[kafkaMessageKey] = context.scriptAppender.getData();
+        }
+        context.scriptAppender.reset();
+    }
+    async run(request) {
+        const usedElementNames = [];
+        const usedVariableNames = [];
+        (0, logData_js_1.initLogger)(request.sessionPath);
+        const isMultichannel = request.type?.toLowerCase().includes("Multi-Channel");
+        if (!isMultichannel) {
+            request.platform = AutomationRunner.normalizeScriptType(request.platform);
+        }
+        const isWebMobile = isMultichannel ||
+            (request.type?.toLowerCase().includes("web") &&
+                request.type?.toLowerCase().includes("android")) ||
+            (request.type?.toLowerCase() === "android");
+        logData_js_1.logger.info("User Given Step", request.userStory);
+        const hasMoreSteps = request.hasMoreSteps;
+        if (!request.isTerminate)
+            AutomationRunner.sessionName(request.testCaseId, request.scriptName);
+        if (request.isTerminate) {
+            return AutomationRunner.updateSessionTerminationInfo(request.testCaseId);
+        }
+        AutomationRunner.sessionTerminationDetails[request.testCaseId] = request.isTerminate;
+        const apiService = new fireflinkApi_service_js_1.FireFlinkApiService();
+        const fireflinkServiceInstance = new fireflink_service_js_1.fireflinkService(apiService, request.broker, request.sslConfig);
+        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverHost, request.licenseId);
+        const aiInfo = (0, getInstancesInfo_js_1.getAiInstanceInfo)(instanceDetails.responseObject);
+        let context = SessionManager_js_1.SessionManager.get(request);
+        const hadExistingSession = Boolean(context);
+        if (!context) {
+            context = SessionManager_js_1.SessionManager.create(request);
+        }
+        const configProvider = new llmConfiguration_js_1.ServiceProviderProviderConfiguration();
+        const provider = await configProvider.getProvider(aiInfo);
+        let domInfo = null;
+        let extractedRelevantDom = null;
+        let errorInfo = {};
+        const llm = new llmAction_js_1.llmAction(aiInfo.apiKey, provider, aiInfo.model, aiInfo.visionApiKey, aiInfo.accountType, aiInfo.enterpriseConfigFile, aiInfo.serviceProvider);
+        let preCapturedDomInfo = null;
+        const stepProcessor = new stepProcessor_js_1.StepProcessor(llm);
+        let currentPlatform = context.activePlatform;
+        (0, platformContext_js_1.setPlatform)(currentPlatform);
+        let previousDetectedPlatform = isMultichannel && hadExistingSession ? context.activePlatform : undefined;
+        const actionHandlers = (0, actionHandlerFactory_js_1.createActionHandlers)(context);
+        const domProcessor = new getRelaventElements_js_1.DomProcessingEngine();
+        let stepCount = 1;
+        const stepsInputData = context.stepsInputData || (context.stepsInputData = []);
+        const listOfSteps = request.userStory.map((step) => String(step));
+        context.allManualSteps.push(...listOfSteps);
+        let driver;
+        if (listOfSteps.length === 0 && request?.aiExecutionAction !== "stopExecution") {
+            logData_js_1.logger.info(listOfSteps);
+            throw new Error("No executable manual steps were returned by the LLM.");
+        }
+        if (aiInfo.serviceProvider === "DefaultFireFlink") {
+            logData_js_1.logger.info("Service Provider --> DefaultFireFlink");
+        }
+        else {
+            logData_js_1.logger.info(`Service Provider --> ${aiInfo.serviceProvider} and Model --> ${aiInfo.model}`);
+        }
+        const reporter = new runnerKafkaReporter_js_1.RunnerKafkaReporter(fireflinkServiceInstance, request);
+        const startTime = new Date().getTime();
+        for (const [index, step] of listOfSteps.entries()) {
+            currentPlatform = context.activePlatform;
+            (0, platformContext_js_1.setPlatform)(currentPlatform);
+            let stepResult;
+            let driverContext = null;
+            let stepAction;
+            let fireflinkIndex;
+            let selector;
+            let doc;
+            let pageDOM;
+            let beforeHandles = null;
+            let baseStepActionBeforeFallback;
+            let inputValue;
+            try {
+                if (request?.aiExecutionAction === "stopExecution") {
+                    break;
+                }
+                if (AutomationRunner.getSessionTerminationInfo(request.testCaseId)) {
+                    await reporter.sendTermination();
+                    break;
+                }
+                const userStepIndex = index + 1;
+                logData_js_1.logger.info(`Processing step ${userStepIndex}: ${step}`);
+                const start = Math.max(0, index - 3);
+                const end = Math.min(listOfSteps.length, index + 4);
+                const priorAndNextSteps = listOfSteps.slice(start, end);
+                const result = isMultichannel
+                    ? await stepProcessor.getLLMResponse({
+                        platform: currentPlatform || "web",
+                        type: promptType_js_1.PromptType.MULTICHANNEL_KEYWORD_EXTRACTOR,
+                        args: {
+                            priorAndNextSteps,
+                            allSteps: context.allManualSteps,
+                            previousPlatform: previousDetectedPlatform ?? null,
+                        },
+                        input: { currentStep: step },
+                    })
+                    : await stepProcessor.getLLMResponse({
+                        platform: currentPlatform,
+                        type: promptType_js_1.PromptType.KEYWORD_EXTRACTOR,
+                        args: { priorAndNextSteps },
+                        input: { currentStep: step },
+                    });
+                if (isMultichannel) {
+                    const firstStepPlatform = AutomationRunner.resolveDetectedPlatform(result.response?.steps?.[0]?.platform ?? result.response?.platform, previousDetectedPlatform);
+                    currentPlatform = firstStepPlatform;
+                    previousDetectedPlatform = firstStepPlatform;
+                    context.activePlatform = firstStepPlatform;
+                    context.request.platform = firstStepPlatform;
+                    (0, platformContext_js_1.setPlatform)(firstStepPlatform);
+                }
+                if (currentPlatform === "android" || currentPlatform === "ios") {
+                    let mobileDriver = null;
+                    try {
+                        mobileDriver = await context.mobileSession.getCurrentDriver();
+                    }
+                    catch {
+                        mobileDriver = null;
+                    }
+                    if (!mobileDriver) {
+                        const initialKeywords = result.response?.keywords ||
+                            (Array.isArray(result.response?.steps) ? result.response.steps[0]?.keywords : undefined);
+                        await context.initializeMobileDriver(initialKeywords);
+                    }
+                }
+                const stepsArray = Array.isArray(result.response?.steps)
+                    ? result.response.steps
+                    : result.response?.action
+                        ? [result.response]
+                        : null;
+                if (!stepsArray || stepsArray.length === 0) {
+                    throw new Error(`No steps returned from action extractor for step: ${step}`);
+                }
+                const isOneToMany = stepsArray.length > 1;
+                for (let i = 0; i < stepsArray.length; i++) {
+                    const stepObj = stepsArray[i];
+                    const action = stepObj.action;
+                    const keywords = stepObj.keywords;
+                    if (isMultichannel) {
+                        const stepPlatform = AutomationRunner.resolveDetectedPlatform(stepObj.platform, previousDetectedPlatform);
+                        currentPlatform = stepPlatform;
+                        previousDetectedPlatform = stepPlatform;
+                        context.activePlatform = stepPlatform;
+                        context.request.platform = stepPlatform;
+                        (0, platformContext_js_1.setPlatform)(stepPlatform);
+                        await context.syncExecutorToActivePlatform();
+                    }
+                    const currentStep = action?.toLowerCase() === "getotp" ? step : stepObj.step || step;
+                    let currentElementName = stepObj.elementName;
+                    let currentVariableName;
+                    let currentReturnTypeVariableName;
+                    const liveLog = stepObj.liveLog;
+                    const isStepValueDependable = stepObj.isStepValueDependable;
+                    const currentStepIndex = isOneToMany ? `${userStepIndex}.${i + 1}` : userStepIndex;
+                    logData_js_1.logger.info(isOneToMany
+                        ? `Sub-step ${currentStepIndex}: ${currentStep}`
+                        : `Step ${currentStepIndex}: ${currentStep}`);
+                    stepsInputData.currentManualStep = step;
+                    stepsInputData.currentStepIndex = currentStepIndex;
+                    context.executor?.setStepContext(currentStepIndex, currentStep, stepsInputData, step);
+                    logData_js_1.logger.info("stepsInputData", stepsInputData);
+                    const inputContextPromise = action !== "arithmetic" && isStepValueDependable && stepsInputData.length > 0
+                        ? stepProcessor.getLLMResponse({
+                            platform: currentPlatform,
+                            type: promptType_js_1.PromptType.INPUT_CONTEXT_PROMPT,
+                            args: { inputStepsContext: stepsInputData },
+                            input: { currentStep },
+                        })
+                        : null;
+                    await reporter.sendOngoing(liveLog);
+                    if (request.scenario && action === "enter") {
+                        const currentUserStoryStep = request.userStory[index];
+                        if (currentUserStoryStep &&
+                            currentUserStoryStep.length > 1 &&
+                            typeof currentUserStoryStep[1] === "string" &&
+                            currentUserStoryStep[1].trim() === "") {
+                            throw new Error(`Input is missing for the given step: ${currentUserStoryStep?.[0]}. Please provide the input.`);
+                        }
+                    }
+                    if (action === "notwebopenaction") {
+                        throw new Error(`Selected platform is invalid for the step: ${step}`);
+                    }
+                    if (!allAction_js_1.allKeywordAction.includes(action)) {
+                        throw new Error(`Unsupported action at action or keyword extractor: ${action}`);
+                    }
+                    let handler = actionHandlers[action];
+                    if (supportedActions_js_1.INPUTLESS_ACTIONS.includes(action)) {
+                        logData_js_1.logger.info(`Keywords ${JSON.stringify(keywords)}`);
+                        await handler({ keywords, step: currentStep, driverSession: request.kafkaMessageKey });
+                        stepCount++;
+                        continue;
+                    }
+                    if (action === "arithmetic") {
+                        const arithmeticResult = await stepProcessor.getLLMResponse({
+                            platform: currentPlatform,
+                            type: promptType_js_1.PromptType.ARITHMETIC_PROMPT,
+                            args: {
+                                inputStepsContext: isStepValueDependable ? stepsInputData : [],
+                            },
+                            input: { currentStep },
+                        });
+                        let targetVarName = arithmeticResult?.response?.variableName?.trim() || "";
+                        if (targetVarName) {
+                            targetVarName = (0, elementSelectorResolver_js_1.generateUniqueName)(targetVarName, usedVariableNames);
+                        }
+                        handler = actionHandlers["arithmetic"];
+                        await handler({
+                            operandOne: arithmeticResult?.response?.operandOne,
+                            operandTwo: arithmeticResult?.response?.operandTwo,
+                            operandOneVariableName: arithmeticResult?.response?.operandOneVariableName,
+                            operandTwoVariableName: arithmeticResult?.response?.operandTwoVariableName,
+                            operation: arithmeticResult?.response?.operation,
+                            variableName: targetVarName,
+                            returnTypeVariableName: targetVarName,
+                            stepIndex: currentStepIndex,
+                            currentStep,
+                            manualStep: step,
+                            stepsInputData,
+                        });
+                        stepCount++;
+                        continue;
+                    }
+                    if (action === "getOtp") {
+                        if (!isWebMobile) {
+                            throw new Error(`Selected platform is invalid for the step: ${step}`);
+                        }
+                        stepResult = await stepProcessor.getLLMResponse({
+                            platform: currentPlatform,
+                            type: promptType_js_1.PromptType.FF_INSPECTOR,
+                            args: {
+                                stepAction: "getOtp",
+                                extractedDomJson: null,
+                                priorAndNextSteps,
+                                isAlert: false,
+                                isDrag: false,
+                            },
+                            input: { currentStep },
+                        });
+                        if (stepResult?.response?.variableName && stepResult.response.variableName.trim() !== "") {
+                            currentReturnTypeVariableName = (0, elementSelectorResolver_js_1.generateUniqueName)(stepResult.response.variableName.trim(), usedVariableNames);
+                        }
+                        const otpAction = currentPlatform === "android" || currentPlatform === "ios"
+                            ? sameActionsHelper_js_1.sameActionHelper[stepResult.response.nlpName] || stepResult.response.nlpName
+                            : stepResult.response.nlpName;
+                        handler = actionHandlers[otpAction];
+                        await handler({
+                            selector: stepResult.response.inputText,
+                            timeFrom: stepResult.response.timeFrom,
+                            waitTime: stepResult.response.waitTime,
+                            activity: stepResult.response.activity,
+                            otpExtractor: async (smsBody) => {
+                                const llmRes = await stepProcessor.getLLMResponse({
+                                    platform: currentPlatform,
+                                    type: promptType_js_1.PromptType.OTP_EXTRACTOR,
+                                    args: {},
+                                    input: { smsBody },
+                                });
+                                return llmRes.response;
+                            },
+                            stepIndex: stepCount,
+                            currentStep,
+                            manualStep: step,
+                            stepsInputData,
+                            returnTypeVariableName: currentReturnTypeVariableName,
+                        });
+                        stepCount++;
+                        if (action?.toLowerCase() === "getotp") {
+                            break;
+                        }
+                        continue;
+                    }
+                    currentElementName = (0, elementSelectorResolver_js_1.generateUniqueName)(currentElementName, usedElementNames);
+                    try {
+                        if (currentPlatform === "web") {
+                            driver = await context.session.getCurrentDriver();
+                        }
+                        else {
+                            driver = await context.mobileSession.getCurrentDriver();
+                            const contexts = await driver.getContexts();
+                            driverContext = contexts.find((context) => String(context).startsWith("WEBVIEW")) || null;
+                        }
+                    }
+                    catch (error) {
+                        if (action === "verify") {
+                            driver = null;
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                    if ((await (0, isAlertPresent_js_1.isAlertPresent)(driver)) && !["wait", "verify"].includes(action)) {
+                        logData_js_1.logger.info("Alert is present");
+                        stepResult = await stepProcessor.getLLMResponse({
+                            platform: currentPlatform,
+                            type: promptType_js_1.PromptType.FF_INSPECTOR,
+                            args: {
+                                stepAction: action,
+                                extractedDomJson: null,
+                                priorAndNextSteps,
+                                isAlert: true,
+                                isDrag: false,
+                            },
+                            input: { currentStep },
+                        });
+                        stepAction = stepResult.response.action;
+                        handler = actionHandlers[stepAction];
+                        await handler({
+                            value: stepResult.response.inputText,
+                        });
+                        stepCount++;
+                        continue;
+                    }
+                    if (preCapturedDomInfo && currentPlatform === "web") {
+                        logData_js_1.logger.info("Using pre-captured DOM from previous toaster detection");
+                        domInfo = preCapturedDomInfo;
+                        preCapturedDomInfo = null;
+                        doc = runnerDomPipeline_js_1.RunnerDomPipeline.parseDomDocument(domInfo.dom, "web");
+                    }
+                    else {
+                        const domResult = await runnerDomPipeline_js_1.RunnerDomPipeline.captureAndParseDom(driver, currentPlatform, stepCount, action, false, driverContext);
+                        domInfo = domResult.domInfo;
+                        doc = domResult.doc;
+                    }
+                    const relevantDomResult = await runnerDomPipeline_js_1.RunnerDomPipeline.processRelevantDom(domProcessor, domInfo, keywords, stepCount, action, currentStep, currentPlatform, driver, false, driverContext);
+                    extractedRelevantDom = relevantDomResult.extractedRelevantDom;
+                    const toonDom = relevantDomResult.toonDom;
+                    const actionResolution = await (0, stepActionInspector_js_1.resolveStepActionFromDom)(stepProcessor, currentPlatform, action, toonDom, priorAndNextSteps, currentStep, stepObj.fileType ?? null);
+                    stepResult = actionResolution.stepResult;
+                    stepAction = actionResolution.stepAction;
+                    if (stepResult?.response?.variableName && stepResult.response.variableName.trim() !== "") {
+                        currentReturnTypeVariableName = (0, elementSelectorResolver_js_1.generateUniqueName)(stepResult.response.variableName.trim(), usedVariableNames);
+                    }
+                    const inputContextResult = inputContextPromise ? await inputContextPromise : null;
+                    const inputText = inputContextResult?.response?.inputText;
+                    if (inputContextResult?.response?.variableName && inputContextResult.response.variableName.trim() !== "") {
+                        currentVariableName = inputContextResult.response.variableName.trim();
+                    }
+                    if (action === "verify") {
+                        inputValue = stepResult?.response?.inputText;
+                    }
+                    else {
+                        inputValue =
+                            inputText && inputText.trim().length > 0
+                                ? inputText
+                                : stepResult?.response?.inputText;
+                    }
+                    if (supportedActions_js_1.SKIPPED_ACTIONS.includes(stepAction)) {
+                        handler = actionHandlers[stepAction];
+                        await handler();
+                        stepCount++;
+                        continue;
+                    }
+                    if (currentPlatform === "web") {
+                        beforeHandles = await driver.getWindowHandles();
+                    }
+                    if (supportedActions_js_1.ELEMENTLESS_ACTION.includes(stepAction)) {
+                        const currentDriver = currentPlatform === "web"
+                            ? await context.session.getCurrentDriver()
+                            : await context.mobileSession.getCurrentDriver();
+                        handler = actionHandlers[stepAction];
+                        if (stepAction === "getOtp") {
+                            await handler({
+                                selector: stepResult.response.inputText,
+                                activity: stepResult.response.activity,
+                                isTerminated: () => AutomationRunner.getSessionTerminationInfo(request.testCaseId),
+                                otpExtractor: async (smsBody) => {
+                                    const llmRes = await stepProcessor.getLLMResponse({
+                                        platform: currentPlatform,
+                                        type: promptType_js_1.PromptType.OTP_EXTRACTOR,
+                                        args: {},
+                                        input: { smsBody },
+                                    });
+                                    return llmRes.response;
+                                },
+                                stepIndex: currentStepIndex,
+                                currentStep,
+                                manualStep: step,
+                                stepsInputData,
+                                returnTypeVariableName: currentReturnTypeVariableName,
+                            });
+                            stepCount++;
+                            continue;
+                        }
+                        await handler({
+                            value: inputValue,
+                            selector: stepResult.response.attributeValue,
+                            elementName: currentElementName || result.response.elementName,
+                            elementType: stepResult.response.elementType,
+                            stepIndex: currentStepIndex,
+                            currentStep,
+                            manualStep: step,
+                            stepsInputData,
+                            returnTypeVariableName: currentReturnTypeVariableName,
+                            isDownload: stepResult.response.isDownload,
+                            path: stepResult.response.path,
+                            ...(currentVariableName ? { variableName: currentVariableName } : {}),
+                        });
+                        if (currentDriver && currentPlatform === "web") {
+                            await (0, newTabTracker_js_1.newTabTracker)(currentDriver, action, beforeHandles, context.scriptAppender);
+                        }
+                        stepCount++;
+                        continue;
+                    }
+                    baseStepActionBeforeFallback = stepAction;
+                    let iframeSwitchRecorded = false;
+                    for (let fallbackAttempt = 1; fallbackAttempt <= 2; fallbackAttempt++) {
+                        let shadowIframeResult = null;
+                        try {
+                            let iframeDomHtml = null;
+                            if (fallbackAttempt > 1) {
+                                logData_js_1.logger.info(`Waiting 5 seconds before retrying step "${step}". Attempt ${fallbackAttempt}`);
+                                await new Promise((resolve) => setTimeout(resolve, 5000));
+                                logData_js_1.logger.info(`Retrying step "${step}" after vision fallback failure. Attempt ${fallbackAttempt}`);
+                                stepAction = baseStepActionBeforeFallback;
+                                selector = "";
+                                iframeDomHtml = null;
+                                beforeHandles = null;
+                                const retryDomResult = await runnerDomPipeline_js_1.RunnerDomPipeline.captureAndParseDom(driver, currentPlatform, stepCount, action, true, driverContext);
+                                domInfo = retryDomResult.domInfo;
+                                doc = retryDomResult.doc;
+                                const retryRelevantResult = await runnerDomPipeline_js_1.RunnerDomPipeline.processRelevantDom(domProcessor, domInfo, keywords, stepCount, action, currentStep, currentPlatform, driver, true, driverContext);
+                                extractedRelevantDom = retryRelevantResult.extractedRelevantDom;
+                                const retryToonDom = retryRelevantResult.toonDom;
+                                const retryActionResolution = await (0, stepActionInspector_js_1.resolveStepActionFromDom)(stepProcessor, currentPlatform, action, retryToonDom, priorAndNextSteps, currentStep, null);
+                                stepResult = retryActionResolution.stepResult;
+                                stepAction = retryActionResolution.stepAction;
+                            }
+                            const swipeVisionResult = await (0, mobileSwipeHelper_js_1.checkMobileSwipeSlider)({
+                                driver,
+                                currentPlatform,
+                                stepAction,
+                                step,
+                                domInfo,
+                                doc,
+                                stepProcessor,
+                                priorAndNextSteps,
+                                fallbackAttempt,
+                                driverContext,
+                            });
+                            domInfo = swipeVisionResult.domInfo;
+                            doc = swipeVisionResult.doc;
+                            if (swipeVisionResult.isSlider) {
+                                handler = actionHandlers["MOB_SwipeSlider"];
+                                await handler({
+                                    parentXpath: swipeVisionResult.parentXpath,
+                                    targetXpath: swipeVisionResult.targetXpath,
+                                    xpath: swipeVisionResult.targetXpath,
+                                    selector: swipeVisionResult.targetXpath,
+                                    parentIndex: swipeVisionResult.parentIndex,
+                                    targetIndex: swipeVisionResult.targetIndex,
+                                    fireflinkIndex: swipeVisionResult.targetIndex,
+                                    direction: swipeVisionResult.direction,
+                                    currentStep: step,
+                                    elementName: currentElementName || result.response.elementName,
+                                    elementType: stepResult.response.elementType || stepResult.response.type,
+                                    pageDOM: domInfo.dom,
+                                    currentPlatform,
+                                    driver,
+                                    driverContext,
+                                    priorAndNextSteps,
+                                    stepCount,
+                                    stepIndex: currentStepIndex,
+                                    manualStep: step,
+                                    stepsInputData,
+                                    returnTypeVariableName: currentReturnTypeVariableName,
+                                    ...(currentVariableName ? { variableName: currentVariableName } : {}),
+                                });
+                                break;
+                            }
+                            if (stepAction === "Builtin_DragAndDropToElement") {
+                                handler = actionHandlers[stepAction];
+                                const fireflinkIndex1 = stepResult.response.drag;
+                                const ele1 = doc.querySelector(`[ff-inspect="${fireflinkIndex1}"]`);
+                                const selector1 = ele1?.getAttribute("ff-xpath");
+                                const fireflinkIndex2 = stepResult.response.drop;
+                                const ele2 = doc.querySelector(`[ff-inspect="${fireflinkIndex2}"]`);
+                                const selector2 = ele2?.getAttribute("ff-xpath");
+                                if (!selector2 && !selector1) {
+                                    throw new Error(`Unable to resolve xpath for ${fireflinkIndex2}`);
+                                }
+                                else if (fireflinkIndex2 === "Fire-Flink-0" && fireflinkIndex1 === "Fire-Flink-0") {
+                                    throw new Error(`Unable to find element for ${step}`);
+                                }
+                                await handler({
+                                    selector1,
+                                    selector2,
+                                    fireflinkIndex1,
+                                    fireflinkIndex2,
+                                    pageDOM: domInfo.dom,
+                                    elementName1: stepResult.response.drag_element_name,
+                                    elementName2: stepResult.response.drop_element_name,
+                                    elementType1: stepResult.response.drag_element_type,
+                                    elementType2: stepResult.response.drop_element_type,
+                                });
+                                break;
+                            }
+                            fireflinkIndex = stepResult.response.attributeValue;
+                            if (fireflinkIndex === "Fire-Flink-0") {
+                                logData_js_1.logger.error(`element not found for step "${step}"`);
+                                throw new Error(`element not found for step "${step}"`);
+                            }
+                            const selectorResult = await (0, elementSelectorResolver_js_1.resolveElementSelector)(doc, domInfo, fireflinkIndex, currentPlatform, driver, fallbackAttempt, driverContext);
+                            selector = selectorResult.selector;
+                            doc = selectorResult.doc;
+                            domInfo = selectorResult.domInfo;
+                            if (!selector) {
+                                logData_js_1.logger.info(`Unable to resolve xpath for ${fireflinkIndex}`);
+                                throw new Error(`Unable to resolve xpath for ${fireflinkIndex}`);
+                            }
+                            shadowIframeResult = await (0, elementSelectorResolver_js_1.handleShadowAndIframe)(driver, stepAction, selector, fireflinkIndex, domInfo, actionHandlers, currentElementName || result.response.elementName, stepResult.response.elementType, usedElementNames, iframeSwitchRecorded);
+                            if (shadowIframeResult?.isIframe) {
+                                iframeSwitchRecorded = true;
+                            }
+                            if (!shadowIframeResult.handled) {
+                                return;
+                            }
+                            stepAction = shadowIframeResult.stepAction;
+                            selector = shadowIframeResult.selector;
+                            iframeDomHtml = shadowIframeResult.iframeDomHtml;
+                            pageDOM = iframeDomHtml ?? domInfo.dom;
+                            handler = actionHandlers[stepAction];
+                            await handler({
+                                nlpName: stepResult.response.nlpName,
+                                selector,
+                                value: inputValue,
+                                fireflinkIndex,
+                                pageDOM,
+                                elementName: currentElementName || result.response.elementName,
+                                elementType: stepResult.response.elementType || stepResult.response.type,
+                                numOfScrolls: stepResult.response.numOfScrolls,
+                                direction: stepResult.response.direction,
+                                stepIndex: currentStepIndex,
+                                filteredSteps: listOfSteps,
+                                attributeType: stepResult.response.attributeType,
+                                currentStep,
+                                manualStep: step,
+                                stepsInputData,
+                                returnTypeVariableName: currentReturnTypeVariableName,
+                                ...(currentVariableName ? { variableName: currentVariableName } : {}),
+                            });
+                            if (shadowIframeResult?.isIframe) {
+                                const defaultHandler = actionHandlers["switchToDefaultContent"];
+                                if (defaultHandler) {
+                                    await defaultHandler({ driver });
+                                }
+                            }
+                            preCapturedDomInfo = await (0, runnerPostActionHelper_js_1.handlePostActionWeb)(currentPlatform, driver, action, beforeHandles, context.scriptAppender, stepCount);
+                            if (fallbackAttempt === 2) {
+                                if (driverContext) {
+                                    await driver.switchContext("NATIVE_APP");
+                                }
+                                await reporter.sendRetry("Retry successful. Moving on to the next step.");
+                            }
+                            break;
+                        }
+                        catch (error) {
+                            if (shadowIframeResult?.isIframe && driver) {
+                                try {
+                                    await driver.switchFrame(null);
+                                }
+                                catch {
+                                    /* ignore */
+                                }
+                            }
+                            const visionResult = await (0, visionFallbackHandler_js_1.executeVisionFallback)({
+                                driver,
+                                platform: currentPlatform,
+                                action,
+                                step,
+                                stepAction,
+                                inputValue,
+                                stepCount,
+                                stepIndex: currentStepIndex,
+                                currentStep,
+                                manualStep: step,
+                                stepsInputData,
+                                returnTypeVariableName: currentReturnTypeVariableName,
+                                variableName: currentVariableName,
+                                fallbackAttempt,
+                                priorAndNextSteps,
+                                listOfSteps,
+                                currentElementName,
+                                extractorElementName: result.response.elementName,
+                                stepElementType: stepResult.response.elementType,
+                                iframeDomHtml: null,
+                                domInfo,
+                                doc,
+                                beforeHandles,
+                                context,
+                                stepProcessor,
+                                actionHandlers,
+                                reporter,
+                                causeError: error,
+                                driverContext,
+                            });
+                            if (visionResult.retryNeeded) {
+                                continue;
+                            }
+                            preCapturedDomInfo = visionResult.preCapturedDomInfo;
+                            if (driverContext) {
+                                await driver.switchContext("NATIVE_APP");
+                            }
+                            break;
+                        }
+                    }
+                    baseStepActionBeforeFallback = stepAction;
+                    domInfo = null;
+                    extractedRelevantDom = null;
+                    stepCount++;
+                }
+            }
+            catch (error) {
+                logData_js_1.logger.error(`Error executing step "${step}":`, error);
+                if (error?.error) {
+                    errorInfo.error = error.error;
+                    errorInfo.errorDescription = error.errorDescription;
+                    if (context.scriptAppender.getErrorNLP()) {
+                        errorInfo.nlp = context.scriptAppender.getErrorNLP();
+                    }
+                    errorInfo.errorManualStep = step;
+                    errorInfo.rawError = logData_js_1.logger.getError(error);
+                    break;
+                }
+                errorInfo = (await stepProcessor.getLLMResponse({
+                    platform: currentPlatform,
+                    type: promptType_js_1.PromptType.ERROR_DESCRIPTION,
+                    args: {},
+                    input: { error: logData_js_1.logger.getError(error) },
+                })).response;
+                if (context.scriptAppender.getErrorNLP()) {
+                    errorInfo.nlp = context.scriptAppender.getErrorNLP();
+                }
+                errorInfo.errorManualStep = step;
+                errorInfo.rawError = logData_js_1.logger.getError(error);
+                break;
+            }
+        }
+        logData_js_1.logger.info("execution time->", new Date().getTime() - startTime);
+        const payload = {
+            scriptName: AutomationRunner.getSessionName(request.testCaseId) ?? "SCRIPT_NAME",
+            type: request.type,
+            projectId: request.projectId,
+            testCaseId: request.testCaseId,
+            pageDetails: request.pageDetails,
+            licenseType: request.licenseType,
+            licenseId: request.licenseId,
+            userId: request.userId,
+            projectType: request.projectType,
+            tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
+        };
+        this.KafkaPayload.topic = request.topic;
+        let keepSessionAlive = false;
+        try {
+            if (errorInfo && Object.keys(errorInfo).length > 0) {
+                await reporter.sendError(errorInfo.errorDescription);
+                await this.saveSessionStepData(context, request.kafkaMessageKey);
+                return;
+            }
+            else {
+                if (request?.aiExecutionAction === "stopExecution") {
+                    await reporter.sendExecutionStopped();
+                }
+                else if (hasMoreSteps) {
+                    keepSessionAlive = true;
+                    await reporter.sendNextBatch();
+                    await this.saveSessionStepData(context, request.kafkaMessageKey);
+                }
+                else {
+                    await reporter.sendCompleted();
+                    await this.saveSessionStepData(context, request.kafkaMessageKey);
+                }
+                // Intermediate batches must only emit nextBatch. Sending AutomationScriptMetaData
+                // here races the chat consumer and is treated as a finished execution.
+                if (!keepSessionAlive) {
+                    this.KafkaPayload.message = {
+                        ...payload,
+                        executionId: request.kafkaMessageKey,
+                        liveLogs: messageType_js_1.MessageType.AutomationScriptMetaData,
+                        stepData: driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey],
+                        serverHost: request.serverHost,
+                        messageType: messageType_js_1.MessageType.AutomationScriptMetaData,
+                    };
+                    await reporter.sendMetadata(this.KafkaPayload);
+                    const stepDataArr = this.KafkaPayload.message.stepData;
+                    const lastStep = Array.isArray(stepDataArr) && stepDataArr.length > 0
+                        ? stepDataArr[stepDataArr.length - 1]
+                        : null;
+                    const closeStepNames = new Set(["CloseBrowser", "IOS_CloseApp", "MOB_CloseApp"]);
+                    if (lastStep && closeStepNames.has(lastStep.nlpName)) {
+                        SessionManager_js_1.SessionManager.remove(request);
+                        delete driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey];
+                        logData_js_1.logger.info("Deletion happened.");
+                    }
+                    logData_js_1.logger.info(`Final Message produced to Kafka topic ${JSON.stringify(this.KafkaPayload, null, 2)} successfully.`);
+                }
+                else {
+                    logData_js_1.logger.info("nextBatch produced; session kept alive for remaining steps.");
+                }
+            }
+        }
+        catch (error) {
+            logData_js_1.logger.error("Failed to produce message :", logData_js_1.logger.getError(error));
+            throw new Error("Failed to produce message :", { cause: error });
+        }
+        finally {
+            if (!keepSessionAlive) {
+                await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, stepsInputData, fireflinkServiceInstance, request, currentPlatform);
+            }
+        }
+    }
+}
+exports.AutomationRunner = AutomationRunner;
+AutomationRunner.sessionTerminationDetails = {};
+AutomationRunner.sessionNames = {};