@samsara-dev/appwright 0.2.0

package/dist/providers/appium.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDriver = installDriver;
+exports.startAppiumServer = startAppiumServer;
+exports.stopAppiumServer = stopAppiumServer;
+exports.isEmulatorInstalled = isEmulatorInstalled;
+exports.startAndroidEmulator = startAndroidEmulator;
+exports.getAppBundleId = getAppBundleId;
+exports.getConnectedIOSDeviceUDID = getConnectedIOSDeviceUDID;
+exports.getActiveAndroidDevices = getActiveAndroidDevices;
+exports.getApkDetails = getApkDetails;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const types_1 = require("../types");
+const logger_1 = require("../logger");
+const promises_1 = __importDefault(require("fs/promises"));
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+async function installDriver(driverName) {
+    // uninstall the driver first to avoid conflicts
+    await new Promise((resolve) => {
+        const installProcess = (0, child_process_1.spawn)("npx", ["appium", "driver", "uninstall", driverName], {
+            stdio: "pipe",
+        });
+        installProcess.on("exit", (code) => {
+            resolve(code);
+        });
+    });
+    // install the driver
+    await new Promise((resolve) => {
+        const installProcess = (0, child_process_1.spawn)("npx", ["appium", "driver", "install", driverName], {
+            stdio: "pipe",
+        });
+        installProcess.on("exit", (code) => {
+            resolve(code);
+        });
+    });
+}
+async function startAppiumServer(provider) {
+    let emulatorStartRequested = false;
+    return new Promise((resolve, reject) => {
+        const appiumProcess = (0, child_process_1.spawn)("npx", ["appium"], {
+            stdio: "pipe",
+        });
+        appiumProcess.stderr.on("data", async (data) => {
+            console.log(data.toString());
+        });
+        appiumProcess.stdout.on("data", async (data) => {
+            const output = data.toString();
+            console.log(output);
+            if (output.includes("Error: listen EADDRINUSE")) {
+                // TODO: Kill the appium server if it is already running
+                logger_1.logger.error(`Appium: ${data}`);
+                throw new Error(`Appium server is already running. Please stop the server before running tests.`);
+            }
+            if (output.includes("Could not find online devices")) {
+                if (!emulatorStartRequested && provider == "emulator") {
+                    emulatorStartRequested = true;
+                    await startAndroidEmulator();
+                }
+            }
+            if (output.includes("Appium REST http interface listener started")) {
+                logger_1.logger.log("Appium server is up and running.");
+                resolve(appiumProcess);
+            }
+        });
+        appiumProcess.on("error", (error) => {
+            logger_1.logger.error(`Appium: ${error}`);
+            reject(error);
+        });
+        process.on("exit", () => {
+            logger_1.logger.log("Main process exiting. Killing Appium server...");
+            appiumProcess.kill();
+        });
+        appiumProcess.on("close", (code) => {
+            logger_1.logger.log(`Appium server exited with code ${code}`);
+        });
+    });
+}
+function stopAppiumServer() {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(`pkill -f appium`, (error, stdout) => {
+            if (error) {
+                logger_1.logger.error(`Error stopping Appium server: ${error.message}`);
+                reject(error);
+            }
+            logger_1.logger.log("Appium server stopped successfully.");
+            resolve(stdout);
+        });
+    });
+}
+function isEmulatorInstalled(platform) {
+    return new Promise((resolve) => {
+        if (platform == types_1.Platform.ANDROID) {
+            const androidHome = process.env.ANDROID_HOME;
+            const emulatorPath = path_1.default.join(androidHome, "emulator", "emulator");
+            (0, child_process_1.exec)(`${emulatorPath} -list-avds`, (error, stdout, stderr) => {
+                if (error) {
+                    throw new Error(`Error fetching emulator list.\nPlease install emulator from Android SDK Tools.
+Follow this guide to install emulators: https://community.neptune-software.com/topics/tips--tricks/blogs/how-to-install--android-emulator-without--android--st`);
+                }
+                if (stderr) {
+                    logger_1.logger.error(`Emulator: ${stderr}`);
+                }
+                const lines = stdout.trim().split("\n");
+                const deviceNames = lines.filter((line) => line.trim() && !line.startsWith("INFO") && !line.includes("/tmp/"));
+                if (deviceNames.length > 0) {
+                    resolve(true);
+                }
+                else {
+                    throw new Error(`No installed emulators found.
+Follow this guide to install emulators: https://community.neptune-software.com/topics/tips--tricks/blogs/how-to-install--android-emulator-without--android--st`);
+                }
+            });
+        }
+    });
+}
+async function startAndroidEmulator() {
+    return new Promise((resolve, reject) => {
+        const androidHome = process.env.ANDROID_HOME;
+        const emulatorPath = path_1.default.join(androidHome, "emulator", "emulator");
+        (0, child_process_1.exec)(`${emulatorPath} -list-avds`, (error, stdout, stderr) => {
+            if (error) {
+                throw new Error(`Error fetching emulator list.\nPlease install emulator from Android SDK Tools.\nFollow this guide to install emulators: https://community.neptune-software.com/topics/tips--tricks/blogs/how-to-install--android-emulator-without--android--st`);
+            }
+            if (stderr) {
+                logger_1.logger.error(`Emulator: ${stderr}`);
+            }
+            const lines = stdout.trim().split("\n");
+            // Filter out lines that do not contain device names
+            const deviceNames = lines.filter((line) => line.trim() && !line.startsWith("INFO") && !line.includes("/tmp/"));
+            if (deviceNames.length === 0) {
+                throw new Error(`No installed emulators found.\nFollow this guide to install emulators: https://community.neptune-software.com/topics/tips--tricks/blogs/how-to-install--android-emulator-without--android--st`);
+            }
+            else {
+                logger_1.logger.log(`Available Emulators: ${deviceNames}`);
+            }
+            const emulatorToStart = deviceNames[0];
+            const emulatorProcess = (0, child_process_1.spawn)(emulatorPath, ["-avd", emulatorToStart], {
+                stdio: "pipe",
+            });
+            emulatorProcess.stdout?.on("data", (data) => {
+                logger_1.logger.log(`Emulator: ${data}`);
+                if (data.includes("Successfully loaded snapshot 'default_boot'")) {
+                    logger_1.logger.log("Emulator started successfully.");
+                    resolve();
+                }
+            });
+            emulatorProcess.on("error", (err) => {
+                logger_1.logger.error(`Emulator: ${err.message}`);
+                reject(`Failed to start emulator: ${err.message}`);
+            });
+            emulatorProcess.on("close", (code) => {
+                if (code !== 0) {
+                    reject(`Emulator process exited with code: ${code}`);
+                }
+            });
+            // Ensure the emulator process is killed when the main process exits
+            process.on("exit", () => {
+                logger_1.logger.log("Main process exiting. Killing the emulator process...");
+                emulatorProcess.kill();
+            });
+        });
+    });
+}
+function getAppBundleId(path) {
+    return new Promise((resolve, reject) => {
+        const command = `osascript -e 'id of app "${path}"'`;
+        (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error) {
+                logger_1.logger.error("osascript:", error.message);
+                return reject(error);
+            }
+            if (stderr) {
+                logger_1.logger.error(`osascript: ${stderr}`);
+                return reject(new Error(stderr));
+            }
+            const bundleId = stdout.trim();
+            if (bundleId) {
+                resolve(bundleId);
+            }
+            else {
+                reject(new Error("Bundle ID not found"));
+            }
+        });
+    });
+}
+async function getConnectedIOSDeviceUDID() {
+    try {
+        const { stdout } = await execPromise(`xcrun xctrace list devices`);
+        const iphoneDevices = stdout
+            .split("\n")
+            .filter((line) => line.includes("iPhone"));
+        const realDevices = iphoneDevices.filter((line) => !line.includes("Simulator"));
+        if (!realDevices.length) {
+            throw new Error(`No connected iPhone detected. Please ensure your device is connected and try again.`);
+        }
+        const deviceLine = realDevices[0];
+        //the output from above looks like this: User’s iPhone (18.0) (00003110-002A304e3A53C41E)
+        //where `00003110-000A304e3A53C41E` is the UDID of the device
+        const matches = deviceLine.match(/\(([\da-fA-F-]+)\)$/);
+        if (matches && matches[1]) {
+            return matches[1];
+        }
+        else {
+            throw new Error(`Please check your iPhone device connection. 
+To check for connected devices run "xcrun xctrace list devices | grep iPhone | grep -v Simulator"`);
+        }
+    }
+    catch (error) {
+        //@ts-ignore
+        throw new Error(`getConnectedIOSDeviceUDID: ${error.message}`);
+    }
+}
+async function getActiveAndroidDevices() {
+    try {
+        const { stdout } = await execPromise("adb devices");
+        const lines = stdout.trim().split("\n");
+        const deviceLines = lines.filter((line) => line.includes("\tdevice"));
+        return deviceLines.length;
+    }
+    catch (error) {
+        throw new Error(
+        //@ts-ignore
+        `getActiveAndroidDevices: ${error.message}`);
+    }
+}
+async function getLatestBuildToolsVersion() {
+    const androidHome = process.env.ANDROID_HOME;
+    const buildToolsPath = path_1.default.join(androidHome, "build-tools");
+    try {
+        const files = await promises_1.default.readdir(buildToolsPath);
+        const versions = files.filter((file) => /^\d+\.\d+\.\d+(-rc\d+)?$/.test(file));
+        if (versions.length === 0) {
+            throw new Error(`No valid build-tools found in ${buildToolsPath}. Please download from Android Studio: https://developer.android.com/studio/intro/update#required`);
+        }
+        return (0, utils_1.getLatestBuildToolsVersions)(versions);
+    }
+    catch (err) {
+        logger_1.logger.error(`getLatestBuildToolsVersion: ${err}`);
+        throw new Error(`Error reading ${buildToolsPath}. Ensure it exists or download from Android Studio: https://developer.android.com/studio/intro/update#required`);
+    }
+}
+async function getApkDetails(buildPath) {
+    const androidHome = process.env.ANDROID_HOME;
+    const buildToolsVersion = await getLatestBuildToolsVersion();
+    if (!buildToolsVersion) {
+        throw new Error(`No valid build-tools found in ${buildToolsVersion}. Please download from Android Studio: https://developer.android.com/studio/intro/update#required`);
+    }
+    const aaptPath = path_1.default.join(androidHome, "build-tools", buildToolsVersion, "aapt");
+    const command = `${aaptPath} dump badging ${buildPath}`;
+    try {
+        const { stdout, stderr } = await execPromise(command);
+        if (stderr) {
+            logger_1.logger.error(`getApkDetails: ${stderr}`);
+            throw new Error(`Error executing aapt: ${stderr}`);
+        }
+        const packageMatch = stdout.match(/package: name='(\S+)'/);
+        const activityMatch = stdout.match(/launchable-activity: name='(\S+)'/);
+        if (!packageMatch || !activityMatch) {
+            throw new Error(`Unable to retrieve package or launchable activity from the APK. Please verify that the provided file is a valid APK.`);
+        }
+        const packageName = packageMatch[1];
+        const launchableActivity = activityMatch[1];
+        return { packageName, launchableActivity };
+    }
+    catch (error) {
+        throw new Error(`getApkDetails: ${error.message}`);
+    }
+}

