@browserstack/mcp-server 1.0.15 → 1.1.0

package/dist/tools/bstack-sdk.js

@@ -1,13 +1,17 @@
-import { z } from "zod";
-import { generateBrowserStackYMLInstructions, getInstructionsForProjectConfiguration, } from "./sdk-utils/instructions.js";
-import { trackMCP } from "../lib/instrumentation.js";
+"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");
 /**
  * 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.
  */
-export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, }) {
-    const instructions = generateBrowserStackYMLInstructions(desiredPlatforms);
-    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+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);
     return {
         content: [
             {
@@ -18,23 +22,23 @@ export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramewo
         ],
     };
 }
-export default function addSDKTools(server) {
+function addSDKTools(server) {
     server.tool("runTestsOnBrowserStack", "Use this tool to get instructions for running tests on BrowserStack.", {
-        detectedBrowserAutomationFramework: z
+        detectedBrowserAutomationFramework: zod_1.z
             .string()
             .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
-        detectedTestingFramework: z
+        detectedTestingFramework: zod_1.z
             .string()
             .describe("The testing framework used in the project. Example: 'jest', 'pytest'"),
-        detectedLanguage: z
+        detectedLanguage: zod_1.z
             .string()
             .describe("The programming language used in the project. Example: 'nodejs', 'python'"),
-        desiredPlatforms: z
-            .array(z.enum(["windows", "macos", "android", "ios"]))
+        desiredPlatforms: zod_1.z
+            .array(zod_1.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 {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion());
+            (0, instrumentation_js_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion());
             return await bootstrapProjectWithSDK({
                 detectedBrowserAutomationFramework: args.detectedBrowserAutomationFramework,
                 detectedTestingFramework: args.detectedTestingFramework,
@@ -43,7 +47,7 @@ export default function addSDKTools(server) {
             });
         }
         catch (error) {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error);
+            (0, instrumentation_js_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

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

@@ -1,8 +1,19 @@
-import config from "../../config.js";
-import { assertOkResponse, filterLinesByKeywords } from "../../lib/utils.js";
-const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
+"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");
 // DEVICE LOGS
-export async function retrieveDeviceLogs(sessionId, buildId) {
+async function retrieveDeviceLogs(sessionId, buildId) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/deviceLogs`;
     const response = await fetch(url, {
         headers: {
@@ -10,12 +21,12 @@ export async function retrieveDeviceLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await assertOkResponse(response, "device logs");
+    await (0, utils_js_1.assertOkResponse)(response, "device logs");
     const logText = await response.text();
     return filterDeviceFailures(logText);
 }
 // APPIUM LOGS
-export async function retrieveAppiumLogs(sessionId, buildId) {
+async function retrieveAppiumLogs(sessionId, buildId) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/appiumlogs`;
     const response = await fetch(url, {
         headers: {
@@ -23,12 +34,12 @@ export async function retrieveAppiumLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await assertOkResponse(response, "Appium logs");
+    await (0, utils_js_1.assertOkResponse)(response, "Appium logs");
     const logText = await response.text();
     return filterAppiumFailures(logText);
 }
 // CRASH LOGS
-export async function retrieveCrashLogs(sessionId, buildId) {
+async function retrieveCrashLogs(sessionId, buildId) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/crashlogs`;
     const response = await fetch(url, {
         headers: {
@@ -36,12 +47,12 @@ export async function retrieveCrashLogs(sessionId, buildId) {
             Authorization: `Basic ${auth}`,
         },
     });
-    await assertOkResponse(response, "crash logs");
+    await (0, utils_js_1.assertOkResponse)(response, "crash logs");
     const logText = await response.text();
     return filterCrashFailures(logText);
 }
 // FILTER HELPERS
-export function filterDeviceFailures(logText) {
+function filterDeviceFailures(logText) {
     const keywords = [
         "error",
         "exception",
@@ -55,9 +66,9 @@ export function filterDeviceFailures(logText) {
         "java.lang.",
         "unable to",
     ];
-    return filterLinesByKeywords(logText, keywords);
+    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
 }
-export function filterAppiumFailures(logText) {
+function filterAppiumFailures(logText) {
     const keywords = [
         "error",
         "fail",
@@ -70,9 +81,9 @@ export function filterAppiumFailures(logText) {
         "command failed",
         "invalid selector",
     ];
-    return filterLinesByKeywords(logText, keywords);
+    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
 }
-export function filterCrashFailures(logText) {
+function filterCrashFailures(logText) {
     const keywords = [
         "fatal exception",
         "crash",
@@ -84,5 +95,5 @@ export function filterCrashFailures(logText) {
         "abort message",
         "application has stopped unexpectedly",
     ];
-    return filterLinesByKeywords(logText, keywords);
+    return (0, utils_js_1.filterLinesByKeywords)(logText, keywords);
 }

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

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

package/dist/tools/getFailureLogs.js

@@ -1,36 +1,43 @@
-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";
+"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");
 // Main log fetcher function
-export async function getFailureLogs(args) {
+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) {
+    if (args.sessionType === constants_js_1.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);
+        const isAutomate = Object.values(constants_js_1.AutomateLogType).includes(logType);
+        const isAppAutomate = Object.values(constants_js_1.AppAutomateLogType).includes(logType);
         if (!isAutomate && !isAppAutomate) {
             errors.push(`Invalid log type '${logType}'. Valid log types are: ${[
-                ...Object.values(AutomateLogType),
-                ...Object.values(AppAutomateLogType),
+                ...Object.values(constants_js_1.AutomateLogType),
+                ...Object.values(constants_js_1.AppAutomateLogType),
             ].join(", ")}`);
             return false;
         }
-        if (args.sessionType === SessionType.Automate && !isAutomate) {
+        if (args.sessionType === constants_js_1.SessionType.Automate && !isAutomate) {
             errors.push(`Log type '${logType}' is only available for app-automate sessions.`);
             return false;
         }
-        if (args.sessionType === SessionType.AppAutomate && !isAppAutomate) {
+        if (args.sessionType === constants_js_1.SessionType.AppAutomate && !isAppAutomate) {
             errors.push(`Log type '${logType}' is only available for automate sessions.`);
             return false;
         }
@@ -51,8 +58,8 @@ export async function getFailureLogs(args) {
     try {
         for (const logType of validLogTypes) {
             switch (logType) {
-                case AutomateLogType.NetworkLogs: {
-                    const logs = await retrieveNetworkFailures(args.sessionId);
+                case constants_js_1.AutomateLogType.NetworkLogs: {
+                    const logs = await (0, automate_js_1.retrieveNetworkFailures)(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -61,8 +68,8 @@ export async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case AutomateLogType.SessionLogs: {
-                    const logs = await retrieveSessionFailures(args.sessionId);
+                case constants_js_1.AutomateLogType.SessionLogs: {
+                    const logs = await (0, automate_js_1.retrieveSessionFailures)(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -71,8 +78,8 @@ export async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case AutomateLogType.ConsoleLogs: {
-                    const logs = await retrieveConsoleFailures(args.sessionId);
+                case constants_js_1.AutomateLogType.ConsoleLogs: {
+                    const logs = await (0, automate_js_1.retrieveConsoleFailures)(args.sessionId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -81,8 +88,8 @@ export async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case AppAutomateLogType.DeviceLogs: {
-                    const logs = await retrieveDeviceLogs(args.sessionId, args.buildId);
+                case constants_js_1.AppAutomateLogType.DeviceLogs: {
+                    const logs = await (0, app_automate_js_1.retrieveDeviceLogs)(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -91,8 +98,8 @@ export async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case AppAutomateLogType.AppiumLogs: {
-                    const logs = await retrieveAppiumLogs(args.sessionId, args.buildId);
+                case constants_js_1.AppAutomateLogType.AppiumLogs: {
+                    const logs = await (0, app_automate_js_1.retrieveAppiumLogs)(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -101,8 +108,8 @@ export async function getFailureLogs(args) {
                     });
                     break;
                 }
-                case AppAutomateLogType.CrashLogs: {
-                    const logs = await retrieveCrashLogs(args.sessionId, args.buildId);
+                case constants_js_1.AppAutomateLogType.CrashLogs: {
+                    const logs = await (0, app_automate_js_1.retrieveCrashLogs)(args.sessionId, args.buildId);
                     results.push({
                         type: "text",
                         text: logs.length > 0
@@ -127,37 +134,37 @@ export async function getFailureLogs(args) {
     return { content: results };
 }
 // Register tool with the MCP server
-export default function registerGetFailureLogs(server) {
+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])
+        sessionType: zod_1.z
+            .enum([constants_js_1.SessionType.Automate, constants_js_1.SessionType.AppAutomate])
             .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
-        sessionId: z
+        sessionId: zod_1.z
             .string()
             .describe("The BrowserStack session ID. Must be explicitly provided by the user."),
-        buildId: z
+        buildId: zod_1.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,
+        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,
         ]))
             .describe("The types of logs to fetch."),
     }, async (args) => {
         try {
-            trackMCP("getFailureLogs", server.server.getClientVersion());
+            (0, instrumentation_js_1.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);
+            (0, instrumentation_js_1.trackMCP)("getFailureLogs", server.server.getClientVersion(), error);
+            logger_js_1.default.error("Failed to fetch logs: %s", message);
             return {
                 content: [
                     {

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

@@ -1,8 +1,11 @@
-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);
+"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);
     const allEntries = getAllDesktopEntries(data);
     // Filter OS
     const osList = filterByOS(allEntries, args.os);
@@ -15,7 +18,7 @@ export async function filterDesktop(args) {
     const entriesForOS = filterByOSVersion(browserList, chosenOS);
     // Resolve browser version
     const browserVersions = entriesForOS.map((e) => e.browser_version);
-    const chosenBrowserVersion = resolveVersion(args.browserVersion, browserVersions);
+    const chosenBrowserVersion = (0, version_resolver_js_1.resolveVersion)(args.browserVersion, browserVersions);
     // Find final entry
     const finalEntry = entriesForOS.find((e) => e.browser_version === chosenBrowserVersion);
     if (!finalEntry) {
@@ -54,7 +57,7 @@ function resolveOSVersion(os, requestedVersion, availableVersions) {
     }
     else {
         // For Windows, use semantic versioning
-        return resolveVersion(requestedVersion, availableVersions);
+        return (0, version_resolver_js_1.resolveVersion)(requestedVersion, availableVersions);
     }
 }
 function resolveMacOSVersion(requested, available) {
@@ -66,7 +69,7 @@ function resolveMacOSVersion(requested, available) {
     }
     else {
         // Try fuzzy matching
-        const fuzzy = customFuzzySearch(available.map((v) => ({ os_version: v })), ["os_version"], requested, 1);
+        const fuzzy = (0, fuzzy_js_1.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,6 +1,9 @@
-import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
-import { resolveVersion } from "./version-resolver.js";
-import { customFuzzySearch } from "../../lib/fuzzy.js";
+"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");
 // Extract all mobile entries from the data
 function getAllMobileEntries(data) {
     return data.mobile.flatMap((grp) => grp.devices.map((d) => ({
@@ -19,7 +22,7 @@ function filterByOS(entries, os) {
 }
 // Find matching device with exact match validation
 function findMatchingDevice(entries, deviceName, os) {
-    const matches = customFuzzySearch(entries, ["display_name"], deviceName, 5);
+    const matches = (0, fuzzy_js_1.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());
@@ -35,7 +38,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 = resolveVersion(requestedVersion, versions);
+    const chosenVersion = (0, version_resolver_js_1.resolveVersion)(requestedVersion, versions);
     const result = entries.filter((d) => d.os_version === chosenVersion);
     if (!result.length)
         throw new Error(`No entry for OS version "${requestedVersion}".`);
@@ -50,8 +53,8 @@ function createVersionNote(requestedVersion, actualVersion) {
     }
     return "";
 }
-export async function filterMobile(args) {
-    const data = await getDevicesAndBrowsers(BrowserStackProducts.LIVE);
+async function filterMobile(args) {
+    const data = await (0, device_cache_js_1.getDevicesAndBrowsers)(device_cache_js_1.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,31 +1,37 @@
-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";
+"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");
 /**
  * Prepares local tunnel setup based on URL type
  */
 async function prepareLocalTunnel(url) {
-    const isLocal = isLocalURL(url);
+    const isLocal = (0, local_js_1.isLocalURL)(url);
     if (isLocal) {
-        await ensureLocalBinarySetup();
+        await (0, local_js_1.ensureLocalBinarySetup)();
     }
     else {
-        await killExistingBrowserStackLocalProcesses();
+        await (0, local_js_1.killExistingBrowserStackLocalProcesses)();
     }
     return isLocal;
 }
 /**
  * Entrypoint: detects platformType & delegates.
  */
-export async function startBrowserSession(args) {
-    const entry = args.platformType === PlatformType.DESKTOP
-        ? await filterDesktop(args)
-        : await filterMobile(args);
+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);
     const isLocal = await prepareLocalTunnel(args.url);
-    const url = args.platformType === PlatformType.DESKTOP
+    const url = args.platformType === types_js_1.PlatformType.DESKTOP
         ? buildDesktopUrl(args, entry, isLocal)
         : buildMobileUrl(args, entry, isLocal);
     openBrowser(url);
@@ -75,14 +81,14 @@ function openBrowser(launchUrl) {
                 ? ["cmd", "/c", "start", launchUrl]
                 : ["xdg-open", launchUrl];
         // nosemgrep:javascript.lang.security.detect-child-process.detect-child-process
-        const child = childProcess.spawn(command[0], command.slice(1), {
+        const child = child_process_1.default.spawn(command[0], command.slice(1), {
             stdio: "ignore",
             detached: true,
         });
-        child.on("error", (err) => logger.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
+        child.on("error", (err) => logger_js_1.default.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
         child.unref();
     }
     catch (err) {
-        logger.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
+        logger_js_1.default.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
     }
 }

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

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

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

@@ -1,9 +1,12 @@
+"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)
  */
-export function resolveVersion(requested, available) {
+function resolveVersion(requested, available) {
     // strip duplicates & sort
     const uniq = Array.from(new Set(available));
     // pick min/max