@browserstack/mcp-server 1.0.13 → 1.0.15

package/dist/tools/accessibility.js

@@ -1,36 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addAccessibilityTools;
-const zod_1 = require("zod");
-const accessibility_1 = require("./accessiblity-utils/accessibility");
-const instrumentation_1 = require("../lib/instrumentation");
-async function runAccessibilityScan(name, pageURL) {
-    const response = await (0, accessibility_1.startAccessibilityScan)(name, [pageURL]);
-    const scanId = response.data?.id;
-    const scanRunId = response.data?.scanRunId;
-    if (!scanId || !scanRunId) {
-        throw new Error("Unable to start a accessibility scan, please try again later or open an issue on GitHub if the problem persists");
+import { z } from "zod";
+import { AccessibilityScanner } from "./accessiblity-utils/scanner.js";
+import { AccessibilityReportFetcher } from "./accessiblity-utils/report-fetcher.js";
+import { trackMCP } from "../lib/instrumentation.js";
+import { parseAccessibilityReportFromCSV } from "./accessiblity-utils/report-parser.js";
+const scanner = new AccessibilityScanner();
+const reportFetcher = new AccessibilityReportFetcher();
+async function runAccessibilityScan(name, pageURL, context) {
+    // Start scan
+    const startResp = await scanner.startScan(name, [pageURL]);
+    const scanId = startResp.data.id;
+    const scanRunId = startResp.data.scanRunId;
+    // Notify scan start
+    await context.sendNotification({
+        method: "notifications/progress",
+        params: {
+            progressToken: context._meta?.progressToken ?? "NOT_FOUND",
+            message: `Accessibility scan "${name}" started`,
+            progress: 0,
+            total: 100,
+        },
+    });
+    // Wait until scan completes
+    const status = await scanner.waitUntilComplete(scanId, scanRunId, context);
+    if (status !== "completed") {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Accessibility scan "${name}" failed with status: ${status} , check the BrowserStack dashboard for more details [https://scanner.browserstack.com/site-scanner/scan-details/${name}].`,
+                    isError: true,
+                },
+            ],
+            isError: true,
+        };
     }
+    // Fetch CSV report link
+    const reportLink = await reportFetcher.getReportLink(scanId, scanRunId);
+    const { records } = await parseAccessibilityReportFromCSV(reportLink);
     return {
         content: [
             {
                 type: "text",
-                text: `Successfully queued accessibility scan, you will get a report via email within 5 minutes.`,
+                text: `✅ Accessibility scan "${name}" completed. check the BrowserStack dashboard for more details [https://scanner.browserstack.com/site-scanner/scan-details/${name}].`,
+            },
+            {
+                type: "text",
+                text: `Scan results: ${JSON.stringify(records, null, 2)}`,
             },
         ],
     };
 }