package/dist/providers/browserstack/index.d.ts

@@ -0,0 +1,26 @@
+import { AppwrightConfig, DeviceProvider } from "../../types";
+import { FullProject } from "@playwright/test";
+import { Device } from "../../device";
+export declare class BrowserStackDeviceProvider implements DeviceProvider {
+    private sessionDetails?;
+    sessionId?: string;
+    private project;
+    constructor(project: FullProject<AppwrightConfig>, appBundleId: string | undefined);
+    globalSetup(): Promise<void>;
+    getDevice(): Promise<Device>;
+    private validateConfig;
+    private createDriver;
+    private getSessionDetails;
+    private getAppBundleIdFromSession;
+    static downloadVideo(sessionId: string, outputDir: string, fileName: string): Promise<{
+        path: string;
+        contentType: string;
+    } | null>;
+    syncTestDetails(details: {
+        status?: string;
+        reason?: string;
+        name?: string;
+    }): Promise<any>;
+    private createConfig;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/browserstack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/browserstack/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,cAAc,EAEf,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAqDtC,qBAAa,0BAA2B,YAAW,cAAc;IAC/D,OAAO,CAAC,cAAc,CAAC,CAA6B;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,OAAO,CAA+B;gBAG5C,OAAO,EAAE,WAAW,CAAC,eAAe,CAAC,EACrC,WAAW,EAAE,MAAM,GAAG,SAAS;IAU3B,WAAW;IAwDX,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAMlC,OAAO,CAAC,cAAc;YASR,YAAY;YAgBZ,iBAAiB;YAKjB,yBAAyB;WAK1B,aAAa,CACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAuFlD,eAAe,CAAC,OAAO,EAAE;QAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf;IA2BD,OAAO,CAAC,YAAY;CAiDrB"}

package/dist/providers/browserstack/index.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserStackDeviceProvider = void 0;
+const async_retry_1 = __importDefault(require("async-retry"));
+const fs_1 = __importDefault(require("fs"));
+const form_data_1 = __importDefault(require("form-data"));
+const path_1 = __importDefault(require("path"));
+const device_1 = require("../../device");
+const logger_1 = require("../../logger");
+const API_BASE_URL = "https://api-cloud.browserstack.com/app-automate";
+const envVarKeyForBuild = (projectName) => `BROWSERSTACK_APP_URL_${projectName.toUpperCase()}`;
+function getAuthHeader() {
+    const userName = process.env.BROWSERSTACK_USERNAME;
+    const accessKey = process.env.BROWSERSTACK_ACCESS_KEY;
+    const key = Buffer.from(`${userName}:${accessKey}`).toString("base64");
+    return `Basic ${key}`;
+}
+async function getSessionDetails(sessionId) {
+    const response = await fetch(`${API_BASE_URL}/sessions/${sessionId}.json`, {
+        method: "GET",
+        headers: {
+            Authorization: getAuthHeader(),
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Error fetching session details: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+}
+class BrowserStackDeviceProvider {
+    sessionDetails;
+    sessionId;
+    project;
+    constructor(project, appBundleId) {
+        this.project = project;
+        if (appBundleId) {
+            logger_1.logger.log(`Bundle id is specified (${appBundleId}) but ignored for BrowserStack provider.`);
+        }
+    }
+    async globalSetup() {
+        if (!this.project.use.buildPath) {
+            throw new Error(`Build path not found. Please set the build path in the config file.`);
+        }
+        if (!(process.env.BROWSERSTACK_USERNAME && process.env.BROWSERSTACK_ACCESS_KEY)) {
+            throw new Error("BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY are required environment variables for this device provider.");
+        }
+        const buildPath = this.project.use.buildPath;
+        const isHttpUrl = buildPath.startsWith("http");
+        const isBrowserStackUrl = buildPath.startsWith("bs://");
+        let appUrl = undefined;
+        if (isBrowserStackUrl) {
+            appUrl = buildPath;
+        }
+        else {
+            // Upload the file to BrowserStack and get the appUrl
+            let body;
+            let headers = {
+                Authorization: getAuthHeader(),
+            };
+            if (isHttpUrl) {
+                body = new URLSearchParams({
+                    url: buildPath,
+                });
+            }
+            else {
+                if (!fs_1.default.existsSync(buildPath)) {
+                    throw new Error(`Build file not found: ${buildPath}`);
+                }
+                const form = new form_data_1.default();
+                form.append("file", fs_1.default.createReadStream(buildPath));
+                headers = { ...headers, ...form.getHeaders() };
+                body = form;
+            }
+            const fetch = (await import("node-fetch")).default;
+            logger_1.logger.log(`Uploading: ${buildPath}`);
+            const response = await fetch(`${API_BASE_URL}/upload`, {
+                method: "POST",
+                headers,
+                body,
+            });
+            const data = await response.json();
+            appUrl = data.app_url;
+            if (!appUrl) {
+                logger_1.logger.error("Uploading the build failed:", data);
+            }
+        }
+        process.env[envVarKeyForBuild(this.project.name)] = appUrl;
+    }
+    async getDevice() {
+        this.validateConfig();
+        const config = this.createConfig();
+        return await this.createDriver(config);
+    }
+    validateConfig() {
+        const device = this.project.use.device;
+        if (!device.name || !device.osVersion) {
+            throw new Error("Device name and osVersion are required for running tests on BrowserStack");
+        }
+    }
+    async createDriver(config) {
+        const WebDriver = (await import("webdriver")).default;
+        const webDriverClient = await WebDriver.newSession(config);
+        this.sessionId = webDriverClient.sessionId;
+        const bundleId = await this.getAppBundleIdFromSession();
+        const testOptions = {
+            expectTimeout: this.project.use.expectTimeout,
+        };
+        return new device_1.Device(webDriverClient, bundleId, testOptions, this.project.use.device?.provider);
+    }
+    async getSessionDetails() {
+        const data = await getSessionDetails(this.sessionId);
+        this.sessionDetails = data.automation_session;
+    }
+    async getAppBundleIdFromSession() {
+        await this.getSessionDetails();
+        return this.sessionDetails?.app_details.app_name ?? "";
+    }
+    static async downloadVideo(sessionId, outputDir, fileName) {
+        const sessionData = await getSessionDetails(sessionId);
+        const sessionDetails = sessionData?.automation_session;
+        const videoURL = sessionDetails?.video_url;
+        const pathToTestVideo = path_1.default.join(outputDir, `${fileName}.mp4`);
+        const tempPathForWriting = `${pathToTestVideo}.part`;
+        const dir = path_1.default.dirname(pathToTestVideo);
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        /**
+         * The BrowserStack video URL initially returns a 200 status,
+         * but the video file may still be empty. To avoid downloading
+         * an incomplete file, we introduce a delay of 10_000 ms before attempting the download.
+         * After the wait, BrowserStack may return a 403 error if the video is not
+         * yet available. We handle this by retrying the download until we either
+         * receive a 200 response (indicating the video is ready) or reach a maximum
+         * of 10 retries, whichever comes first.
+         */
+        await new Promise((resolve) => setTimeout(resolve, 10_000));
+        const fileStream = fs_1.default.createWriteStream(tempPathForWriting);
+        //To catch the browserstack error in case all retries fails
+        try {
+            if (videoURL) {
+                await (0, async_retry_1.default)(async () => {
+                    const response = await fetch(videoURL, {
+                        method: "GET",
+                    });
+                    if (response.status !== 200) {
+                        // Retry if not 200
+                        throw new Error(`Video not found: ${response.status} (URL: ${videoURL})`);
+                    }
+                    const reader = response.body?.getReader();
+                    if (!reader) {
+                        throw new Error("Failed to get reader from response body.");
+                    }
+                    const streamToFile = async () => {
+                        // eslint-disable-next-line no-constant-condition
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            fileStream.write(value);
+                        }
+                    };
+                    await streamToFile();
+                    fileStream.close();
+                }, {
+                    retries: 10,
+                    minTimeout: 3_000,
+                    onRetry: (err, i) => {
+                        if (i > 5) {
+                            logger_1.logger.warn(`Retry attempt ${i} failed: ${err.message}`);
+                        }
+                    },
+                });
+                return new Promise((resolve, reject) => {
+                    // Ensure file stream is closed even in case of an error
+                    fileStream.on("finish", () => {
+                        try {
+                            fs_1.default.renameSync(tempPathForWriting, pathToTestVideo);
+                            logger_1.logger.log(`Download finished and file closed: ${pathToTestVideo}`);
+                            resolve({ path: pathToTestVideo, contentType: "video/mp4" });
+                        }
+                        catch (err) {
+                            logger_1.logger.error(`Failed to rename file: `, err);
+                            reject(err);
+                        }
+                    });
+                    fileStream.on("error", (err) => {
+                        logger_1.logger.error(`Failed to write file: ${err.message}`);
+                        reject(err);
+                    });
+                });
+            }
+            else {
+                return null;
+            }
+        }
+        catch (e) {
+            logger_1.logger.log(`Error Downloading video: `, e);
+            return null;
+        }
+    }
+    async syncTestDetails(details) {
+        const response = await fetch(`${API_BASE_URL}/sessions/${this.sessionId}.json`, {
+            method: "PUT",
+            headers: {
+                Authorization: getAuthHeader(),
+                "Content-Type": "application/json",
+            },
+            body: details.status
+                ? JSON.stringify({
+                    status: details.status,
+                    reason: details.reason,
+                })
+                : JSON.stringify({
+                    name: details.name,
+                }),
+        });
+        if (!response.ok) {
+            throw new Error(`Error setting session details: ${response.statusText}`);
+        }
+        const responseData = await response.json();
+        return responseData;
+    }
+    createConfig() {
+        const platformName = this.project.use.platform;
+        const projectName = path_1.default.basename(process.cwd());
+        const envVarKey = envVarKeyForBuild(this.project.name);
+        const deviceConfig = this.project.use.device;
+        const configuredAppiumVersion = deviceConfig.appiumVersion ??
+            process.env.BROWSERSTACK_APPIUM_VERSION ??
+            "3.1.0";
+        if (!process.env[envVarKey]) {
+            throw new Error(`process.env.${envVarKey} is not set. Did the file upload work?`);
+        }
+        return {
+            port: 443,
+            path: "/wd/hub",
+            protocol: "https",
+            logLevel: "warn",
+            user: process.env.BROWSERSTACK_USERNAME,
+            key: process.env.BROWSERSTACK_ACCESS_KEY,
+            hostname: "hub.browserstack.com",
+            capabilities: {
+                "bstack:options": {
+                    debug: true,
+                    interactiveDebugging: true,
+                    networkLogs: true,
+                    appiumVersion: configuredAppiumVersion,
+                    enableCameraImageInjection: deviceConfig?.enableCameraImageInjection,
+                    idleTimeout: 180,
+                    deviceName: deviceConfig?.name,
+                    osVersion: deviceConfig.osVersion,
+                    platformName: platformName,
+                    deviceOrientation: deviceConfig?.orientation,
+                    buildName: `${projectName} ${platformName}`,
+                    sessionName: `${projectName} ${platformName} test`,
+                    buildIdentifier: process.env.GITHUB_ACTIONS === "true"
+                        ? `CI ${process.env.GITHUB_RUN_ID}`
+                        : process.env.USER,
+                },
+                "appium:autoGrantPermissions": true,
+                "appium:app": process.env[envVarKey],
+                "appium:autoAcceptAlerts": true,
+                "appium:fullReset": true,
+                "appium:settings[snapshotMaxDepth]": 62,
+            },
+        };
+    }
+}
+exports.BrowserStackDeviceProvider = BrowserStackDeviceProvider;

package/dist/providers/browserstack/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function uploadImageToBS(imagePath: string): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/providers/browserstack/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/providers/browserstack/utils.ts"],"names":[],"mappings":"AAgBA,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBxE"}

package/dist/providers/browserstack/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadImageToBS = uploadImageToBS;
+const fs_1 = __importDefault(require("fs"));
+const form_data_1 = __importDefault(require("form-data"));
+function getAuthHeader() {
+    const userName = process.env.BROWSERSTACK_USERNAME;
+    const accessKey = process.env.BROWSERSTACK_ACCESS_KEY;
+    const key = Buffer.from(`${userName}:${accessKey}`).toString("base64");
+    return `Basic ${key}`;
+}
+async function uploadImageToBS(imagePath) {
+    const formData = new form_data_1.default();
+    if (!fs_1.default.existsSync(imagePath)) {
+        throw new Error(`No image file found at the specified path: ${imagePath}. Please provide a valid image file. 
+Supported formats include JPG, JPEG, and PNG. Ensure the file exists and the path is correct.`);
+    }
+    formData.append("file", fs_1.default.createReadStream(imagePath));
+    formData.append("custom_id", "SampleMedia");
+    const fetch = (await import("node-fetch")).default;
+    const response = await fetch("https://api-cloud.browserstack.com/app-automate/upload-media", {
+        method: "POST",
+        headers: {
+            Authorization: getAuthHeader(),
+        },
+        body: formData,
+    });
+    const data = (await response.json());
+    const imageURL = data.media_url.trim();
+    return imageURL;
+}

package/dist/providers/emulator/index.d.ts

@@ -0,0 +1,13 @@
+import { AppwrightConfig, DeviceProvider } from "../../types";
+import { Device } from "../../device";
+import { FullProject } from "@playwright/test";
+export declare class EmulatorProvider implements DeviceProvider {
+    private project;
+    sessionId?: string;
+    constructor(project: FullProject<AppwrightConfig>, appBundleId: string | undefined);
+    getDevice(): Promise<Device>;
+    globalSetup(): Promise<void>;
+    private createDriver;
+    private createConfig;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/emulator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/emulator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,cAAc,EAIf,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAOtC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C,qBAAa,gBAAiB,YAAW,cAAc;IAInD,OAAO,CAAC,OAAO;IAHjB,SAAS,CAAC,EAAE,MAAM,CAAC;gBAGT,OAAO,EAAE,WAAW,CAAC,eAAe,CAAC,EAC7C,WAAW,EAAE,MAAM,GAAG,SAAS;IAS3B,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5B,WAAW;YA8BH,YAAY;YAwBZ,YAAY;CAmC3B"}