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

package/dist/automation/actions/interaction/click/doubleClick.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doubleClick = doubleClick;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function doubleClick(args) {
+    const nlpName = args.platform === "ios" ? "IOS_DoubleTap" : "MOB_DoubleTap";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.doubleClick();
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`DoubleClick action failed :`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await args.driver.execute((el) => {
+                    el.scrollIntoView({
+                        block: "center",
+                        inline: "nearest"
+                    });
+                }, element);
+                await element.doubleClick();
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'DoubleClick',
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("DoubleClick");
+                throw new Error(`DoubleClick action failed :`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/click/rightClick.d.ts

@@ -0,0 +1,2 @@
+import { RightClickInterface } from "../../interface/clickActionInterface.js";
+export declare function rightClick(args: RightClickInterface): Promise<void>;

package/dist/automation/actions/interaction/click/rightClick.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rightClick = rightClick;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function rightClick(args) {
+    try {
+        const element = await args.driver.$(args.selector);
+        await args.driver.execute((el) => {
+            el.scrollIntoView({
+                block: "center",
+                inline: "nearest"
+            });
+        }, element);
+        await element.click({ button: 2 });
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: 'RightClick',
+            stepInputs: [],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("RightClick");
+        throw new Error(`RightClick action failed :`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/click/tapOnSpecifiedLocation.d.ts

@@ -0,0 +1,2 @@
+import { MOB_TapOnSpecifiedLocationInterface } from "../../interface/clickActionInterface.js";
+export declare const TapOnSpecifiedLocation: (args: MOB_TapOnSpecifiedLocationInterface) => Promise<void>;

package/dist/automation/actions/interaction/click/tapOnSpecifiedLocation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapOnSpecifiedLocation = void 0;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const TapOnSpecifiedLocation = async (args) => {
+    const nlpName = args.platform === "ios" ? "IOS_TapOnSpecifiedLocation" : "MOB_TapOnSpecifiedLocation";
+    try {
+        const coords = args.value.split(",");
+        const x = parseInt(coords[0]);
+        const y = parseInt(coords[1]);
+        await args.driver.performActions([
+            {
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions: [
+                    { type: "pointerMove", duration: 0, x, y },
+                    { type: "pointerDown", button: 0 },
+                    { type: "pointerUp", button: 0 }
+                ]
+            }
+        ]);
+        await args.driver.releaseActions();
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName,
+            stepInputs: [x, y],
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error("MOB_TapOnSpecifiedLocation action failed", { cause: error });
+    }
+};
+exports.TapOnSpecifiedLocation = TapOnSpecifiedLocation;

package/dist/automation/actions/interaction/click/waitAndClick.d.ts

@@ -0,0 +1,2 @@
+import { WaitAndClickInterface } from "../../interface/clickActionInterface.js";
+export declare function waitAndClick(args: WaitAndClickInterface): Promise<void>;

package/dist/automation/actions/interaction/click/waitAndClick.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitAndClick = waitAndClick;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function waitAndClick(args) {
+    const nlpName = args.platform === "ios" ? "IOS_WaitAndClick" : "MOB_WaitAndClick";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                const element = await args.driver.$(args.selector);
+                let waitTime = 10;
+                if (args.value != "") {
+                    waitTime = parseInt(args.value);
+                    await element.waitForDisplayed({ timeout: waitTime });
+                }
+                else {
+                    await element.waitForDisplayed({ timeout: waitTime * 100 });
+                }
+                logData_js_1.logger.info(`Element became visible. Clicking selector: ${args.selector}`);
+                await element.click();
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [waitTime ? waitTime : 10],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`WaitAndClick action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                let waitTime = 10;
+                const element = await args.driver.$(args.selector);
+                if (args.value != "") {
+                    waitTime = parseInt(args.value);
+                    await element.waitForDisplayed({ timeout: waitTime });
+                }
+                else {
+                    await element.waitForDisplayed({ timeout: 10000 });
+                }
+                logData_js_1.logger.info(`Element became visible. Clicking selector: ${args.selector}`);
+                await element.click();
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "WaitAndClick",
+                    stepInputs: [waitTime ? waitTime : 10],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("WaitAndClick");
+                throw new Error(`WaitAndClick action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/dragAndDrop/dragAndDrop.d.ts

@@ -0,0 +1,2 @@
+import { DragAndDropToElementInterface } from "../../interface/dragAndDropToElementInterface.js";
+export declare function dragAndDropToElement(args: DragAndDropToElementInterface): Promise<void>;

package/dist/automation/actions/interaction/dragAndDrop/dragAndDrop.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragAndDropToElement = dragAndDropToElement;
+async function dragAndDropToElement(args) {
+    try {
+        const source = await args.driver.$(args.selector1);
+        const target = await args.driver.$(args.selector2);
+        await source.dragAndDrop(target);
+        args.scriptDataAppender.add(async () => {
+            const ffElement1 = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex1}"]`);
+            const ffElement2 = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex2}"]`);
+            return {
+                nlpName: "Builtin_DragAndDropToElement",
+                elementsData: [
+                    {
+                        name: args.elementName1,
+                        type: args.elementType1,
+                        locators: ffElement1?.locators ? ffElement1.locators : [{ name: "xpath", value: args.selector1 }],
+                        platform: args.platform
+                    },
+                    {
+                        name: args.elementName2,
+                        type: args.elementType2,
+                        locators: ffElement2?.locators ? ffElement2.locators : [{ name: "xpath", value: args.selector2 }],
+                        platform: args.platform
+                    }
+                ],
+                stepInputs: []
+            };
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("Builtin_DragAndDropToElement");
+        throw new Error("Builtin_DragAndDropToElement action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementLessAction/MobCheckIfAppIsClosed.d.ts

@@ -0,0 +1,2 @@
+import { MOB_CheckIfAppIsClosedInterface } from "../../interface/elelementLessActionInterface.js";
+export declare function MOB_CheckIfAppIsClosed(args: MOB_CheckIfAppIsClosedInterface): Promise<void>;

package/dist/automation/actions/interaction/elementLessAction/MobCheckIfAppIsClosed.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOB_CheckIfAppIsClosed = MOB_CheckIfAppIsClosed;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function MOB_CheckIfAppIsClosed(args) {
+    const nlpName = args.platform === "ios" ? "IOS_CheckIfAppIsClosed" : "MOB_CheckIfAppIsClosed";
+    try {
+        let state;
+        if (args.platform === "ios") {
+            state = await args.driver.queryAppState(args.driver.capabilities["appium:bundleId"]);
+        }
+        else {
+            state = await args.driver.queryAppState(await args.driver.getCurrentPackage());
+        }
+        const isClosed = state !== 4;
+        if (!isClosed) {
+            throw new Error("App is not closed");
+        }
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error(`App is not closed:`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementLessAction/MobRunAppInBackgroundInterface.d.ts

@@ -0,0 +1,2 @@
+import { MOB_RunAppInBackgroundInterface } from "../../interface/elelementLessActionInterface.js";
+export declare function MOB_RunAppInBackground(args: MOB_RunAppInBackgroundInterface): Promise<void>;

package/dist/automation/actions/interaction/elementLessAction/MobRunAppInBackgroundInterface.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOB_RunAppInBackground = MOB_RunAppInBackground;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function MOB_RunAppInBackground(args) {
+    const nlpName = args.platform === "ios" ? "IOS_RunAppInBackground" : "MOB_RunAppInBackground";
+    try {
+        await args.driver.execute('mobile: backgroundApp', {
+            seconds: Number(args.value || "5")
+        });
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName,
+            stepInputs: [args.value]
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error("RunAppInBackground action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementlessActions/activateAppUsingAppPackage.d.ts

@@ -0,0 +1,2 @@
+import { MOB_ActivateAppUsingAppPackageInterface } from "../../interface/elementlessInterface.js";
+export declare function ActivateAppUsingAppPackage(args: MOB_ActivateAppUsingAppPackageInterface): Promise<void>;

package/dist/automation/actions/interaction/elementlessActions/activateAppUsingAppPackage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivateAppUsingAppPackage = ActivateAppUsingAppPackage;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function ActivateAppUsingAppPackage(args) {
+    const nlpName = args.platform === "ios" ? "IOS_ActivateAppUsingBundleID" : "MOB_ActivateAppUsingAppPackage";
+    try {
+        await args.driver.activateApp(args.value);
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName,
+            stepInputs: [args.value],
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error("ActivateAppUsingAppPackage action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementlessActions/getOtp.d.ts

@@ -0,0 +1,2 @@
+import { GetOtpInterface } from "../../interface/getOtpInterface.js";
+export declare function GetOtpAction(args: GetOtpInterface): Promise<void>;

package/dist/automation/actions/interaction/elementlessActions/getOtp.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOtpAction = GetOtpAction;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const child_process_1 = require("child_process");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const saveStepInputData_js_1 = require("../../../../utils/helpers/saveStepInputData.js");
+async function GetOtpAction(args) {
+    try {
+        // const udid = (args.driver.capabilities as any)["appium:udid"] || (args.driver.capabilities as any).udid;
+        const cmdPrefix = `${args.adbPath} shell`;
+        const timeFrom = Number(args.timeFrom) || 60;
+        const waitTime = Number(args.waitTime) || 60;
+        const packageName = (0, child_process_1.execSync)(`${cmdPrefix} cmd role get-role-holders android.app.role.SMS`.trim(), { encoding: "utf8" });
+        logData_js_1.logger.info("the default app is ", packageName);
+        const expectedHeader = args.selector.trim().toLowerCase();
+        const getLatestMatchingSms = () => {
+            const inboxSms = (0, child_process_1.execSync)(`${cmdPrefix} "content query --uri content://sms/inbox --projection _id:date:address:body --sort 'date DESC' | head -n 100"`, { encoding: "utf8" }).trim();
+            const messages = [...inboxSms.matchAll(/(?:^|\r?\n)Row:\s*\d+\s+_id=(\d+),\s*date=(\d+),\s*address=(.*?),\s*body=(.*?)(?=\r?\nRow:|$)/gs)]
+                .map((match) => ({
+                id: match[1],
+                date: Number(match[2]),
+                address: match[3].trim(),
+                body: match[4].trim()
+            })).slice(0, 5);
+            return messages.find((message) => message.address.toLowerCase().includes(expectedHeader));
+        };
+        const existingSms = getLatestMatchingSms();
+        const now = Date.now();
+        if (existingSms && now - existingSms.date <= (timeFrom * 1000)) {
+            const smsBody = existingSms.body;
+            logData_js_1.logger.info("SMS body:", smsBody);
+            let _regex;
+            let otpValue;
+            if (args.otpExtractor) {
+                const otpResult = await args.otpExtractor(smsBody);
+                if (otpResult?.otp && otpResult.regex) {
+                    _regex = otpResult.regex;
+                    otpValue = otpResult.otp;
+                    logData_js_1.logger.info("Extracted OTP:", otpResult.otp, "Generated Regex:", otpResult.regex);
+                }
+                else {
+                    logData_js_1.logger.info("LLM could not find an OTP in the SMS body.");
+                }
+            }
+            (0, appendScriptData_js_1.appendScriptData)({
+                scriptDataAppender: args.scriptDataAppender,
+                nlpName: "MOB_FetchOtpFromMessages",
+                stepInputs: [existingSms.address, timeFrom + "s", waitTime, _regex],
+                platform: "android",
+                returnTypeVariableName: args.returnTypeVariableName
+            });
+            (0, saveStepInputData_js_1.saveStepInputData)(args, otpValue || smsBody);
+            return;
+        }
+        const baselineId = existingSms?.id;
+        const pollingStartedAt = now;
+        const pollingDeadline = pollingStartedAt + (waitTime * 1000);
+        while (Date.now() < pollingDeadline) {
+            if (args.isTerminated?.()) {
+                logData_js_1.logger.info("OTP polling aborted because session was terminated.");
+                return;
+            }
+            const latestSms = getLatestMatchingSms();
+            if (latestSms &&
+                latestSms.id !== baselineId &&
+                latestSms.date >= pollingStartedAt) {
+                const smsBody = latestSms.body;
+                logData_js_1.logger.info("SMS body:", smsBody);
+                let regex;
+                let otpValue;
+                if (args.otpExtractor) {
+                    const otpResult = await args.otpExtractor(smsBody);
+                    if (otpResult?.otp && otpResult.regex) {
+                        regex = otpResult.regex;
+                        regex = regex.replace(/\\+/g, "\\");
+                        otpValue = otpResult.otp;
+                        logData_js_1.logger.info("Extracted OTP:", otpResult.otp, "Generated Regex:", otpResult.regex);
+                    }
+                    else {
+                        logData_js_1.logger.error("LLM could not find an OTP in the SMS body.");
+                    }
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "MOB_FetchOtpFromMessages",
+                    stepInputs: [latestSms.address, timeFrom + "s", waitTime, regex],
+                    platform: "android",
+                    returnTypeVariableName: args.returnTypeVariableName
+                });
+                (0, saveStepInputData_js_1.saveStepInputData)(args, otpValue || smsBody);
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        throw new Error(`Timed out waiting up to ${waitTime} seconds for an SMS with header: ${args.selector}`);
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("getOtp");
+        throw new Error("GettingOtp action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementlessActions/installAPK.d.ts

@@ -0,0 +1,2 @@
+import { MOB_InstallAPKInterface } from "../../interface/elementlessInterface.js";
+export declare function InstallAPK(args: MOB_InstallAPKInterface): Promise<void>;

package/dist/automation/actions/interaction/elementlessActions/installAPK.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallAPK = InstallAPK;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function InstallAPK(args) {
+    switch (args.platform) {
+        case "android":
+            try {
+                const apkPath = args.value.trim();
+                logData_js_1.logger.info(`Installing APK: ${apkPath}`);
+                let installed = false;
+                // 1. Direct install if it looks like a path
+                if (apkPath.toLowerCase().endsWith(".apk") || apkPath.includes("/") || apkPath.includes("\\")) {
+                    await args.driver.execute("mobile: installApp", {
+                        appPath: apkPath
+                    });
+                    installed = true;
+                }
+                if (!installed) {
+                    const files = fs_1.default.readdirSync(process.cwd());
+                    const apkFile = files.find(f => f.toLowerCase().includes(apkPath.toLowerCase()) && f.toLowerCase().endsWith(".apk"));
+                    if (apkFile) {
+                        const apkPath = path_1.default.resolve(process.cwd(), apkFile);
+                        logData_js_1.logger.info(`Found APK for installation: ${apkPath}`);
+                        await args.driver.installApp(apkPath);
+                        installed = true;
+                    }
+                }
+                if (!installed) {
+                    throw new Error(`Could not find or install APK: ${apkPath}`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'MOB_InstallAPK',
+                    stepInputs: [args.value],
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("MOB_InstallAPK");
+                throw new Error("MOB_InstallAPK action failed", { cause: error });
+            }
+            break;
+        case "ios":
+        default:
+            try {
+                const ipaPath = args.value.trim();
+                logData_js_1.logger.info(`Installing IPA: ${ipaPath}`);
+                let installed = false;
+                if (ipaPath.toLowerCase().endsWith(".ipa") ||
+                    ipaPath.includes("/") ||
+                    ipaPath.includes("\\")) {
+                    await args.driver.installApp(ipaPath);
+                    installed = true;
+                }
+                if (!installed) {
+                    const files = fs_1.default.readdirSync(process.cwd());
+                    const ipaFile = files.find((f) => f.toLowerCase().includes(ipaPath.toLowerCase()) &&
+                        f.toLowerCase().endsWith(".ipa"));
+                    if (ipaFile) {
+                        const resolvedPath = path_1.default.resolve(process.cwd(), ipaFile);
+                        logData_js_1.logger.info(`Found IPA for installation: ${resolvedPath}`);
+                        await args.driver.installApp(resolvedPath);
+                        installed = true;
+                    }
+                }
+                if (!installed) {
+                    throw new Error(`Could not find or install IPA: ${ipaPath}`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: 'IOS_InstallIPA',
+                    stepInputs: [args.value],
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("IOS_InstallIPA");
+                throw new Error("IOS_InstallIPA action failed", { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/elementlessActions/isAppInstalled.d.ts

@@ -0,0 +1,2 @@
+import { MOB_IsAppInstalledInterface } from "../../interface/elementlessInterface.js";
+export declare function IsAppInstalled(args: MOB_IsAppInstalledInterface): Promise<void>;

package/dist/automation/actions/interaction/elementlessActions/isAppInstalled.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAppInstalled = IsAppInstalled;
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+const child_process_1 = require("child_process");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+async function IsAppInstalled(args) {
+    const nlpName = args.platform === "ios" ? "IOS_IsAppInstalled" : "MOB_IsAppInstalled";
+    try {
+        const target = args.value.trim();
+        logData_js_1.logger.info(`Checking if app is installed: ${target}`);
+        let isInstalled = false;
+        try {
+            isInstalled = await args.driver.isAppInstalled(target);
+        }
+        catch (e) {
+            throw new Error("IsAppInstalled action failed", { cause: e });
+        }
+        if (!isInstalled) {
+            const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+            const cmdPrefix = udid ? `${args.adbPath} -s ${udid} shell` : `${args.adbPath} shell`;
+            const result = (0, child_process_1.execSync)(`${cmdPrefix} pm list packages`).toString().toLowerCase();
+            if (result.includes(target.toLowerCase())) {
+                isInstalled = true;
+            }
+        }
+        if (!isInstalled) {
+            throw new Error(`Could not find or install APK: ${target}`);
+        }
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: nlpName,
+            stepInputs: [args.value],
+        });
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP(nlpName);
+        throw new Error("IsAppInstalled action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/elementlessActions/openAppWithApkFilePath.d.ts

@@ -0,0 +1,2 @@
+import { MOB_OpenAppWithApkFilePathInterface } from "../../interface/elementlessInterface.js";
+export declare function OpenAppWithApkFilePath(args: MOB_OpenAppWithApkFilePathInterface): Promise<void>;