-function addAccessibilityTools(server) {
-    server.tool("startAccessibilityScan", "Use this tool to start an accessibility scan for a list of URLs on BrowserStack.", {
-        name: zod_1.z.string().describe("Name of the accessibility scan"),
-        pageURL: zod_1.z.string().describe("The URL to scan for accessibility issues"),
-    }, async (args) => {
+export default function addAccessibilityTools(server) {
+    server.tool("startAccessibilityScan", "Start an accessibility scan via BrowserStack and retrieve a local CSV report path.", {
+        name: z.string().describe("Name of the accessibility scan"),
+        pageURL: z.string().describe("The URL to scan for accessibility issues"),
+    }, async (args, context) => {
         try {
-            (0, instrumentation_1.trackMCP)("startAccessibilityScan", server.server.getClientVersion());
-            return await runAccessibilityScan(args.name, args.pageURL);
+            trackMCP("startAccessibilityScan", server.server.getClientVersion());
+            return await runAccessibilityScan(args.name, args.pageURL, context);
         }
         catch (error) {
-            (0, instrumentation_1.trackMCP)("startAccessibilityScan", server.server.getClientVersion(), error);
+            trackMCP("startAccessibilityScan", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

package/dist/tools/accessiblity-utils/report-fetcher.js

@@ -0,0 +1,28 @@
+import axios from "axios";
+import config from "../../config.js";
+export class AccessibilityReportFetcher {
+    auth = {
+        username: config.browserstackUsername,
+        password: config.browserstackAccessKey,
+    };
+    async getReportLink(scanId, scanRunId) {
+        // Initiate CSV link generation
+        const initUrl = `https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/issues?scan_run_id=${scanRunId}`;
+        const initResp = await axios.get(initUrl, {
+            auth: this.auth,
+        });
+        if (!initResp.data.success) {
+            throw new Error(`Failed to initiate report: ${initResp.data.error || initResp.data.data.message}`);
+        }
+        const taskId = initResp.data.data.task_id;
+        // Fetch the generated CSV link
+        const reportUrl = `https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/issues?task_id=${encodeURIComponent(taskId)}`;
+        const reportResp = await axios.get(reportUrl, {
+            auth: this.auth,
+        });
+        if (!reportResp.data.success) {
+            throw new Error(`Failed to fetch report: ${reportResp.data.error}`);
+        }
+        return reportResp.data.data.reportLink;
+    }
+}

package/dist/tools/accessiblity-utils/report-parser.js

@@ -0,0 +1,51 @@
+import fetch from "node-fetch";
+import { parse } from "csv-parse/sync";
+export async function parseAccessibilityReportFromCSV(reportLink, { maxCharacterLength = 10_000, nextPage = 0 } = {}) {
+    // 1) Download & parse
+    const res = await fetch(reportLink);
+    if (!res.ok)
+        throw new Error(`Failed to download report: ${res.statusText}`);
+    const text = await res.text();
+    const all = parse(text, {
+        columns: true,
+        skip_empty_lines: true,
+    }).map((row) => ({
+        issue_type: row["Issue type"],
+        component: row["Component"],
+        issue_description: row["Issue description"],
+        HTML_snippet: row["HTML snippet"],
+        how_to_fix: row["How to fix this issue"],
+        severity: (row["Severity"] || "unknown").trim(),
+    }));
+    // 2) Sort by severity
+    const order = {
+        critical: 0,
+        serious: 1,
+        moderate: 2,
+        minor: 3,
+    };
+    all.sort((a, b) => (order[a.severity] ?? 99) - (order[b.severity] ?? 99));
+    // 3) Walk to the starting offset
+    let charCursor = 0;
+    let idx = 0;
+    for (; idx < all.length; idx++) {
+        const len = JSON.stringify(all[idx]).length;
+        if (charCursor + len > nextPage)
+            break;
+        charCursor += len;
+    }
+    // 4) Collect up to maxCharacterLength
+    const page = [];
+    for (let i = idx; i < all.length; i++) {
+        const recStr = JSON.stringify(all[i]);
+        if (charCursor - nextPage + recStr.length > maxCharacterLength)
+            break;
+        page.push(all[i]);
+        charCursor += recStr.length;
+    }
+    const hasMore = idx + page.length < all.length;
+    return {
+        records: page,
+        next_page: hasMore ? charCursor : null,
+    };
+}

package/dist/tools/accessiblity-utils/scanner.js

@@ -0,0 +1,80 @@
+import axios from "axios";
+import config from "../../config.js";
+export class AccessibilityScanner {
+    auth = {
+        username: config.browserstackUsername,
+        password: config.browserstackAccessKey,
+    };
+    async startScan(name, urlList) {
+        try {
+            const { data } = await axios.post("https://api-accessibility.browserstack.com/api/website-scanner/v1/scans", { name, urlList, recurring: false }, { auth: this.auth });
+            if (!data.success)
+                throw new Error(`Unable to start scan: ${data.errors?.join(", ")}`);
+            return data;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response?.data) {
+                const msg = err.response.data.error ||
+                    err.response.data.message ||
+                    err.message;
+                throw new Error(`Failed to start scan: ${msg}`);
+            }
+            throw err;
+        }
+    }
+    async pollStatus(scanId, scanRunId) {
+        try {
+            const { data } = await axios.get(`https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/${scanRunId}/status`, { auth: this.auth });
+            if (!data.success)
+                throw new Error(`Failed to get status: ${data.errors?.join(", ")}`);
+            return data;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err) && err.response?.data) {
+                const msg = err.response.data.message || err.message;
+                throw new Error(`Failed to get scan status: ${msg}`);
+            }
+            throw err;
+        }
+    }
+    async waitUntilComplete(scanId, scanRunId, context) {
+        return new Promise((resolve, reject) => {
+            let timepercent = 0;
+            let dotCount = 1;
+            const interval = setInterval(async () => {
+                try {
+                    const statusResp = await this.pollStatus(scanId, scanRunId);
+                    const status = statusResp.data.status;
+                    timepercent += 1.67;
+                    const progress = status === "completed" ? 100 : timepercent;
+                    const dots = ".".repeat(dotCount);
+                    dotCount = (dotCount % 4) + 1;
+                    const message = status === "completed" || status === "failed"
+                        ? `Scan completed with status: ${status}`
+                        : `Scan in progress${dots}`;
+                    await context.sendNotification({
+                        method: "notifications/progress",
+                        params: {
+                            progressToken: context._meta?.progressToken ?? "NOT_FOUND",
+                            message: message,
+                            progress: progress,
+                            total: 100,
+                        },
+                    });
+                    if (status === "completed" || status === "failed") {
+                        clearInterval(interval);
+                        resolve(status);
+                    }
+                }
+                catch (e) {
+                    clearInterval(interval);
+                    reject(e);
+                }
+            }, 5000);
+            setTimeout(() => {
+                clearInterval(interval);
+                reject(new Error("Scan timed out after 5 minutes"));
+            }, 5 * 60 * 1000);
+        });
+    }
+}

package/dist/tools/appautomate-utils/appautomate.js

@@ -0,0 +1,95 @@
+import fs from "fs";
+import axios from "axios";
+import config from "../../config.js";
+import FormData from "form-data";
+import { customFuzzySearch } from "../../lib/fuzzy.js";
+/**
+ * Finds devices that exactly match the provided display name.
+ * Uses fuzzy search first, and then filters for exact case-insensitive match.
+ */
+export function findMatchingDevice(devices, deviceName) {
+    const matches = customFuzzySearch(devices, ["display_name"], deviceName, 5);
+    if (matches.length === 0) {
+        const availableDevices = [
+            ...new Set(devices.map((d) => d.display_name)),
+        ].join(", ");
+        throw new Error(`No devices found matching "${deviceName}". Available devices: ${availableDevices}`);
+    }
+    const exactMatches = matches.filter((m) => m.display_name.toLowerCase() === deviceName.toLowerCase());
+    if (exactMatches.length === 0) {
+        const suggestions = [...new Set(matches.map((d) => d.display_name))].join(", ");
+        throw new Error(`Alternative devices found: ${suggestions}. Please select one of these exact device names.`);
+    }
+    return exactMatches;
+}
+/**
+ * Extracts all unique OS versions from a device list and sorts them.
+ */
+export function getDeviceVersions(devices) {
+    return [...new Set(devices.map((d) => d.os_version))].sort();
+}
+/**
+ * Resolves the requested platform version against available versions.
+ * Supports 'latest' and 'oldest' as dynamic selectors.
+ */
+export function resolveVersion(versions, requestedVersion) {
+    if (requestedVersion === "latest") {
+        return versions[versions.length - 1];
+    }
+    if (requestedVersion === "oldest") {
+        return versions[0];
+    }
+    const match = versions.find((v) => v === requestedVersion);
+    if (!match) {
+        throw new Error(`Version "${requestedVersion}" not found. Available versions: ${versions.join(", ")}`);
+    }
+    return match;
+}
+/**
+ * Validates the input arguments for taking app screenshots.
+ * Checks for presence and correctness of platform, device, and file types.
+ */
+export function validateArgs(args) {
+    const { desiredPlatform, desiredPlatformVersion, appPath, desiredPhone } = args;
+    if (!desiredPlatform || !desiredPhone) {
+        throw new Error("Missing required arguments: desiredPlatform and desiredPhone are required");
+    }
+    if (!desiredPlatformVersion) {
+        throw new Error("Missing required arguments: desiredPlatformVersion is required");
+    }
+    if (!appPath) {
+        throw new Error("You must provide an appPath.");
+    }
+    if (desiredPlatform === "android" && !appPath.endsWith(".apk")) {
+        throw new Error("You must provide a valid Android app path (.apk).");
+    }
+    if (desiredPlatform === "ios" && !appPath.endsWith(".ipa")) {
+        throw new Error("You must provide a valid iOS app path (.ipa).");
+    }
+}
+/**
+ * Uploads an application file to AppAutomate and returns the app URL
+ */
+export async function uploadApp(appPath) {
+    const filePath = appPath;
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found at path: ${filePath}`);
+    }
+    const formData = new FormData();
+    formData.append("file", fs.createReadStream(filePath));
+    const response = await axios.post("https://api-cloud.browserstack.com/app-automate/upload", formData, {
+        headers: {
+            ...formData.getHeaders(),
+        },
+        auth: {
+            username: config.browserstackUsername,
+            password: config.browserstackAccessKey,
+        },
+    });
+    if (response.data.app_url) {
+        return response.data.app_url;
+    }
+    else {
+        throw new Error(`Failed to upload app: ${response.data}`);
+    }
+}

package/dist/tools/appautomate.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import logger from "../logger.js";
+import config from "../config.js";
+import { trackMCP } from "../lib/instrumentation.js";
+import { maybeCompressBase64 } from "../lib/utils.js";
+import { remote } from "webdriverio";
+import { getDevicesAndBrowsers, BrowserStackProducts, } from "../lib/device-cache.js";
+import { findMatchingDevice, getDeviceVersions, resolveVersion, validateArgs, uploadApp, } from "./appautomate-utils/appautomate.js";
+var Platform;
+(function (Platform) {
+    Platform["ANDROID"] = "android";
+    Platform["IOS"] = "ios";
+})(Platform || (Platform = {}));
+/**
+ * Launches an app on a selected BrowserStack device and takes a screenshot.
+ */
+async function takeAppScreenshot(args) {
+    let driver;
+    try {
+        validateArgs(args);
+        const { desiredPlatform, desiredPhone, appPath } = args;
+        let { desiredPlatformVersion } = args;
+        const platforms = (await getDevicesAndBrowsers(BrowserStackProducts.APP_AUTOMATE)).mobile;
+        const platformData = platforms.find((p) => p.os === desiredPlatform.toLowerCase());
+        if (!platformData) {
+            throw new Error(`Platform ${desiredPlatform} not found in device cache.`);
+        }
+        const matchingDevices = findMatchingDevice(platformData.devices, desiredPhone);
+        const availableVersions = getDeviceVersions(matchingDevices);
+        desiredPlatformVersion = resolveVersion(availableVersions, desiredPlatformVersion);
+        const selectedDevice = matchingDevices.find((d) => d.os_version === desiredPlatformVersion);
+        if (!selectedDevice) {
+            throw new Error(`Device "${desiredPhone}" with version ${desiredPlatformVersion} not found.`);
+        }
+        const app_url = await uploadApp(appPath);
+        logger.info(`App uploaded. URL: ${app_url}`);
+        const capabilities = {
+            platformName: desiredPlatform,
+            "appium:platformVersion": selectedDevice.os_version,
+            "appium:deviceName": selectedDevice.device,
+            "appium:app": app_url,
+            "appium:autoGrantPermissions": true,
+            "bstack:options": {
+                userName: config.browserstackUsername,
+                accessKey: config.browserstackAccessKey,
+                appiumVersion: "2.0.1",
+            },
+        };
+        logger.info("Starting WebDriver session on BrowserStack...");
+        driver = await remote({
+            protocol: "https",
+            hostname: "hub.browserstack.com",
+            port: 443,
+            path: "/wd/hub",
+            capabilities,
+        });
+        const screenshotBase64 = await driver.takeScreenshot();
+        const compressed = await maybeCompressBase64(screenshotBase64);
+        return {
+            content: [
+                {
+                    type: "image",
+                    data: compressed,
+                    mimeType: "image/png",
+                    name: `screenshot-${selectedDevice.device}-${Date.now()}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.error("Error during app automation or screenshot capture", error);
+        throw error;
+    }
+    finally {
+        if (driver) {
+            logger.info("Cleaning up WebDriver session...");
+            await driver.deleteSession();
+        }
+    }
+}
+/**
+ * Registers the `takeAppScreenshot` tool with the MCP server.
+ */
+export default function addAppAutomationTools(server) {
+    server.tool("takeAppScreenshot", "Use this tool to take a screenshot of an app running on a BrowserStack device. This is useful for visual testing and debugging.", {
+        desiredPhone: z
+            .string()
+            .describe("The full name of the device to run the app on. Example: 'iPhone 12 Pro' or 'Samsung Galaxy S20'. Always ask the user for the device they want to use."),
+        desiredPlatformVersion: z
+            .string()
+            .describe("The platform version to run the app on. Use 'latest' or 'oldest' for dynamic resolution."),
+        desiredPlatform: z
+            .enum([Platform.ANDROID, Platform.IOS])
+            .describe("Platform to run the app on. Either 'android' or 'ios'."),
+        appPath: z
+            .string()
+            .describe("The path to the .apk or .ipa file. Required for app installation."),
+    }, async (args) => {
+        try {
+            trackMCP("takeAppScreenshot", server.server.getClientVersion());
+            return await takeAppScreenshot(args);
+        }
+        catch (error) {
+            trackMCP("takeAppScreenshot", server.server.getClientVersion(), error);
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error during app automation or screenshot capture: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/applive-utils/fuzzy-search.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fuzzySearchDevices = fuzzySearchDevices;
-const fuzzy_1 = require("../../lib/fuzzy");
+import { customFuzzySearch } from "../../lib/fuzzy.js";
 /**
  * Fuzzy searches App Live device entries by name.
  */
-async function fuzzySearchDevices(devices, query, limit = 5) {
-    const top_match = (0, fuzzy_1.customFuzzySearch)(devices, ["device", "display_name"], query, limit);
+export async function fuzzySearchDevices(devices, query, limit = 5) {
+    const top_match = customFuzzySearch(devices, ["device", "display_name"], query, limit);
     return top_match;
 }

package/dist/tools/applive-utils/start-session.js

@@ -1,31 +1,25 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startSession = startSession;
-const child_process_1 = __importDefault(require("child_process"));
-const logger_1 = __importDefault(require("../../logger"));
-const device_cache_1 = require("../../lib/device-cache");
-const fuzzy_search_1 = require("./fuzzy-search");
-const utils_1 = require("../../lib/utils");
-const upload_app_1 = require("./upload-app");
+import childProcess from "child_process";
+import logger from "../../logger.js";
+import { BrowserStackProducts, getDevicesAndBrowsers, } from "../../lib/device-cache.js";
+import { fuzzySearchDevices } from "./fuzzy-search.js";
+import { sanitizeUrlParam } from "../../lib/utils.js";
+import { uploadApp } from "./upload-app.js";
 /**
  * Starts an App Live session after filtering, fuzzy matching, and launching.
  * @param args - The arguments for starting the session.
  * @returns The launch URL for the session.
  * @throws Will throw an error if no devices are found or if the app URL is invalid.
  */
-async function startSession(args) {
+export async function startSession(args) {
     const { appPath, desiredPlatform, desiredPhone } = args;
     let { desiredPlatformVersion } = args;
-    const data = await (0, device_cache_1.getDevicesAndBrowsers)("app_live");
+    const data = await getDevicesAndBrowsers(BrowserStackProducts.APP_LIVE);
     const allDevices = data.mobile.flatMap((group) => group.devices.map((dev) => ({ ...dev, os: group.os })));
     desiredPlatformVersion = resolvePlatformVersion(allDevices, desiredPlatform, desiredPlatformVersion);
     const filteredDevices = filterDevicesByPlatformAndVersion(allDevices, desiredPlatform, desiredPlatformVersion);
-    const matches = await (0, fuzzy_search_1.fuzzySearchDevices)(filteredDevices, desiredPhone);
+    const matches = await fuzzySearchDevices(filteredDevices, desiredPhone);
     const selectedDevice = validateAndSelectDevice(matches, desiredPhone, desiredPlatform, desiredPlatformVersion);
-    const { app_url } = await (0, upload_app_1.uploadApp)(appPath);
+    const { app_url } = await uploadApp(appPath);
     validateAppUrl(app_url);
     const launchUrl = constructLaunchUrl(app_url, selectedDevice, desiredPlatform, desiredPlatformVersion);
     openBrowser(launchUrl);
@@ -120,7 +114,7 @@ function validateAppUrl(appUrl) {
  * @returns The constructed launch URL.
  */
 function constructLaunchUrl(appUrl, device, desiredPlatform, desiredPlatformVersion) {
-    const deviceParam = (0, utils_1.sanitizeUrlParam)(device.display_name.replace(/\s+/g, "+"));
+    const deviceParam = sanitizeUrlParam(device.display_name.replace(/\s+/g, "+"));
     const params = new URLSearchParams({
         os: desiredPlatform,
         os_version: desiredPlatformVersion,
@@ -144,16 +138,16 @@ function openBrowser(launchUrl) {
                 ? ["cmd", "/c", "start", launchUrl]
                 : ["xdg-open", launchUrl];
         // nosemgrep:javascript.lang.security.detect-child-process.detect-child-process
-        const child = child_process_1.default.spawn(command[0], command.slice(1), {
+        const child = childProcess.spawn(command[0], command.slice(1), {
             stdio: "ignore",
             detached: true,
         });
         child.on("error", (error) => {
-            logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
+            logger.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
         });
         child.unref();
     }
     catch (error) {
-        logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
+        logger.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
     }
 }

package/dist/tools/applive-utils/upload-app.js

@@ -1,66 +1,27 @@
-"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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadApp = uploadApp;
-const axios_1 = __importStar(require("axios"));
-const form_data_1 = __importDefault(require("form-data"));
-const fs_1 = __importDefault(require("fs"));
-const config_1 = __importDefault(require("../../config"));
-async function uploadApp(filePath) {
-    if (!fs_1.default.existsSync(filePath)) {
+import axios, { AxiosError } from "axios";
+import FormData from "form-data";
+import fs from "fs";
+import config from "../../config.js";
+export async function uploadApp(filePath) {
+    if (!fs.existsSync(filePath)) {
         throw new Error(`File not found at path: ${filePath}`);
     }
-    const formData = new form_data_1.default();
-    formData.append("file", fs_1.default.createReadStream(filePath));
+    const formData = new FormData();
+    formData.append("file", fs.createReadStream(filePath));
     try {
-        const response = await axios_1.default.post("https://api-cloud.browserstack.com/app-live/upload", formData, {
+        const response = await axios.post("https://api-cloud.browserstack.com/app-live/upload", formData, {
             headers: {
                 ...formData.getHeaders(),
             },
             auth: {
-                username: config_1.default.browserstackUsername,
-                password: config_1.default.browserstackAccessKey,
+                username: config.browserstackUsername,
+                password: config.browserstackAccessKey,
             },
         });
         return response.data;
     }
     catch (error) {
-        if (error instanceof axios_1.AxiosError) {
+        if (error instanceof AxiosError) {
             throw new Error(`Failed to upload app: ${error.response?.data?.message || error.message}`);
         }
         throw error;