ff-automationv2 2.2.29 → 2.2.30

package/dist/core/main/actionHandlerFactory.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,8 +39,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createActionHandlers = createActionHandlers;
 const executor_js_1 = require("../../automation/actions/executor.js");
 const logData_js_1 = require("../../utils/logger/logData.js");
+const capability_js_1 = require("../../utils/browserCap/capability.js");
 const path_1 = __importDefault(require("path"));
 function createActionHandlers(context) {
+    let isAndroidInitialized = false;
     const requireExecutor = () => {
         if (!context.executor) {
             throw new Error("Browser not initialized.");
@@ -27,85 +62,244 @@ function createActionHandlers(context) {
     return {
         open: async (result) => {
             try {
-                if (result?.keywords?.length > 0 && result?.keywords?.[0].includes("path")) {
-                    let pathValue = result.keywords[0].replace(/^path:/, "");
-                    const profileValue = result.keywords[1]?.replace(/^profile:/, "");
-                    const pathParts = pathValue.split(/[\\/]+/);
+                const keywords = result?.keywords || [];
+                const pathKeyword = keywords.find((k) => k.startsWith("path:"));
+                const profileKeyword = keywords.find((k) => k.startsWith("profile:"));
+                const capsKeywords = keywords
+                    .filter((k) => k.startsWith("caps:"))
+                    .map((k) => k.replace(/^caps:/, ""));
+                let pathValue;
+                let profileValue;
+                if (pathKeyword) {
+                    const rawPath = pathKeyword.replace(/^path:/, "");
+                    const pathParts = rawPath.split(/[\\/]+/);
                     pathValue = path_1.default.join(...pathParts);
-                    await context.session.open(pathValue, profileValue);
+                }
+                if (profileKeyword) {
+                    profileValue = profileKeyword.replace(/^profile:/, "");
+                }
+                await context.session.open(pathValue, profileValue, capsKeywords);
+                context.executor = new executor_js_1.ActionExecutor(await context.session.getCurrentDriver(), context.scriptAppender, context.locator, context.activePlatform, context.adbPath);
+                const rawBrowserName = context.request.browserName.toLowerCase();
+                let resolvedBrowserName = "chrome";
+                if (rawBrowserName.includes("firefox")) {
+                    resolvedBrowserName = "firefox";
+                }
+                else if (rawBrowserName.includes("edge")) {
+                    resolvedBrowserName = "edge";
+                }
+                else if (rawBrowserName.includes("safari")) {
+                    resolvedBrowserName = "safari";
+                }
+                const capsObj = (0, capability_js_1.getCapabilities)(resolvedBrowserName, pathValue, profileValue, capsKeywords);
+                let exactCommands = [];
+                let exactPrefs = {};
+                if (resolvedBrowserName === "chrome") {
+                    exactCommands = capsObj["goog:chromeOptions"]?.args || [];
+                    exactPrefs = capsObj["goog:chromeOptions"]?.prefs || {};
+                }
+                else if (resolvedBrowserName === "edge") {
+                    exactCommands = capsObj["ms:edgeOptions"]?.args || [];
+                    exactPrefs = capsObj["ms:edgeOptions"]?.prefs || {};
+                }
+                else if (resolvedBrowserName === "firefox") {
+                    exactCommands = capsObj["moz:firefoxOptions"]?.args || [];
+                    exactPrefs = capsObj["moz:firefoxOptions"]?.prefs || {};
+                }
+                const prefKeys = Object.keys(exactPrefs);
+                const hasArgs = exactCommands.length > 0;
+                const hasPrefs = prefKeys.length > 0;
+                const isLinux = process.platform === 'linux';
+                if (isLinux && exactCommands.length === 1) {
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "Open Browser",
+                        elementsData: [],
+                        stepInputs: []
+                    }));
                 }
                 else {
-                    await context.session.open();
+                    if (hasArgs || hasPrefs) {
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "BrowserOptionsCreateInstance",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                        if (hasArgs) {
+                            for (const command of exactCommands) {
+                                if (process.platform === 'linux' && /--ozone-platform\b/.test(command)) {
+                                    continue;
+                                }
+                                context.scriptAppender.add(async () => ({
+                                    nlpName: "BrowserOptionsAddArguments",
+                                    elementsData: [],
+                                    stepInputs: [command]
+                                }));
+                            }
+                        }
+                        if (hasPrefs) {
+                            context.scriptAppender.add(async () => ({
+                                nlpName: "MapCreateEmptyMap",
+                                elementsData: [],
+                                stepInputs: []
+                            }));
+                            for (const key of prefKeys) {
+                                const value = exactPrefs[key];
+                                context.scriptAppender.add(async () => ({
+                                    nlpName: "MapPut",
+                                    elementsData: [],
+                                    stepInputs: [key, String(value)]
+                                }));
+                            }
+                            context.scriptAppender.add(async () => ({
+                                nlpName: "BrowserOptionsSetExperimentalOption",
+                                elementsData: [],
+                                stepInputs: ["prefs"]
+                            }));
+                        }
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "OpenBrowser",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                    }
+                    else {
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "Open Browser",
+                            elementsData: [],
+                            stepInputs: []
+                        }));
+                    }
                 }
-                context.executor = new executor_js_1.ActionExecutor(await context.session.getCurrentDriver(), context.scriptAppender, context.locator, context.request.platform, context.adbPath);
-                context.scriptAppender.add(async () => ({
-                    nlpName: "OpenBrowser",
-                    elementsData: [],
-                    stepInputs: []
-                }));
             }
             catch (error) {
                 logData_js_1.logger.error("Error in createActionHandlers", error);
                 throw error;
             }
         },
