ff-automationv2 2.2.2 → 2.2.6

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

@@ -0,0 +1,5 @@
+import { MOB_ActivateAppUsingAppPackageInterface } from "../../interface/elementlessInterface.js";
+/**
+ * Reuses InstallAPK logic as per user's Python implementation
+ */
+export declare function ActivateAppUsingAppPackage(args: MOB_ActivateAppUsingAppPackageInterface): Promise<void>;

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

@@ -0,0 +1,17 @@
+/**
+ * Reuses InstallAPK logic as per user's Python implementation
+ */
+export async function ActivateAppUsingAppPackage(args) {
+    try {
+        await args.driver.activateApp(args.value);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_ActivateAppUsingAppPackage',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_ActivateAppUsingAppPackage");
+        throw new Error("MOB_ActivateAppUsingAppPackage 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,40 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import fs from "fs";
+import path from "path";
+export async function InstallAPK(args) {
+    try {
+        const apkPath = args.value.trim();
+        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;
+        }
+        // 2. Search for APK in current directory
+        if (!installed) {
+            const files = fs.readdirSync(process.cwd());
+            const apkFile = files.find(f => f.toLowerCase().includes(apkPath.toLowerCase()) && f.toLowerCase().endsWith(".apk"));
+            if (apkFile) {
+                const apkPath = path.resolve(process.cwd(), apkFile);
+                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}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_InstallAPK',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_InstallAPK");
+        throw new Error("MOB_InstallAPK action failed", { cause: error });
+    }
+}

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,35 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { execSync } from "child_process";
+export async function IsAppInstalled(args) {
+    try {
+        const target = args.value.trim();
+        logger.info(`Checking if app is installed: ${target}`);
+        let isInstalled = false;
+        try {
+            isInstalled = await args.driver.isAppInstalled(target);
+        }
+        catch (e) {
+            throw new Error("MOB_IsAppInstalled action failed", { cause: e });
+        }
+        if (!isInstalled) {
+            const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+            const cmdPrefix = udid ? `adb -s ${udid} shell` : `adb shell`;
+            const result = 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}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_IsAppInstalled',
+            stepInputs: [args.value, isInstalled],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_IsAppInstalled");
+        throw new Error("MOB_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>;

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

@@ -0,0 +1,93 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import fs from "fs";
+import { execSync } from "child_process";
+import path from "path";
+function getLatestInstalledPackage(apkPath) {
+    // ✅ Step 1: Extract APK name
+    const apkName = path.basename(apkPath, ".apk").toLowerCase();
+    // Example:
+    // "/folder/MyApp-release.apk" → "myapp-release"
+    // Normalize name (remove special chars)
+    const normalizedApkName = apkName.replace(/[^a-z0-9]/g, "");
+    // ✅ Step 2: Get installed packages (3rd party only)
+    const output = execSync(`adb shell pm list packages -3`, {
+        maxBuffer: 1024 * 1024 * 5
+    }).toString();
+    const packages = output
+        .split("\n")
+        .map(line => line.replace("package:", "").trim())
+        .filter(Boolean);
+    let bestMatch = "";
+    let bestScore = 0;
+    // ✅ Step 3: Find most similar package
+    for (const pkg of packages) {
+        const normalizedPkg = pkg.toLowerCase().replace(/[^a-z0-9]/g, "");
+        let score = 0;
+        // 🔥 Simple similarity logic
+        if (normalizedPkg.includes(normalizedApkName)) {
+            score += 3;
+        }
+        if (normalizedApkName.includes(normalizedPkg)) {
+            score += 2;
+        }
+        // Partial match scoring
+        for (let i = 0; i < normalizedApkName.length; i++) {
+            if (normalizedPkg.includes(normalizedApkName[i])) {
+                score += 0.1;
+            }
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestMatch = pkg;
+        }
+    }
+    // ✅ Step 4: Fallback (if nothing matched well)
+    if (!bestMatch && packages.length > 0) {
+        bestMatch = packages[packages.length - 1];
+    }
+    return bestMatch;
+}
+export async function OpenAppWithApkFilePath(args) {
+    try {
+        const apkPath = args.value.trim();
+        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;
+        }
+        // 2. Search for APK in current directory
+        if (!installed) {
+            const files = fs.readdirSync(process.cwd());
+            const apkFile = files.find(f => f.toLowerCase().includes(apkPath.toLowerCase()) && f.toLowerCase().endsWith(".apk"));
+            if (apkFile) {
+                const apkPath = path.resolve(process.cwd(), apkFile);
+                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}`);
+        }
+        // ✅ Step 5: Launch app
+        const appPackage = await getLatestInstalledPackage(apkPath);
+        logger.info(`Launching app: ${appPackage}`);
+        await args.driver.activateApp(appPackage);
+        // ✅ Script logging
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_OpenAppWithApkFilePath",
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_OpenAppWithApkFilePath");
+        throw new Error("MOB_OpenAppWithApkFilePath action failed", {
+            cause: error
+        });
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+export async function OpenMobileApplication(args) {
+    try {
+        await args.driver.activateApp(args.value);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_OpenMobileApplication',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_OpenMobileApplication");
+        throw new Error("MOB_OpenMobileApplication action failed", { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function ReceiveMessageOnEmulator(args) {
+    try {
+        const [number, message] = args.value.split(",").map(s => s.trim());
+        logger.info(`Receiving message on emulator from ${number}: ${message}`);
+        await args.driver.sendSms(number, message);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_ReceiveMessageOnEmulator',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_ReceiveMessageOnEmulator");
+        throw new Error("MOB_ReceiveMessageOnEmulator action failed", { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function TerminateAppUsingAppPackage(args) {
+    try {
+        const target = args.value.trim();
+        logger.info(`Terminating app: ${target}`);
+        await args.driver.terminateApp(target);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_TerminateAppUsingAppPackage',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_TerminateAppUsingAppPackage");
+        throw new Error("MOB_TerminateAppUsingAppPackage action failed", { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,44 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { execSync } from "child_process";
+export async function UninstallAPK(args) {
+    try {
+        const target = args.value.trim();
+        logger.info(`Uninstalling APK: ${target}`);
+        let uninstalled = false;
+        if (target.includes(".")) {
+            try {
+                await args.driver.removeApp(target);
+                uninstalled = true;
+            }
+            catch (error) {
+                throw new Error("MOB_UninstallAPK action failed", { cause: error });
+            }
+        }
+        if (!uninstalled) {
+            const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+            const cmdPrefix = udid ? `adb -s ${udid} shell` : `adb shell`;
+            const packagesResult = execSync(`${cmdPrefix} pm list packages`).toString().toLowerCase();
+            for (const line of packagesResult.split(/\r?\n/)) {
+                if (line.includes(target.toLowerCase())) {
+                    const pkg = line.replace("package:", "").trim();
+                    logger.info(`Uninstalling found package via ADB: ${pkg}`);
+                    await args.driver.removeApp(pkg);
+                    uninstalled = true;
+                    break;
+                }
+            }
+        }
+        if (!uninstalled) {
+            throw new Error(`Could not find or uninstall package: ${target}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'MOB_UninstallAPK',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_UninstallAPK");
+        throw new Error("MOB_UninstallAPK action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/AirplaneModeSwitchOff.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/AirplaneModeSwitchOff.js

@@ -0,0 +1,24 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { execSync } from "child_process";
+export async function AirplaneModeSwitchOff(args) {
+    try {
+        const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+        const cmdPrefix = udid
+            ? `adb -s ${udid} shell`
+            : `adb shell`;
+        logger.info("Attempting ADB fallback for AIRPLANE MODE OFF...");
+        // Android 10+
+        execSync(`${cmdPrefix} cmd connectivity airplane-mode disable`);
+        // Backup command
+        execSync(`${cmdPrefix} settings put global airplane_mode_on 0`);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_AirplaneModeSwitchOff",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_AirplaneModeSwitchOff");
+        throw new Error("AirplaneModeSwitchOff action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/AirplaneModeSwitchOn.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/AirplaneModeSwitchOn.js

@@ -0,0 +1,25 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { execSync } from "child_process";
+export async function AirplaneModeSwitchOn(args) {
+    try {
+        // ADB fallback
+        const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+        const cmdPrefix = udid
+            ? `adb -s ${udid} shell`
+            : `adb shell`;
+        logger.info("Attempting ADB fallback for AIRPLANE MODE ON...");
+        // Android 10+
+        execSync(`${cmdPrefix} cmd connectivity airplane-mode enable`);
+        // Backup command
+        execSync(`${cmdPrefix} settings put global airplane_mode_on 1`);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_AirplaneModeSwitchOn",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_AirplaneModeSwitchOn");
+        throw new Error("AirplaneModeSwitchOn action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/Break.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/Break.js

@@ -0,0 +1,14 @@
+export async function Break(args) {
+    try {
+        // Break action usually does nothing or just logs
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "Break",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("Break");
+        throw new Error("Break action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/Continue.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/Continue.js

@@ -0,0 +1,14 @@
+export async function Continue(args) {
+    try {
+        // Continue action usually does nothing or just logs
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "Continue",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("Continue");
+        throw new Error("Continue action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/GpsSwitchOff.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/GpsSwitchOff.js

@@ -0,0 +1,18 @@
+export async function GpsSwitchOff(args) {
+    try {
+        const currentState = await args.driver.getNetworkConnection();
+        // If GPS is ON (state 6)
+        if (currentState === 6) {
+            await args.driver.toggleLocationServices();
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_GpsSwitchOff",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GpsSwitchOff");
+        throw new Error("GpsSwitchOff action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/GpsSwitchOn.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/GpsSwitchOn.js

@@ -0,0 +1,18 @@
+export async function GpsSwitchOn(args) {
+    try {
+        const currentState = await args.driver.getNetworkConnection();
+        // If GPS is OFF (state 6 is ALL_NETWORK_ON which usually includes GPS)
+        if (currentState !== 6) {
+            await args.driver.toggleLocationServices();
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_GpsSwitchOn",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GpsSwitchOn");
+        throw new Error("GpsSwitchOn action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/HideKeyboard.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/HideKeyboard.js

@@ -0,0 +1,14 @@
+export async function HideKeyboard(args) {
+    try {
+        await args.driver.hideKeyboard();
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_HideKeyboard",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_HideKeyboard");
+        throw new Error("HideKeyboard action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/LockDevice.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/LockDevice.js

@@ -0,0 +1,14 @@
+export async function LockDevice(args) {
+    try {
+        await args.driver.lock();
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_LockDevice",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_LockDevice");
+        throw new Error("LockDevice action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/OpenChromeBrowser.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/OpenChromeBrowser.js

@@ -0,0 +1,14 @@
+export async function OpenChromeBrowser(args) {
+    try {
+        await args.driver.activateApp("com.android.chrome");
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_OpenChromeBrowser",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_OpenChromeBrowser");
+        throw new Error("OpenChromeBrowser action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/OpenNotification.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/OpenNotification.js

@@ -0,0 +1,14 @@
+export async function OpenNotification(args) {
+    try {
+        await args.driver.openNotifications();
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_OpenNotification",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_OpenNotification");
+        throw new Error("OpenNotification action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/ResetApp.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/ResetApp.js

@@ -0,0 +1,19 @@
+export async function ResetApp(args) {
+    try {
+        const appPackage = await args.driver.getCurrentPackage();
+        if (!appPackage) {
+            throw new Error("Could not determine appPackage");
+        }
+        await args.driver.terminateApp(appPackage);
+        await args.driver.activateApp(appPackage);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_ResetApp",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_ResetApp");
+        throw new Error("ResetApp action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/RestartCurrentDevice.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/RestartCurrentDevice.js

@@ -0,0 +1,23 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { execSync } from "child_process";
+export async function RestartCurrentDevice(args) {
+    try {
+        const udid = args.driver.capabilities["appium:udid"] || args.driver.capabilities.udid;
+        logger.info(`Attempting ADB reboot on ${udid || 'default device'}...`);
+        try {
+            execSync(`adb -s ${udid} reboot`);
+        }
+        catch (e) {
+            logger.info("ADB reboot is going", e);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_RestartCurrentDevice",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_RestartCurrentDevice");
+        throw new Error("RestartCurrentDevice action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/SetDeviceOrientationAsLandscape.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/SetDeviceOrientationAsLandscape.js

@@ -0,0 +1,14 @@
+export async function SetDeviceOrientationAsLandscape(args) {
+    try {
+        await args.driver.setOrientation("LANDSCAPE");
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_SetDeviceOrientationAsLandscape",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SetDeviceOrientationAsLandscape");
+        throw new Error("SetDeviceOrientationLandscape action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/inputlessActions/SetDeviceOrientationAsPortrait.d.ts

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

package/dist/automation/actions/interaction/inputlessActions/SetDeviceOrientationAsPortrait.js

@@ -0,0 +1,14 @@
+export async function SetDeviceOrientationAsPortrait(args) {
+    try {
+        await args.driver.setOrientation("PORTRAIT");
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "MOB_SetDeviceOrientationAsPortrait",
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_SetDeviceOrientationAsPortrait");
+        throw new Error("SetDeviceOrientationPortrait action failed", { cause: error });
+    }
+}