@browserstack/mcp-server 1.0.12 → 1.0.14

package/dist/tools/automate.js

@@ -1,62 +1,69 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNetworkFailures = getNetworkFailures;
-exports.default = addAutomateTools;
-const zod_1 = require("zod");
-const logger_1 = __importDefault(require("../logger"));
-const api_1 = require("../lib/api");
-const instrumentation_1 = require("../lib/instrumentation");
-/**
- * Fetches failed network requests from a BrowserStack Automate session.
- * Returns network requests that resulted in errors or failed to complete.
- */
-async function getNetworkFailures(args) {
+import { z } from "zod";
+import { fetchAutomationScreenshots } from "./automate-utils/fetch-screenshots.js";
+import { SessionType } from "../lib/constants.js";
+import { trackMCP } from "../lib/instrumentation.js";
+import logger from "../logger.js";
+// Tool function that fetches and processes screenshots from BrowserStack Automate session
+export async function fetchAutomationScreenshotsTool(args) {
     try {
-        const failureLogs = await (0, api_1.retrieveNetworkFailures)(args.sessionId);
-        logger_1.default.info("Successfully fetched failure network logs for session: %s", args.sessionId);
-        // Check if there are any failures
-        const hasFailures = failureLogs.totalFailures > 0;
-        const text = hasFailures
-            ? `${failureLogs.totalFailures} network failure(s) found for session :\n\n${JSON.stringify(failureLogs.failures, null, 2)}`
-            : `No network failures found for session`;
+        const screenshots = await fetchAutomationScreenshots(args.sessionId, args.sessionType);
+        if (screenshots.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No screenshots found in the session or some unexpected error occurred",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const results = screenshots.map((screenshot, index) => ({
+            type: "image",
+            text: `Screenshot ${index + 1}`,
+            data: screenshot.base64,
+            mimeType: "image/png",
+            metadata: { url: screenshot.url },
+        }));
         return {
             content: [
                 {
                     type: "text",
-                    text,
+                    text: `Retrieved ${screenshots.length} screenshot(s) from the end of the session.`,
                 },
+                ...results,
             ],
         };
     }
     catch (error) {
-        logger_1.default.error("Failed to fetch network logs: %s", error);
-        throw new Error(error instanceof Error ? error.message : String(error));
+        logger.error("Error during fetching screenshots", error);
+        throw error;
     }
 }