+        switchToAndroid: async (result) => {
+            try {
+                let androidDriver;
+                try {
+                    androidDriver = await context.mobileSession.getCurrentDriver();
+                }
+                catch {
+                    if (!context.request.isCloud) {
+                        let deviceId = context.request.realDeviceId;
+                        if (!deviceId) {
+                            const { execFileSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
+                            const output = execFileSync(context.adbPath, ["devices"], {
+                                encoding: "utf8",
+                            });
+                            const devices = output
+                                .split("\n")
+                                .slice(1) // Skip "List of devices attached"
+                                .map(line => line.trim())
+                                .filter(line => line.endsWith("\tdevice"));
+                            if (devices.length === 0) {
+                                throw new Error("No Android device connected.");
+                            }
+                            if (devices.length > 1) {
+                                throw new Error("Multiple Android devices connected. Please specify a realDeviceId.");
+                            }
+                            deviceId = devices[0].split("\t")[0];
+                            context.request.realDeviceId = deviceId;
+                        }
+                        logData_js_1.logger.info("Using device:", deviceId);
+                    }
+                    await context.initializeMobileDriver(result.keywords);
+                    androidDriver = await context.mobileSession.getCurrentDriver();
+                }
+                context.executor = new executor_js_1.ActionExecutor(androidDriver, context.scriptAppender, context.locator, "android", context.adbPath);
+                context.activePlatform = "android";
+                if (!isAndroidInitialized) {
+                    isAndroidInitialized = true;
+                    // context.scriptAppender.add(async () => ({
+                    //     nlpName: "CreateCapabilitiesInstance",
+                    //     elementsData: [],
+                    //     stepInputs: []
+                    // }));
+                    // context.scriptAppender.add(async () => ({
+                    //     nlpName: "MOB_OpenMobileApplication",
+                    //     elementsData: [],
+                    //     stepInputs: ["http://localhost:4723/wd/hub", "10", JSON.stringify(capability)]
+                    // }));
+                }
+            }
+            catch (error) {
+                logData_js_1.logger.error("Unable to switch to Android", error);
+                throw error;
+            }
+        },
+        switchToWeb: async () => {
+            try {
+                try {
+                    const webDriver = await context.session.getCurrentDriver();
+                    context.executor = new executor_js_1.ActionExecutor(webDriver, context.scriptAppender, context.locator, "web", context.adbPath);
+                }
+                catch {
+                    logData_js_1.logger.info("Web driver not initialized. Skipping executor creation.");
+                }
+                context.activePlatform = "web";
+            }
+            catch (error) {
+                logData_js_1.logger.error("Unable to switch to web", error);
+                throw error;
+            }
+        },
         openApp: async (result) => {
             try {
                 const isIOS = context.request.platform?.toLowerCase() === "ios";
-                let capabilities;
-                if (isIOS) {
-                    capabilities = {
-                        platformName: "iOS",
-                        "appium:platformVersion": context.request.platformVersion,
-                        "appium:deviceName": "iphone",
-                        "appium:udid": context.request.realDeviceId,
-                        "appium:automationName": "XCUITest",
-                        "appium:bundleId": result.keywords[0],
-                        "appium:shouldUseCompactResponses": true,
-                        "appium:waitForQuiescence": false,
-                        "appium:wdaLaunchTimeout": 300000,
-                        "appium:wdaConnectionTimeout": 300000,
-                        "appium:agentPath": "/Applications/FireFlinkClient.app/Contents/Resources/flinko-client/exec/appium-webdriveragent/WebDriverAgent.xcodeproj",
-                        "appium:bootstrapPath": "/Applications/FireFlinkClient.app/Contents/Resources/flinko-client/exec/appium-webdriveragent",
-                        "appium:noReset": false,
-                        "appium:showXcodeLog": true,
-                        "appium:useNewWDA": true,
-                        "appium:unicodeKeyboard": true,
-                        "appium:resetKeyboard": true,
-                        "appium:ignoreUnimportantViews": true,
-                        "appium:disableWindowAnimation": true,
-                        'appium:newCommandTimeout': 300
-                    };
+                const appPackage = result.keywords
+                    .find((item) => item.startsWith("appPackage:"))
+                    ?.substring("appPackage:".length);
+                const appActivity = result.keywords
+                    .find((item) => item.startsWith("appActivity:"))
+                    ?.substring("appActivity:".length);
+                await context.mobileSession.launchApp(appPackage, appActivity);
+                // Check whether there is any capability other than appPackage/appActivity
+                const hasAdditionalCapabilities = result.keywords.some((item) => !item.startsWith("appPackage:") &&
+                    !item.startsWith("appActivity:"));
+                if (!isIOS && hasAdditionalCapabilities) {
+                    // Create capabilities instance
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "MOB_CreateCapabilitiesInstance",
+                        elementsData: [],
+                        stepInputs: []
+                    }));
+                    // Add every capability, including appPackage and appActivity
+                    for (const capability of result.keywords) {
+                        const [key, ...valueParts] = capability.split(":");
+                        const value = valueParts.join(":");
+                        context.scriptAppender.add(async () => ({
+                            nlpName: "MOB_SetCapability",
+                            elementsData: [],
+                            stepInputs: [key, value]
+                        }));
+                    }
+                    // Open mobile application
+                    context.scriptAppender.add(async () => ({
+                        nlpName: "MOB_OpenMobileApplication",
+                        elementsData: [],
+                        stepInputs: [10]
+                    }));
                 }
                 else {
-                    capabilities = {
-                        platformName: "Android",
-                        "appium:platformVersion": context.request.platformVersion,
-                        "appium:deviceName": "AndroidDevice",
-                        "appium:udid": context.request.realDeviceId,
-                        "appium:automationName": "UiAutomator2",
-                        "appium:ignoreHiddenApiPolicyError": true,
-                        "appium:shouldUseCompactResponses": true,
-                        "appium:ignoreUnimportantViews": false,
-                        "appium:disableAndroidWatcher": true,
-                        "appium:disableWindowAnimation": true,
-                        "appium:uiautomator2ServerLaunchTimeout": 60000,
-                        "appium:uiautomator2ServerReadTimeout": 60000,
-                        "appium:waitForIdleTimeout": 0,
-                        "appium:waitForIdlePollingInterval": 0,
-                        "appium:waitForSelectorTimeout": 0,
-                    };
+                    // Normal flow
+                    context.scriptAppender.add(async () => ({
+                        nlpName: isIOS ? "Open iOS App" : "Open Android App",
+                        elementsData: [],
+                        stepInputs: isIOS
+                            ? [
+                                context.request.realDeviceId,
+                                context.request.platformVersion,
+                                appPackage
+                            ]
+                            : [
+                                appPackage,
+                                appActivity
+                            ]
+                    }));
                 }
-                await context.mobileSession.open({
-                    capabilities: capabilities,
-                    keywords: result.keywords
-                });
-                context.executor = new executor_js_1.ActionExecutor(await context.mobileSession.getCurrentDriver(), context.scriptAppender, context.locator, context.request.platform, context.request.adbPath || "");
-                context.scriptAppender.add(async () => ({
-                    nlpName: isIOS ? "Open iOS App" : "Open Android App",
-                    elementsData: [],
-                    stepInputs: isIOS ? [context.request.realDeviceId, context.request.platformVersion, result.keywords[0]] : [result.keywords[0], result.keywords[1]]
-                }));
             }
             catch (error) {
                 logData_js_1.logger.error("Error in createActionHandlers", error);
@@ -116,7 +310,7 @@ function createActionHandlers(context) {
             try {
                 await context.session.close();
                 context.scriptAppender.add(async () => ({
-                    nlpName: "CloseBrowser",
+                    nlpName: "Close Browser",
                     elementsData: [],
                     stepInputs: []
                 }));
@@ -1243,6 +1437,9 @@ function createActionHandlers(context) {
         }),
         MouseClickOnCurrentCursorPointNTimes: withExecutor(async (executor, result) => {
             await executor.MouseClickOnCurrentCursorPointNTimes(result.value);
+        }),
+        getOtp: withExecutor(async (executor, result) => {
+            await executor.getOtp(result.selector, result.timeFrom, result.waitTime, result.activity, result.otpExtractor);
         })
     };
 }

