@browserstack/mcp-server 1.1.0 → 1.1.1

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_js_1 = require("./sdk-utils/instructions.js");
-const instrumentation_js_1 = require("../lib/instrumentation.js");
+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_js_1.generateBrowserStackYMLInstructions)(desiredPlatforms);
-    const instructionsForProjectConfiguration = (0, instructions_js_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_js_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_js_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion(), error);
+            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

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

@@ -1,19 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveDeviceLogs = retrieveDeviceLogs;
-exports.retrieveAppiumLogs = retrieveAppiumLogs;
-exports.retrieveCrashLogs = retrieveCrashLogs;
-exports.filterDeviceFailures = filterDeviceFailures;
-exports.filterAppiumFailures = filterAppiumFailures;
-exports.filterCrashFailures = filterCrashFailures;
-const config_js_1 = __importDefault(require("../../config.js"));
-const utils_js_1 = require("../../lib/utils.js");
-const auth = Buffer.from(`${config_js_1.default.browserstackUsername}:${config_js_1.default.browserstackAccessKey}`).toString("base64");
+import config from "../../config.js";
+import { assertOkResponse, filterLinesByKeywords } from "../../lib/utils.js";
+const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
 // DEVICE LOGS
-async function retrieveDeviceLogs(sessionId, buildId) {
+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: {
@@ -21,12 +10,12 @@ async function retrieveDeviceLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "device logs");
+    await assertOkResponse(response, "device logs");
     const logText = await response.text();
     return filterDeviceFailures(logText);
 }
 // APPIUM LOGS
-async function retrieveAppiumLogs(sessionId, buildId) {
+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: {
@@ -34,12 +23,12 @@ async function retrieveAppiumLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "Appium logs");
+    await assertOkResponse(response, "Appium logs");
     const logText = await response.text();
     return filterAppiumFailures(logText);
 }
 // CRASH LOGS
-async function retrieveCrashLogs(sessionId, buildId) {
+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: {
@@ -47,12 +36,12 @@ async function retrieveCrashLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "crash logs");
+    await assertOkResponse(response, "crash logs");
     const logText = await response.text();
     return filterCrashFailures(logText);
 }
 // FILTER HELPERS
