@browserstack/mcp-server 1.0.10 → 1.0.12

package/dist/config.js

@@ -8,11 +8,13 @@ if (!process.env.BROWSERSTACK_ACCESS_KEY ||
 class Config {
     browserstackUsername;
     browserstackAccessKey;
-    constructor(browserstackUsername, browserstackAccessKey) {
+    DEV_MODE;
+    constructor(browserstackUsername, browserstackAccessKey, DEV_MODE) {
         this.browserstackUsername = browserstackUsername;
         this.browserstackAccessKey = browserstackAccessKey;
+        this.DEV_MODE = DEV_MODE;
     }
 }
 exports.Config = Config;
-const config = new Config(process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY);
+const config = new Config(process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY, process.env.DEV_MODE === "true");
 exports.default = config;

package/dist/lib/device-cache.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDevicesAndBrowsers = getDevicesAndBrowsers;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CACHE_DIR = path_1.default.join(os_1.default.homedir(), ".browserstack", "combined_cache");
+const CACHE_FILE = path_1.default.join(CACHE_DIR, "data.json");
+const TTL_MS = 24 * 60 * 60 * 1000; // 1 day
+const URLS = {
+    live: "https://www.browserstack.com/list-of-browsers-and-platforms/live.json",
+    app_live: "https://www.browserstack.com/list-of-browsers-and-platforms/app_live.json",
+};
+/**
+ * Fetches and caches both BrowserStack datasets (live + app_live) with a shared TTL.
+ */
+async function getDevicesAndBrowsers(type) {
+    if (!fs_1.default.existsSync(CACHE_DIR)) {
+        fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    let cache = {};
+    if (fs_1.default.existsSync(CACHE_FILE)) {
+        const stats = fs_1.default.statSync(CACHE_FILE);
+        if (Date.now() - stats.mtimeMs < TTL_MS) {
+            try {
+                cache = JSON.parse(fs_1.default.readFileSync(CACHE_FILE, "utf8"));
+                return cache[type];
+            }
+            catch (error) {
+                console.error("Error parsing cache file:", error);
+                // Continue with fetching fresh data
+            }
+        }
+    }
+    const [liveRes, appLiveRes] = await Promise.all([
+        fetch(URLS.live),
+        fetch(URLS.app_live),
+    ]);
+    if (!liveRes.ok || !appLiveRes.ok) {
+        throw new Error(`Failed to fetch configuration from BrowserStack : live=${liveRes.statusText}, app_live=${appLiveRes.statusText}`);
+    }
+    const [liveData, appLiveData] = await Promise.all([
+        liveRes.json(),
+        appLiveRes.json(),
+    ]);
+    cache = { live: liveData, app_live: appLiveData };
+    fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf8");
+    return cache[type];
+}

package/dist/lib/instrumentation.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackMCP = trackMCP;
+const logger_1 = __importDefault(require("../logger"));
+const config_1 = __importDefault(require("../config"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const axios_1 = __importDefault(require("axios"));
+function trackMCP(toolName, clientInfo, error) {
+    if (config_1.default.DEV_MODE) {
+        logger_1.default.info("Tracking MCP is disabled in dev mode");
+        return;
+    }
+    const instrumentationEndpoint = "https://api.browserstack.com/sdk/v1/event";
+    const isSuccess = !error;
+    const mcpClient = clientInfo?.name || "unknown";
+    // Log client information
+    if (clientInfo?.name) {
+        logger_1.default.info(`Client connected: ${clientInfo.name} (version: ${clientInfo.version})`);
+    }
+    else {
+        logger_1.default.info("Client connected: unknown client");
+    }
+    const event = {
+        event_type: "MCPInstrumentation",
+        event_properties: {
+            mcp_version: package_json_1.default.version,
+            tool_name: toolName,
+            mcp_client: mcpClient,
+            success: isSuccess,
+        },
+    };
+    // Add error details if applicable
+    if (error) {
+        event.event_properties.error_message =
+            error instanceof Error ? error.message : String(error);
+        event.event_properties.error_type =
+            error instanceof Error ? error.constructor.name : "Unknown";
+    }
+    axios_1.default
+        .post(instrumentationEndpoint, event, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${Buffer.from(`${config_1.default.browserstackUsername}:${config_1.default.browserstackAccessKey}`).toString("base64")}`,
+        },
+        timeout: 2000,
+    })
+        .catch(() => { });
+}

package/dist/tools/accessibility.js

@@ -3,41 +3,44 @@ 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) {
-    try {
-        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");
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Successfully queued accessibility scan, you will get a report via email within 5 minutes.`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Failed to start accessibility scan: ${error instanceof Error ? error.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
-                    isError: true,
-                },
-            ],
-            isError: true,
-        };
+    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");
     }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Successfully queued accessibility scan, you will get a report via email within 5 minutes.`,
+            },
+        ],
+    };
 }
 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) => {
-        return runAccessibilityScan(args.name, args.pageURL);
+        try {
+            (0, instrumentation_1.trackMCP)("startAccessibilityScan", server.server.getClientVersion());
+            return await runAccessibilityScan(args.name, args.pageURL);
+        }
+        catch (error) {
+            (0, instrumentation_1.trackMCP)("startAccessibilityScan", server.server.getClientVersion(), error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to start accessibility scan: ${error instanceof Error ? error.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
     });
 }

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

@@ -6,7 +6,7 @@ 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("./device-cache");
+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");
@@ -19,7 +19,7 @@ const upload_app_1 = require("./upload-app");
 async function startSession(args) {
     const { appPath, desiredPlatform, desiredPhone } = args;
     let { desiredPlatformVersion } = args;
-    const data = await (0, device_cache_1.getAppLiveData)();
+    const data = await (0, device_cache_1.getDevicesAndBrowsers)("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);

package/dist/tools/applive.js

@@ -9,6 +9,7 @@ const zod_1 = require("zod");
 const fs_1 = __importDefault(require("fs"));
 const start_session_1 = require("./applive-utils/start-session");
 const logger_1 = __importDefault(require("../logger"));
+const instrumentation_1 = require("../lib/instrumentation");
 /**
  * Launches an App Live Session on BrowserStack.
  */
@@ -70,14 +71,17 @@ function addAppLiveTools(server) {
             .describe("The path to the .ipa or .apk file to install on the device. Always ask the user for the app path, do not assume it."),
     }, async (args) => {
         try {
-            return startAppLiveSession(args);
+            (0, instrumentation_1.trackMCP)("runAppLiveSession", server.server.getClientVersion());
+            return await startAppLiveSession(args);
         }
         catch (error) {
+            logger_1.default.error("App live session failed: %s", error);
+            (0, instrumentation_1.trackMCP)("runAppLiveSession", server.server.getClientVersion(), error);
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to start an app live session. Error: ${error}. Please open an issue on GitHub if the problem persists`,
+                        text: `Failed to start app live session: ${error instanceof Error ? error.message : String(error)}`,
                         isError: true,
                     },
                 ],

package/dist/tools/automate.js

@@ -8,6 +8,7 @@ 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.
@@ -31,22 +32,32 @@ async function getNetworkFailures(args) {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
-        logger_1.default.error("Failed to fetch network logs: %s", errorMessage);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Failed to fetch network logs: ${errorMessage}`,
-                    isError: true,
-                },
-            ],
-            isError: true,
-        };
+        logger_1.default.error("Failed to fetch network logs: %s", error);
+        throw new Error(error instanceof Error ? error.message : String(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."),
-    }, getNetworkFailures);
+    }, async (args) => {
+        try {
+            (0, instrumentation_1.trackMCP)("getNetworkFailures", server.server.getClientVersion());
+            return await getNetworkFailures(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);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to fetch network logs: ${errorMessage}`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
 }

package/dist/tools/bstack-sdk.js

@@ -4,6 +4,7 @@ exports.bootstrapProjectWithSDK = bootstrapProjectWithSDK;
 exports.default = addSDKTools;
 const zod_1 = require("zod");
 const instructions_1 = require("./sdk-utils/instructions");
+const instrumentation_1 = require("../lib/instrumentation");
 /**
  * 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.
@@ -36,19 +37,17 @@ function addSDKTools(server) {
             .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) => {
-        const detectedBrowserAutomationFramework = args.detectedBrowserAutomationFramework;
-        const detectedTestingFramework = args.detectedTestingFramework;
-        const detectedLanguage = args.detectedLanguage;
-        const desiredPlatforms = args.desiredPlatforms;
         try {
-            return bootstrapProjectWithSDK({
-                detectedBrowserAutomationFramework,
-                detectedTestingFramework,
-                detectedLanguage,
-                desiredPlatforms,
+            (0, instrumentation_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion());
+            return await bootstrapProjectWithSDK({
+                detectedBrowserAutomationFramework: args.detectedBrowserAutomationFramework,
+                detectedTestingFramework: args.detectedTestingFramework,
+                detectedLanguage: args.detectedLanguage,
+                desiredPlatforms: args.desiredPlatforms,
             });
         }
         catch (error) {
+            (0, instrumentation_1.trackMCP)("runTestsOnBrowserStack", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

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

@@ -0,0 +1,98 @@
+"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");
+    const allEntries = getAllDesktopEntries(data);
+    // Filter OS
+    const osList = filterByOS(allEntries, args.os);
+    // Filter browser
+    const browserList = filterByBrowser(osList, args.browser, args.os);
+    // Resolve OS version
+    const uniqueOSVersions = getUniqueOSVersions(browserList);
+    const chosenOS = resolveOSVersion(args.os, args.osVersion, uniqueOSVersions);
+    // Filter entries based on chosen OS version
+    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);
+    // Find final entry
+    const finalEntry = entriesForOS.find((e) => e.browser_version === chosenBrowserVersion);
+    if (!finalEntry) {
+        throw new Error(`No entry for browser version "${args.browserVersion}".`);
+    }
+    // Add notes if versions were adjusted
+    addNotes(finalEntry, args, chosenOS, chosenBrowserVersion);
+    return finalEntry;
+}
+function getAllDesktopEntries(data) {
+    return data.desktop.flatMap((plat) => plat.browsers.map((b) => ({
+        os: plat.os,
+        os_version: plat.os_version,
+        browser: b.browser,
+        browser_version: b.browser_version,
+    })));
+}
+function filterByOS(entries, os) {
+    const filtered = entries.filter((e) => e.os === os);
+    if (!filtered.length)
+        throw new Error(`No OS entries for "${os}".`);
+    return filtered;
+}
+function filterByBrowser(entries, browser, os) {
+    const filtered = entries.filter((e) => e.browser === browser);
+    if (!filtered.length)
+        throw new Error(`No browser "${browser}" on ${os}.`);
+    return filtered;
+}
+function getUniqueOSVersions(entries) {
+    return Array.from(new Set(entries.map((e) => e.os_version)));
+}
+function resolveOSVersion(os, requestedVersion, availableVersions) {
+    if (os === "OS X") {
+        return resolveMacOSVersion(requestedVersion, availableVersions);
+    }
+    else {
+        // For Windows, use semantic versioning
+        return (0, version_resolver_1.resolveVersion)(requestedVersion, availableVersions);
+    }
+}
+function resolveMacOSVersion(requested, available) {
+    if (requested === "latest") {
+        return available[available.length - 1];
+    }
+    else if (requested === "oldest") {
+        return available[0];
+    }
+    else {
+        // Try fuzzy matching
+        const fuzzy = (0, fuzzy_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];
+    }
+}
+function filterByOSVersion(entries, osVersion) {
+    return entries.filter((e) => e.os_version === osVersion);
+}
+function addNotes(entry, args, resolvedOS, resolvedBrowser) {
+    if (args.osVersion !== resolvedOS &&
+        args.osVersion !== "latest" &&
+        args.osVersion !== "oldest") {
+        entry.notes = `Note: OS version ${args.osVersion} was not found. Using "${resolvedOS}" instead.`;
+    }
+    if (args.browserVersion !== resolvedBrowser &&
+        args.browserVersion !== "latest" &&
+        args.browserVersion !== "oldest") {
+        if (!entry.notes) {
+            entry.notes = `Note: `;
+        }
+        else {
+            entry.notes += ` `;
+        }
+        entry.notes += `Browser version ${args.browserVersion} was not found. Using "${resolvedBrowser}" instead.`;
+    }
+}

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

@@ -0,0 +1,65 @@
+"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");
+// Extract all mobile entries from the data
+function getAllMobileEntries(data) {
+    return data.mobile.flatMap((grp) => grp.devices.map((d) => ({
+        os: grp.os,
+        os_version: d.os_version,
+        display_name: d.display_name,
+        notes: "",
+    })));
+}
+// Filter entries by OS
+function filterByOS(entries, os) {
+    const candidates = entries.filter((d) => d.os === os);
+    if (!candidates.length)
+        throw new Error(`No mobile OS entries for "${os}".`);
+    return candidates;
+}
+// Find matching device with exact match validation
+function findMatchingDevice(entries, deviceName, os) {
+    const matches = (0, fuzzy_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());
+    if (!exact) {
+        const names = matches.map((m) => m.display_name).join(", ");
+        throw new Error(`Alternative Device/Device's found : ${names}. Please Select one.`);
+    }
+    const result = entries.filter((d) => d.display_name === exact.display_name);
+    if (!result.length)
+        throw new Error(`No device "${exact.display_name}" on ${os}.`);
+    return result;
+}
+// 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 result = entries.filter((d) => d.os_version === chosenVersion);
+    if (!result.length)
+        throw new Error(`No entry for OS version "${requestedVersion}".`);
+    return { entries: result, chosenVersion };
+}
+// Create version note if needed
+function createVersionNote(requestedVersion, actualVersion) {
+    if (actualVersion !== requestedVersion &&
+        requestedVersion !== "latest" &&
+        requestedVersion !== "oldest") {
+        return `Note: Os version ${requestedVersion} was not found. Using ${actualVersion} instead.`;
+    }
+    return "";
+}
+async function filterMobile(args) {
+    const data = await (0, device_cache_1.getDevicesAndBrowsers)("live");
+    const allEntries = getAllMobileEntries(data);
+    const osCandidates = filterByOS(allEntries, args.os);
+    const deviceCandidates = findMatchingDevice(osCandidates, args.device, args.os);
+    const { entries: versionCandidates, chosenVersion } = findOSVersion(deviceCandidates, args.osVersion);
+    const final = versionCandidates[0];
+    final.notes = createVersionNote(args.osVersion, chosenVersion);
+    return final;
+}

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

@@ -4,35 +4,77 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startBrowserSession = startBrowserSession;
-const utils_1 = require("../../lib/utils");
 const logger_1 = __importDefault(require("../../logger"));
 const child_process_1 = __importDefault(require("child_process"));
+const desktop_filter_1 = require("./desktop-filter");
+const mobile_filter_1 = require("./mobile-filter");
+const types_1 = require("./types");
+const local_1 = require("../../lib/local");
+/**
+ * Prepares local tunnel setup based on URL type
+ */
+async function prepareLocalTunnel(url) {
+    const isLocal = (0, local_1.isLocalURL)(url);
+    if (isLocal) {
+        await (0, local_1.ensureLocalBinarySetup)();
+    }
+    else {
+        await (0, local_1.killExistingBrowserStackLocalProcesses)();
+    }
+    return isLocal;
+}
+/**
+ * Entrypoint: detects platformType & delegates.
+ */
 async function startBrowserSession(args) {
-    // Sanitize all input parameters
-    const sanitizedArgs = {
-        browser: (0, utils_1.sanitizeUrlParam)(args.browser),
-        os: (0, utils_1.sanitizeUrlParam)(args.os),
-        osVersion: (0, utils_1.sanitizeUrlParam)(args.osVersion),
-        url: (0, utils_1.sanitizeUrlParam)(args.url),
-        browserVersion: (0, utils_1.sanitizeUrlParam)(args.browserVersion),
-        isLocal: args.isLocal,
-    };
-    // Construct URL with encoded parameters
+    const entry = args.platformType === types_1.PlatformType.DESKTOP
+        ? await (0, desktop_filter_1.filterDesktop)(args)
+        : await (0, mobile_filter_1.filterMobile)(args);
+    const isLocal = await prepareLocalTunnel(args.url);
+    const url = args.platformType === types_1.PlatformType.DESKTOP
+        ? buildDesktopUrl(args, entry, isLocal)
+        : buildMobileUrl(args, entry, isLocal);
+    openBrowser(url);
+    return entry.notes ? `${url}, ${entry.notes}` : url;
+}
+function buildDesktopUrl(args, e, isLocal) {
     const params = new URLSearchParams({
-        os: sanitizedArgs.os,
-        os_version: sanitizedArgs.osVersion,
-        browser: sanitizedArgs.browser,
-        browser_version: sanitizedArgs.browserVersion,
+        os: e.os,
+        os_version: e.os_version,
+        browser: e.browser,
+        browser_version: e.browser_version,
+        url: args.url,
         scale_to_fit: "true",
-        url: sanitizedArgs.url,
         resolution: "responsive-mode",
         speed: "1",
-        local: sanitizedArgs.isLocal ? "true" : "false",
+        local: isLocal ? "true" : "false",
+        start: "true",
+    });
+    return `https://live.browserstack.com/dashboard#${params.toString()}`;
+}
+function buildMobileUrl(args, d, isLocal) {
+    const os_map = {
+        android: "Android",
+        ios: "iOS",
+        winphone: "Winphone",
+    };
+    const os = os_map[d.os] || d.os;
+    const params = new URLSearchParams({
+        os: os,
+        os_version: d.os_version,
+        device: d.display_name,
+        device_browser: args.browser,
+        url: args.url,
+        scale_to_fit: "true",
+        speed: "1",
+        local: isLocal ? "true" : "false",
         start: "true",
     });
-    const launchUrl = `https://live.browserstack.com/dashboard#${params.toString()}`;
+    return `https://live.browserstack.com/dashboard#${params.toString()}`;
+}
+// ——— Open a browser window ———
+function openBrowser(launchUrl) {
     try {
-        // Use platform-specific commands with proper escaping
         const command = process.platform === "darwin"
             ? ["open", launchUrl]
             : process.platform === "win32"
@@ -43,16 +85,10 @@ async function startBrowserSession(args) {
             stdio: "ignore",
             detached: true,
         });
-        // Handle process errors
-        child.on("error", (error) => {
-            logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
-        });
-        // Unref the child process to allow the parent to exit
+        child.on("error", (err) => logger_1.default.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
         child.unref();
-        return launchUrl;
     }
-    catch (error) {
-        logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
-        return launchUrl;
+    catch (err) {
+        logger_1.default.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
     }
 }

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

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