package/dist/core/main/executionContext.d.ts

@@ -4,13 +4,19 @@ import { ActionExecutor } from "../../automation/actions/executor.js";
 import { ElementGetter } from "../../fireflinkData/fireflinkLocators/getListOfLocators.js";
 import { ScriptDataAppender } from "../../fireflinkData/fireflinkScript/scriptGenrationData.js";
 import { AutomationRequest } from "../interfaces/executionDetails.js";
+import { platform } from "../types/scriptTypesType.js";
+import { LocatorWorkerPool } from "../../utils/workers/LocatorWorkerPool.js";
 export declare class ExecutionContext {
     request: AutomationRequest;
+    workerPool: LocatorWorkerPool;
     session: BrowserSession;
     mobileSession: MobileSession;
     executor: ActionExecutor | null;
     locator: ElementGetter;
     scriptAppender: ScriptDataAppender;
     adbPath: string;
-    constructor(request: AutomationRequest);
+    activePlatform: platform;
+    extractedOtp: string | null;
+    constructor(request: AutomationRequest, workerPool: LocatorWorkerPool);
+    initializeMobileDriver(caps: any): Promise<void>;
 }

package/dist/core/main/executionContext.js

@@ -3,19 +3,109 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionContext = void 0;
 const initiateBrowserSession_js_1 = require("../../automation/browserSession/initiateBrowserSession.js");
 const initiateMobileSession_js_1 = require("../../automation/mobileSession/initiateMobileSession.js");