-function filterDeviceFailures(logText) {
+export function filterDeviceFailures(logText) {
     const keywords = [
         "error",
         "exception",
@@ -66,9 +55,9 @@ function filterDeviceFailures(logText) {
         "java.lang.",
         "unable to",
     ];
-    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
+    return filterLinesByKeywords(logText, keywords);
 }
-function filterAppiumFailures(logText) {
+export function filterAppiumFailures(logText) {
     const keywords = [
         "error",
         "fail",
@@ -81,9 +70,9 @@ function filterAppiumFailures(logText) {
         "command failed",
         "invalid selector",
     ];
-    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
+    return filterLinesByKeywords(logText, keywords);
 }
-function filterCrashFailures(logText) {
+export function filterCrashFailures(logText) {
     const keywords = [
         "fatal exception",
         "crash",
@@ -95,5 +84,5 @@ function filterCrashFailures(logText) {
         "abort message",
         "application has stopped unexpectedly",
     ];
-    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
+    return filterLinesByKeywords(logText, keywords);
 }

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

@@ -1,18 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveNetworkFailures = retrieveNetworkFailures;
-exports.retrieveSessionFailures = retrieveSessionFailures;
-exports.retrieveConsoleFailures = retrieveConsoleFailures;
-exports.filterSessionFailures = filterSessionFailures;
-exports.filterConsoleFailures = filterConsoleFailures;
-const config_js_1 = __importDefault(require("../../config.js"));
-const utils_js_1 = require("../../lib/utils.js");
-const auth = Buffer.from(`${config_js_1.default.browserstackUsername}:${config_js_1.default.browserstackAccessKey}`).toString("base64");
+import config from "../../config.js";
+import { assertOkResponse, filterLinesByKeywords } from "../../lib/utils.js";
+const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
 // NETWORK LOGS
-async function retrieveNetworkFailures(sessionId) {
+export async function retrieveNetworkFailures(sessionId) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/networklogs`;
     const response = await fetch(url, {
         method: "GET",
@@ -21,7 +11,7 @@ async function retrieveNetworkFailures(sessionId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "network logs");
+    await assertOkResponse(response, "network logs");
     const networklogs = await response.json();
     // Filter for failure logs
     const failureEntries = networklogs.log.entries.filter((entry) => {
@@ -47,7 +37,7 @@ async function retrieveNetworkFailures(sessionId) {
     }));
 }
 // SESSION LOGS
-async function retrieveSessionFailures(sessionId) {
+export async function retrieveSessionFailures(sessionId) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
     const response = await fetch(url, {
         headers: {
@@ -55,12 +45,12 @@ async function retrieveSessionFailures(sessionId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "session logs");
+    await assertOkResponse(response, "session logs");
     const logText = await response.text();
     return filterSessionFailures(logText);
 }
 // CONSOLE LOGS
-async function retrieveConsoleFailures(sessionId) {
+export async function retrieveConsoleFailures(sessionId) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/consolelogs`;
     const response = await fetch(url, {
         headers: {
@@ -68,12 +58,12 @@ async function retrieveConsoleFailures(sessionId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await (0, utils_js_1.assertOkResponse)(response, "console logs");
+    await assertOkResponse(response, "console logs");
     const logText = await response.text();
     return filterConsoleFailures(logText);
 }
 // FILTER: session logs
-function filterSessionFailures(logText) {
+export function filterSessionFailures(logText) {
     const keywords = [
         "error",
         "fail",
@@ -87,10 +77,10 @@ function filterSessionFailures(logText) {
         "console.error",
         "stderr",
     ];
-    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
+    return filterLinesByKeywords(logText, keywords);
 }
 // FILTER: console logs
-function filterConsoleFailures(logText) {
+export function filterConsoleFailures(logText) {
     const keywords = [
         "failed to load resource",
         "uncaught",
@@ -103,5 +93,5 @@ function filterConsoleFailures(logText) {
         "undefined",
         "error:",
     ];
-    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
+    return filterLinesByKeywords(logText, keywords);
 }

package/dist/tools/getFailureLogs.js

@@ -1,43 +1,36 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFailureLogs = getFailureLogs;
-exports.default = registerGetFailureLogs;
-const zod_1 = require("zod");
-const logger_js_1 = __importDefault(require("../logger.js"));
-const automate_js_1 = require("./failurelogs-utils/automate.js");
-const app_automate_js_1 = require("./failurelogs-utils/app-automate.js");
-const instrumentation_js_1 = require("../lib/instrumentation.js");
-const constants_js_1 = require("../lib/constants.js");
+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
-async function getFailureLogs(args) {
+export async function getFailureLogs(args) {
     const results = [];
     const errors = [];
     let validLogTypes = [];
     if (!args.sessionId) {
         throw new Error("Session ID is required");
     }
-    if (args.sessionType === constants_js_1.SessionType.AppAutomate && !args.buildId) {
+    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(constants_js_1.AutomateLogType).includes(logType);
-        const isAppAutomate = Object.values(constants_js_1.AppAutomateLogType).includes(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(constants_js_1.AutomateLogType),
-                ...Object.values(constants_js_1.AppAutomateLogType),
+                ...Object.values(AutomateLogType),
+                ...Object.values(AppAutomateLogType),
             ].join(", ")}`);
             return false;
         }
-        if (args.sessionType === constants_js_1.SessionType.Automate && !isAutomate) {
+        if (args.sessionType === SessionType.Automate && !isAutomate) {
             errors.push(`Log type '${logType}' is only available for app-automate sessions.`);
             return false;
         }
-        if (args.sessionType === constants_js_1.SessionType.AppAutomate && !isAppAutomate) {
+        if (args.sessionType === SessionType.AppAutomate && !isAppAutomate) {
             errors.push(`Log type '${logType}' is only available for automate sessions.`);
             return false;
         }
@@ -58,8 +51,8 @@ async function getFailureLogs(args) {
     try {
         for (const logType of validLogTypes) {
             switch (logType) {
-                case constants_js_1.AutomateLogType.NetworkLogs: {
-                    const logs = await (0, automate_js_1.retrieveNetworkFailures)(args.sessionId);
+                case AutomateLogType.NetworkLogs: {
+                    const logs = await retrieveNetworkFailures(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -68,8 +61,8 @@ async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case constants_js_1.AutomateLogType.SessionLogs: {
-                    const logs = await (0, automate_js_1.retrieveSessionFailures)(args.sessionId);
+                case AutomateLogType.SessionLogs: {
+                    const logs = await retrieveSessionFailures(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -78,8 +71,8 @@ async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case constants_js_1.AutomateLogType.ConsoleLogs: {
-                    const logs = await (0, automate_js_1.retrieveConsoleFailures)(args.sessionId);
+                case AutomateLogType.ConsoleLogs: {
+                    const logs = await retrieveConsoleFailures(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -88,8 +81,8 @@ async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case constants_js_1.AppAutomateLogType.DeviceLogs: {
-                    const logs = await (0, app_automate_js_1.retrieveDeviceLogs)(args.sessionId, args.buildId);
+                case AppAutomateLogType.DeviceLogs: {
+                    const logs = await retrieveDeviceLogs(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -98,8 +91,8 @@ async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case constants_js_1.AppAutomateLogType.AppiumLogs: {
-                    const logs = await (0, app_automate_js_1.retrieveAppiumLogs)(args.sessionId, args.buildId);
+                case AppAutomateLogType.AppiumLogs: {
+                    const logs = await retrieveAppiumLogs(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -108,8 +101,8 @@ async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case constants_js_1.AppAutomateLogType.CrashLogs: {
-                    const logs = await (0, app_automate_js_1.retrieveCrashLogs)(args.sessionId, args.buildId);
+                case AppAutomateLogType.CrashLogs: {
+                    const logs = await retrieveCrashLogs(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -134,37 +127,37 @@ async function getFailureLogs(args) {
     return { content: results };
 }
 // Register tool with the MCP server
-function registerGetFailureLogs(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: zod_1.z
-            .enum([constants_js_1.SessionType.Automate, constants_js_1.SessionType.AppAutomate])
+        sessionType: z
+            .enum([SessionType.Automate, SessionType.AppAutomate])
             .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
-        sessionId: zod_1.z
+        sessionId: z
             .string()
             .describe("The BrowserStack session ID. Must be explicitly provided by the user."),
-        buildId: zod_1.z
+        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: zod_1.z
-            .array(zod_1.z.enum([
-            constants_js_1.AutomateLogType.NetworkLogs,
-            constants_js_1.AutomateLogType.SessionLogs,
-            constants_js_1.AutomateLogType.ConsoleLogs,
-            constants_js_1.AppAutomateLogType.DeviceLogs,
-            constants_js_1.AppAutomateLogType.AppiumLogs,
-            constants_js_1.AppAutomateLogType.CrashLogs,
+        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 {
-            (0, instrumentation_js_1.trackMCP)("getFailureLogs", server.server.getClientVersion());
+            trackMCP("getFailureLogs", server.server.getClientVersion());
             return await getFailureLogs(args);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            (0, instrumentation_js_1.trackMCP)("getFailureLogs", server.server.getClientVersion(), error);
-            logger_js_1.default.error("Failed to fetch logs: %s", message);
+            trackMCP("getFailureLogs", server.server.getClientVersion(), error);
+            logger.error("Failed to fetch logs: %s", message);
             return {
                 content: [
                     {

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_js_1 = require("../../lib/device-cache.js");
-const version_resolver_js_1 = require("./version-resolver.js");
-const fuzzy_js_1 = require("../../lib/fuzzy.js");
-async function filterDesktop(args) {
-    const data = await (0, device_cache_js_1.getDevicesAndBrowsers)(device_cache_js_1.BrowserStackProducts.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_js_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_js_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_js_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_js_1 = require("../../lib/device-cache.js");
-const version_resolver_js_1 = require("./version-resolver.js");
-const fuzzy_js_1 = require("../../lib/fuzzy.js");
+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_js_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_js_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_js_1.getDevicesAndBrowsers)(device_cache_js_1.BrowserStackProducts.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);

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

@@ -1,37 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startBrowserSession = startBrowserSession;
-const logger_js_1 = __importDefault(require("../../logger.js"));
-const child_process_1 = __importDefault(require("child_process"));
-const desktop_filter_js_1 = require("./desktop-filter.js");
-const mobile_filter_js_1 = require("./mobile-filter.js");
-const types_js_1 = require("./types.js");
-const local_js_1 = require("../../lib/local.js");
+import logger from "../../logger.js";
+import childProcess from "child_process";
+import { filterDesktop } from "./desktop-filter.js";
+import { filterMobile } from "./mobile-filter.js";
+import { PlatformType, } from "./types.js";
+import { isLocalURL, ensureLocalBinarySetup, killExistingBrowserStackLocalProcesses, } from "../../lib/local.js";
 /**
  * Prepares local tunnel setup based on URL type
  */
 async function prepareLocalTunnel(url) {
-    const isLocal = (0, local_js_1.isLocalURL)(url);
+    const isLocal = isLocalURL(url);
     if (isLocal) {
-        await (0, local_js_1.ensureLocalBinarySetup)();
+        await ensureLocalBinarySetup();
     }
     else {
-        await (0, local_js_1.killExistingBrowserStackLocalProcesses)();
+        await killExistingBrowserStackLocalProcesses();
     }
     return isLocal;
 }
 /**
  * Entrypoint: detects platformType & delegates.
  */
-async function startBrowserSession(args) {
-    const entry = args.platformType === types_js_1.PlatformType.DESKTOP
-        ? await (0, desktop_filter_js_1.filterDesktop)(args)
-        : await (0, mobile_filter_js_1.filterMobile)(args);
+export async function startBrowserSession(args) {
+    const entry = args.platformType === PlatformType.DESKTOP
+        ? await filterDesktop(args)
+        : await filterMobile(args);
     const isLocal = await prepareLocalTunnel(args.url);
-    const url = args.platformType === types_js_1.PlatformType.DESKTOP
+    const url = args.platformType === PlatformType.DESKTOP
         ? buildDesktopUrl(args, entry, isLocal)
         : buildMobileUrl(args, entry, isLocal);
     openBrowser(url);
@@ -81,14 +75,14 @@ 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", (err) => logger_js_1.default.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
+        child.on("error", (err) => logger.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
         child.unref();
     }
     catch (err) {
-        logger_js_1.default.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
+        logger.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
     }
 }

package/dist/tools/live-utils/types.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformType = void 0;
-var PlatformType;
+export var PlatformType;
 (function (PlatformType) {
     PlatformType["DESKTOP"] = "desktop";
     PlatformType["MOBILE"] = "mobile";
-})(PlatformType || (exports.PlatformType = PlatformType = {}));
+})(PlatformType || (PlatformType = {}));

package/dist/tools/live-utils/version-resolver.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVersion = resolveVersion;
 /**
  * If req === "latest" or "oldest", returns max/min numeric (or lex)
  * Else if exact match, returns that
  * Else picks the numerically closest (or first)
  */
-function resolveVersion(requested, available) {
+export function resolveVersion(requested, available) {
     // strip duplicates & sort
     const uniq = Array.from(new Set(available));
     // pick min/max