-function addAutomateTools(server) {
-    server.tool("getNetworkFailures", "Use this tool to fetch failed network requests from a BrowserStack Automate session.", {
-        sessionId: zod_1.z.string().describe("The Automate session ID."),
+//Registers the fetchAutomationScreenshots tool with the MCP server
+export default function addAutomationTools(server) {
+    server.tool("fetchAutomationScreenshots", "Fetch and process screenshots from a BrowserStack Automate session", {
+        sessionId: z
+            .string()
+            .describe("The BrowserStack session ID to fetch screenshots from"),
+        sessionType: z
+            .enum([SessionType.Automate, SessionType.AppAutomate])
+            .describe("Type of BrowserStack session"),
     }, async (args) => {
         try {
-            (0, instrumentation_1.trackMCP)("getNetworkFailures", server.server.getClientVersion());
-            return await getNetworkFailures(args);
+            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion());
+            return await fetchAutomationScreenshotsTool(args);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger_1.default.error("Failed to fetch network logs: %s", errorMessage);
-            (0, instrumentation_1.trackMCP)("getNetworkFailures", server.server.getClientVersion(), error);
+            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion(), error);
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to fetch network logs: ${errorMessage}`,
-                        isError: true,
+                        text: `Error during fetching automate screenshots: ${errorMessage}`,
                     },
                 ],
-                isError: true,
             };
         }
     });

package/dist/tools/bstack-sdk.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bootstrapProjectWithSDK = bootstrapProjectWithSDK;
-exports.default = addSDKTools;
-const zod_1 = require("zod");
-const instructions_1 = require("./sdk-utils/instructions");
-const instrumentation_1 = require("../lib/instrumentation");
+import { z } from "zod";
+import { generateBrowserStackYMLInstructions, getInstructionsForProjectConfiguration, } from "./sdk-utils/instructions.js";
+import { trackMCP } from "../lib/instrumentation.js";
 /**
  * BrowserStack SDK hooks into your test framework to seamlessly run tests on BrowserStack.
  * This tool gives instructions to setup a browserstack.yml file in the project root and installs the necessary dependencies.
  */
-async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, }) {
-    const instructions = (0, instructions_1.generateBrowserStackYMLInstructions)(desiredPlatforms);
-    const instructionsForProjectConfiguration = (0, instructions_1.getInstructionsForProjectConfiguration)(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, }) {
+    const instructions = generateBrowserStackYMLInstructions(desiredPlatforms);
+    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
     return {
         content: [
             {
@@ -22,23 +18,23 @@ async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, det
         ],
     };
 }
-function addSDKTools(server) {
+export default function addSDKTools(server) {
     server.tool("runTestsOnBrowserStack", "Use this tool to get instructions for running tests on BrowserStack.", {
-        detectedBrowserAutomationFramework: zod_1.z
+        detectedBrowserAutomationFramework: z
             .string()
             .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
-        detectedTestingFramework: zod_1.z
+        detectedTestingFramework: z
             .string()
             .describe("The testing framework used in the project. Example: 'jest', 'pytest'"),
-        detectedLanguage: zod_1.z
+        detectedLanguage: z
             .string()
             .describe("The programming language used in the project. Example: 'nodejs', 'python'"),
-        desiredPlatforms: zod_1.z
-            .array(zod_1.z.enum(["windows", "macos", "android", "ios"]))
+        desiredPlatforms: z
+            .array(z.enum(["windows", "macos", "android", "ios"]))
             .describe("The platforms the user wants to test on. Always ask this to the user, do not try to infer this."),
     }, async (args) => {
         try {
-            (0, instrumentation_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion());
+            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion());
             return await bootstrapProjectWithSDK({
                 detectedBrowserAutomationFramework: args.detectedBrowserAutomationFramework,
                 detectedTestingFramework: args.detectedTestingFramework,
@@ -47,7 +43,7 @@ function addSDKTools(server) {
             });
         }
         catch (error) {
-            (0, instrumentation_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion(), error);
+            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

package/dist/tools/failurelogs-utils/app-automate.js

@@ -0,0 +1,88 @@
+import config from "../../config.js";
+import { assertOkResponse, filterLinesByKeywords } from "../../lib/utils.js";
+const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
+// DEVICE LOGS
+export async function retrieveDeviceLogs(sessionId, buildId) {
+    const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/deviceLogs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "device logs");
+    const logText = await response.text();
+    return filterDeviceFailures(logText);
+}
+// APPIUM LOGS
+export async function retrieveAppiumLogs(sessionId, buildId) {
+    const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/appiumlogs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "Appium logs");
+    const logText = await response.text();
+    return filterAppiumFailures(logText);
+}
+// CRASH LOGS
+export async function retrieveCrashLogs(sessionId, buildId) {
+    const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/crashlogs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "crash logs");
+    const logText = await response.text();
+    return filterCrashFailures(logText);
+}
+// FILTER HELPERS
+export function filterDeviceFailures(logText) {
+    const keywords = [
+        "error",
+        "exception",
+        "fatal",
+        "anr",
+        "not responding",
+        "process crashed",
+        "crash",
+        "force close",
+        "signal",
+        "java.lang.",
+        "unable to",
+    ];
+    return filterLinesByKeywords(logText, keywords);
+}
+export function filterAppiumFailures(logText) {
+    const keywords = [
+        "error",
+        "fail",
+        "exception",
+        "not found",
+        "no such element",
+        "unable to",
+        "stacktrace",
+        "appium exited",
+        "command failed",
+        "invalid selector",
+    ];
+    return filterLinesByKeywords(logText, keywords);
+}
+export function filterCrashFailures(logText) {
+    const keywords = [
+        "fatal exception",
+        "crash",
+        "signal",
+        "java.lang.",
+        "caused by:",
+        "native crash",
+        "anr",
+        "abort message",
+        "application has stopped unexpectedly",
+    ];
+    return filterLinesByKeywords(logText, keywords);
+}

package/dist/tools/failurelogs-utils/automate.js

@@ -0,0 +1,97 @@
+import config from "../../config.js";
+import { assertOkResponse, filterLinesByKeywords } from "../../lib/utils.js";
+const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
+// NETWORK LOGS
+export async function retrieveNetworkFailures(sessionId) {
+    const url = `https://api.browserstack.com/automate/sessions/${sessionId}/networklogs`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "network logs");
+    const networklogs = await response.json();
+    // Filter for failure logs
+    const failureEntries = networklogs.log.entries.filter((entry) => {
+        return (entry.response.status === 0 ||
+            entry.response.status >= 400 ||
+            entry.response._error !== undefined);
+    });
+    // Return only the failure entries with some context
+    return failureEntries.map((entry) => ({
+        startedDateTime: entry.startedDateTime,
+        request: {
+            method: entry.request?.method,
+            url: entry.request?.url,
+            queryString: entry.request?.queryString,
+        },
+        response: {
+            status: entry.response?.status,
+            statusText: entry.response?.statusText,
+            _error: entry.response?._error,
+        },
+        serverIPAddress: entry.serverIPAddress,
+        time: entry.time,
+    }));
+}
+// SESSION LOGS
+export async function retrieveSessionFailures(sessionId) {
+    const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "session logs");
+    const logText = await response.text();
+    return filterSessionFailures(logText);
+}
+// CONSOLE LOGS
+export async function retrieveConsoleFailures(sessionId) {
+    const url = `https://api.browserstack.com/automate/sessions/${sessionId}/consolelogs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "console logs");
+    const logText = await response.text();
+    return filterConsoleFailures(logText);
+}
+// FILTER: session logs
+export function filterSessionFailures(logText) {
+    const keywords = [
+        "error",
+        "fail",
+        "exception",
+        "fatal",
+        "unable to",
+        "not found",
+        '"success":false',
+        '"success": false',
+        '"msg":',
+        "console.error",
+        "stderr",
+    ];
+    return filterLinesByKeywords(logText, keywords);
+}
+// FILTER: console logs
+export function filterConsoleFailures(logText) {
+    const keywords = [
+        "failed to load resource",
+        "uncaught",
+        "typeerror",
+        "referenceerror",
+        "scanner is not ready",
+        "status of 4",
+        "status of 5",
+        "not found",
+        "undefined",
+        "error:",
+    ];
+    return filterLinesByKeywords(logText, keywords);
+}

package/dist/tools/getFailureLogs.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import logger from "../logger.js";
+import { retrieveNetworkFailures, retrieveSessionFailures, retrieveConsoleFailures, } from "./failurelogs-utils/automate.js";
+import { retrieveDeviceLogs, retrieveAppiumLogs, retrieveCrashLogs, } from "./failurelogs-utils/app-automate.js";
+import { trackMCP } from "../lib/instrumentation.js";
+import { AppAutomateLogType, AutomateLogType, SessionType, } from "../lib/constants.js";
+// Main log fetcher function
+export async function getFailureLogs(args) {
+    const results = [];
+    const errors = [];
+    let validLogTypes = [];
+    if (!args.sessionId) {
+        throw new Error("Session ID is required");
+    }
+    if (args.sessionType === SessionType.AppAutomate && !args.buildId) {
+        throw new Error("Build ID is required for app-automate sessions");
+    }
+    // Validate log types and collect errors
+    validLogTypes = args.logTypes.filter((logType) => {
+        const isAutomate = Object.values(AutomateLogType).includes(logType);
+        const isAppAutomate = Object.values(AppAutomateLogType).includes(logType);
+        if (!isAutomate && !isAppAutomate) {
+            errors.push(`Invalid log type '${logType}'. Valid log types are: ${[
+                ...Object.values(AutomateLogType),
+                ...Object.values(AppAutomateLogType),
+            ].join(", ")}`);
+            return false;
+        }
+        if (args.sessionType === SessionType.Automate && !isAutomate) {
+            errors.push(`Log type '${logType}' is only available for app-automate sessions.`);
+            return false;
+        }
+        if (args.sessionType === SessionType.AppAutomate && !isAppAutomate) {
+            errors.push(`Log type '${logType}' is only available for automate sessions.`);
+            return false;
+        }
+        return true;
+    });
+    if (validLogTypes.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No valid log types found for ${args.sessionType} session.\nErrors encountered:\n${errors.join("\n")}`,
+                    isError: true,
+                },
+            ],
+        };
+    }
+    // eslint-disable-next-line no-useless-catch
+    try {
+        for (const logType of validLogTypes) {
+            switch (logType) {
+                case AutomateLogType.NetworkLogs: {
+                    const logs = await retrieveNetworkFailures(args.sessionId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Network Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No network failures found",
+                    });
+                    break;
+                }
+                case AutomateLogType.SessionLogs: {
+                    const logs = await retrieveSessionFailures(args.sessionId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Session Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No session failures found",
+                    });
+                    break;
+                }
+                case AutomateLogType.ConsoleLogs: {
+                    const logs = await retrieveConsoleFailures(args.sessionId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Console Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No console failures found",
+                    });
+                    break;
+                }
+                case AppAutomateLogType.DeviceLogs: {
+                    const logs = await retrieveDeviceLogs(args.sessionId, args.buildId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Device Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No device failures found",
+                    });
+                    break;
+                }
+                case AppAutomateLogType.AppiumLogs: {
+                    const logs = await retrieveAppiumLogs(args.sessionId, args.buildId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Appium Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No Appium failures found",
+                    });
+                    break;
+                }
+                case AppAutomateLogType.CrashLogs: {
+                    const logs = await retrieveCrashLogs(args.sessionId, args.buildId);
+                    results.push({
+                        type: "text",
+                        text: logs.length > 0
+                            ? `Crash Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+                            : "No crash failures found",
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+    if (errors.length > 0) {
+        results.push({
+            type: "text",
+            text: `Errors encountered:\n${errors.join("\n")}`,
+            isError: true,
+        });
+    }
+    return { content: results };
+}
+// Register tool with the MCP server
+export default function registerGetFailureLogs(server) {
+    server.tool("getFailureLogs", "Fetch various types of logs from a BrowserStack session. Supports both automate and app-automate sessions.", {
+        sessionType: z
+            .enum([SessionType.Automate, SessionType.AppAutomate])
+            .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
+        sessionId: z
+            .string()
+            .describe("The BrowserStack session ID. Must be explicitly provided by the user."),
+        buildId: z
+            .string()
+            .optional()
+            .describe("Required only when sessionType is 'app-automate'. If sessionType is 'app-automate', always ask the user to provide the build ID before proceeding."),
+        logTypes: z
+            .array(z.enum([
+            AutomateLogType.NetworkLogs,
+            AutomateLogType.SessionLogs,
+            AutomateLogType.ConsoleLogs,
+            AppAutomateLogType.DeviceLogs,
+            AppAutomateLogType.AppiumLogs,
+            AppAutomateLogType.CrashLogs,
+        ]))
+            .describe("The types of logs to fetch."),
+    }, async (args) => {
+        try {
+            trackMCP("getFailureLogs", server.server.getClientVersion());
+            return await getFailureLogs(args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            trackMCP("getFailureLogs", server.server.getClientVersion(), error);
+            logger.error("Failed to fetch logs: %s", message);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to fetch logs: ${message}`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/live-utils/desktop-filter.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterDesktop = filterDesktop;
-const device_cache_1 = require("../../lib/device-cache");
-const version_resolver_1 = require("./version-resolver");
-const fuzzy_1 = require("../../lib/fuzzy");
-async function filterDesktop(args) {
-    const data = await (0, device_cache_1.getDevicesAndBrowsers)("live");
+import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
+import { resolveVersion } from "./version-resolver.js";
+import { customFuzzySearch } from "../../lib/fuzzy.js";
+export async function filterDesktop(args) {
+    const data = await getDevicesAndBrowsers(BrowserStackProducts.LIVE);
     const allEntries = getAllDesktopEntries(data);
     // Filter OS
     const osList = filterByOS(allEntries, args.os);
@@ -18,7 +15,7 @@ async function filterDesktop(args) {
     const entriesForOS = filterByOSVersion(browserList, chosenOS);
     // Resolve browser version
     const browserVersions = entriesForOS.map((e) => e.browser_version);
-    const chosenBrowserVersion = (0, version_resolver_1.resolveVersion)(args.browserVersion, browserVersions);
+    const chosenBrowserVersion = resolveVersion(args.browserVersion, browserVersions);
     // Find final entry
     const finalEntry = entriesForOS.find((e) => e.browser_version === chosenBrowserVersion);
     if (!finalEntry) {
@@ -57,7 +54,7 @@ function resolveOSVersion(os, requestedVersion, availableVersions) {
     }
     else {
         // For Windows, use semantic versioning
-        return (0, version_resolver_1.resolveVersion)(requestedVersion, availableVersions);
+        return resolveVersion(requestedVersion, availableVersions);
     }
 }
 function resolveMacOSVersion(requested, available) {
@@ -69,7 +66,7 @@ function resolveMacOSVersion(requested, available) {
     }
     else {
         // Try fuzzy matching
-        const fuzzy = (0, fuzzy_1.customFuzzySearch)(available.map((v) => ({ os_version: v })), ["os_version"], requested, 1);
+        const fuzzy = customFuzzySearch(available.map((v) => ({ os_version: v })), ["os_version"], requested, 1);
         const matched = fuzzy.length ? fuzzy[0].os_version : requested;
         // Fallback if not valid
         return available.includes(matched) ? matched : available[0];

package/dist/tools/live-utils/mobile-filter.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterMobile = filterMobile;
-const device_cache_1 = require("../../lib/device-cache");
-const version_resolver_1 = require("./version-resolver");
-const fuzzy_1 = require("../../lib/fuzzy");
+import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
+import { resolveVersion } from "./version-resolver.js";
+import { customFuzzySearch } from "../../lib/fuzzy.js";
 // Extract all mobile entries from the data
 function getAllMobileEntries(data) {
     return data.mobile.flatMap((grp) => grp.devices.map((d) => ({
@@ -22,7 +19,7 @@ function filterByOS(entries, os) {
 }
 // Find matching device with exact match validation
 function findMatchingDevice(entries, deviceName, os) {
-    const matches = (0, fuzzy_1.customFuzzySearch)(entries, ["display_name"], deviceName, 5);
+    const matches = customFuzzySearch(entries, ["display_name"], deviceName, 5);
     if (!matches.length)
         throw new Error(`No devices matching "${deviceName}" on ${os}.`);
     const exact = matches.find((m) => m.display_name.toLowerCase() === deviceName.toLowerCase());
@@ -38,7 +35,7 @@ function findMatchingDevice(entries, deviceName, os) {
 // Find the appropriate OS version
 function findOSVersion(entries, requestedVersion) {
     const versions = entries.map((d) => d.os_version);
-    const chosenVersion = (0, version_resolver_1.resolveVersion)(requestedVersion, versions);
+    const chosenVersion = resolveVersion(requestedVersion, versions);
     const result = entries.filter((d) => d.os_version === chosenVersion);
     if (!result.length)
         throw new Error(`No entry for OS version "${requestedVersion}".`);
@@ -53,8 +50,8 @@ function createVersionNote(requestedVersion, actualVersion) {
     }
     return "";
 }
-async function filterMobile(args) {
-    const data = await (0, device_cache_1.getDevicesAndBrowsers)("live");
+export async function filterMobile(args) {
+    const data = await getDevicesAndBrowsers(BrowserStackProducts.LIVE);
     const allEntries = getAllMobileEntries(data);
     const osCandidates = filterByOS(allEntries, args.os);
     const deviceCandidates = findMatchingDevice(osCandidates, args.device, args.os);