+const executor_js_1 = require("../../automation/actions/executor.js");
 const getListOfLocators_js_1 = require("../../fireflinkData/fireflinkLocators/getListOfLocators.js");
 const scriptGenrationData_js_1 = require("../../fireflinkData/fireflinkScript/scriptGenrationData.js");
 const defaultValues_js_1 = require("../constants/defaultValues.js");
 const browserType_js_1 = require("../../core/types/browserType.js");
 class ExecutionContext {
-    constructor(request) {
+    constructor(request, workerPool) {
         this.request = request;
+        this.workerPool = workerPool;
         this.executor = null;
-        this.session = new initiateBrowserSession_js_1.BrowserSession(browserType_js_1.browsers[request.browser.browserName], request.isCloud, request.capabilities, defaultValues_js_1.DEFAULT_PAGE_LOAD, request.cloudConfig);
-        this.locator = new getListOfLocators_js_1.ElementGetter();
+        this.extractedOtp = null;
+        this.session = new initiateBrowserSession_js_1.BrowserSession(browserType_js_1.browserName[request.browserName], request.isCloud, request.capabilities, defaultValues_js_1.DEFAULT_PAGE_LOAD, request.cloudConfig);
+        this.locator = new getListOfLocators_js_1.ElementGetter(workerPool);
         this.scriptAppender = new scriptGenrationData_js_1.ScriptDataAppender();
         this.mobileSession = new initiateMobileSession_js_1.MobileSession(request.appiumPort, request.isCloud, request.capabilities, request.cloudConfig, request.adbPath);
         this.adbPath = request.adbPath || "";
+        this.activePlatform = request.platform.toLowerCase();
+    }
+    async initializeMobileDriver(caps) {
+        const isIOS = this.request.platform.toLowerCase() === "ios";
+        const appiumCaps = {};
+        const allowedCapabilities = [
+            "app",
+            "appPackage",
+            "appActivity",
+            "noReset",
+            "fullReset",
+            "autoGrantPermissions"
+        ];
+        let hasAppPackage = false;
+        if (Array.isArray(caps)) {
+            for (const cap of caps) {
+                if (typeof cap !== "string") {
+                    continue;
+                }
+                const [key, ...valueParts] = cap.split(":");
+                const value = valueParts.join(":");
+                if (!allowedCapabilities.includes(key)) {
+                    continue;
+                }
+                if (key === "appActivity" || !value.trim()) {
+                    continue;
+                }
+                if (key === "appPackage") {
+                    hasAppPackage = true;
+                }
+                if (value === "true") {
+                    appiumCaps[`appium:${key}`] = true;
+                }
+                else if (value === "false") {
+                    appiumCaps[`appium:${key}`] = false;
+                }
+                else {
+                    appiumCaps[`appium:${key}`] = value;
+                }
+            }
+        }
+        const capabilities = isIOS
+            ? {
+                platformName: "iOS",
+                "appium:platformVersion": this.request.platformVersion,
+                "appium:deviceName": "iphone",
+                "appium:udid": this.request.realDeviceId,
+                "appium:automationName": "XCUITest",
+                "appium:autoLaunch": false,
+                "appium:shouldUseCompactResponses": true,
+                "appium:waitForQuiescence": false,
+                "appium:wdaLaunchTimeout": 300000,
+                "appium:wdaConnectionTimeout": 300000,
+                "appium:agentPath": "/Applications/FireFlinkClient.app/Contents/Resources/flinko-client/exec/appium-webdriveragent/WebDriverAgent.xcodeproj",
+                "appium:bootstrapPath": "/Applications/FireFlinkClient.app/Contents/Resources/flinko-client/exec/appium-webdriveragent",
+                "appium:noReset": false,
+                "appium:showXcodeLog": true,
+                "appium:useNewWDA": true,
+                "appium:unicodeKeyboard": true,
+                "appium:resetKeyboard": true,
+                "appium:ignoreUnimportantViews": true,
+                "appium:disableWindowAnimation": true,
+                "appium:newCommandTimeout": 300,
+            }
+            : {
+                platformName: "Android",
+                "appium:platformVersion": this.request.platformVersion,
+                "appium:deviceName": "AndroidDevice",
+                "appium:udid": this.request.realDeviceId,
+                "appium:autoLaunch": !hasAppPackage,
+                "appium:automationName": "UiAutomator2",
+                "appium:ignoreHiddenApiPolicyError": true,
+                "appium:shouldUseCompactResponses": true,
+                "appium:ignoreUnimportantViews": false,
+                "appium:disableAndroidWatcher": true,
+                "appium:disableWindowAnimation": true,
+                "appium:uiautomator2ServerLaunchTimeout": 60000,
+                "appium:uiautomator2ServerReadTimeout": 60000,
+                "appium:waitForIdleTimeout": 0,
+                "appium:waitForIdlePollingInterval": 0,
+                "appium:waitForSelectorTimeout": 0,
+                "appium:newCommandTimeout": 600,
+                "appium:noReset": false,
+                ...appiumCaps
+            };
+        await this.mobileSession.createDriver(capabilities);
+        this.executor = new executor_js_1.ActionExecutor(await this.mobileSession.getCurrentDriver(), this.scriptAppender, this.locator, this.request.platform, this.adbPath);
     }
 }
 exports.ExecutionContext = ExecutionContext;

package/dist/core/main/runAutomationScript.d.ts

@@ -6,6 +6,7 @@ export declare class AutomationRunner implements IAutomationRunner {
     private KafkaPayload;
     static getSessionTerminationInfo(testCaseId: string): boolean;
     static updateSessionTerminationInfo(testCaseId: string): void;
+    static normalizeScriptType(scriptType?: string): string;
     private cleanup;
     run(request: AutomationRequest): Promise<void>;
 }