@browserstack/mcp-server 1.0.9 → 1.0.11

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/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/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 = {}));

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

@@ -0,0 +1,48 @@
+"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) {
+    // strip duplicates & sort
+    const uniq = Array.from(new Set(available));
+    // pick min/max
+    if (requested === "latest" || requested === "oldest") {
+        // try numeric
+        const nums = uniq
+            .map((v) => ({ v, n: parseFloat(v) }))
+            .filter((x) => !isNaN(x.n))
+            .sort((a, b) => a.n - b.n);
+        if (nums.length) {
+            return requested === "latest" ? nums[nums.length - 1].v : nums[0].v;
+        }
+        // fallback lex
+        const lex = uniq.slice().sort();
+        return requested === "latest" ? lex[lex.length - 1] : lex[0];
+    }
+    // exact?
+    if (uniq.includes(requested)) {
+        return requested;
+    }
+    // try closest numeric
+    const reqNum = parseFloat(requested);
+    const nums = uniq
+        .map((v) => ({ v, n: parseFloat(v) }))
+        .filter((x) => !isNaN(x.n));
+    if (!isNaN(reqNum) && nums.length) {
+        let best = nums[0], bestDiff = Math.abs(nums[0].n - reqNum);
+        for (const x of nums) {
+            const d = Math.abs(x.n - reqNum);
+            if (d < bestDiff) {
+                best = x;
+                bestDiff = d;
+            }
+        }
+        return best.v;
+    }
+    // final fallback
+    return uniq[0];
+}

package/dist/tools/live.js

@@ -3,90 +3,111 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startBrowserLiveSession = startBrowserLiveSession;
 exports.default = addBrowserLiveTools;
 const zod_1 = require("zod");
-const start_session_1 = require("./live-utils/start-session");
 const logger_1 = __importDefault(require("../logger"));
-const local_1 = require("../lib/local");
+const start_session_1 = require("./live-utils/start-session");
+const types_1 = require("./live-utils/types");
+// Define the schema shape
+const LiveArgsShape = {
+    platformType: zod_1.z
+        .nativeEnum(types_1.PlatformType)
+        .describe("Must be 'desktop' or 'mobile'"),
+    desiredURL: zod_1.z.string().url().describe("The URL to test"),
+    desiredOS: zod_1.z
+        .enum(["Windows", "OS X", "android", "ios", "winphone"])
+        .describe("Desktop OS ('Windows' or 'OS X') or mobile OS ('android','ios','winphone')"),
+    desiredOSVersion: zod_1.z
+        .string()
+        .describe("The OS version must be specified as a version number (e.g., '10', '14.0') or as a keyword such as 'latest' or 'oldest'. Normalize variations like 'newest' or 'most recent' to 'latest', and terms like 'earliest' or 'first' to 'oldest'. For macOS, version names (e.g., 'Sequoia') must be used instead of numeric versions."),
+    desiredBrowser: zod_1.z
+        .enum(["chrome", "firefox", "safari", "edge", "ie"])
+        .describe("Browser for desktop (Chrome, IE, Firefox, Safari, Edge)"),
+    desiredBrowserVersion: zod_1.z
+        .string()
+        .optional()
+        .describe("Browser version for desktop (e.g. '133.2', 'latest'). If the user says 'latest', 'newest', or similar, normalize it to 'latest'. Likewise, convert terms like 'earliest' or 'oldest' to 'oldest'."),
+    desiredDevice: zod_1.z.string().optional().describe("Device name for mobile"),
+};
+const LiveArgsSchema = zod_1.z.object(LiveArgsShape);
 /**
- * Launches a Browser Live Session on BrowserStack.
+ * Launches a desktop browser session
  */
-async function startBrowserLiveSession(args) {
-    if (!args.desiredBrowser) {
-        throw new Error("You must provide a desiredBrowser.");
-    }
-    if (!args.desiredURL) {
-        throw new Error("You must provide a desiredURL.");
-    }
-    if (!args.desiredOS) {
-        throw new Error("You must provide a desiredOS.");
-    }
-    if (!args.desiredOSVersion) {
-        throw new Error("You must provide a desiredOSVersion.");
-    }
-    if (!args.desiredBrowserVersion) {
-        throw new Error("You must provide a desiredBrowserVersion.");
-    }
-    // Validate URL format
-    try {
-        new URL(args.desiredURL);
-    }
-    catch (error) {
-        logger_1.default.error("Invalid URL format: %s", error);
-        throw new Error("The provided URL is invalid.");
-    }
-    const isLocal = (0, local_1.isLocalURL)(args.desiredURL);
-    if (isLocal) {
-        await (0, local_1.ensureLocalBinarySetup)();
-    }
-    else {
-        await (0, local_1.killExistingBrowserStackLocalProcesses)();
-    }
-    const launchUrl = await (0, start_session_1.startBrowserSession)({
-        browser: args.desiredBrowser,
+async function launchDesktopSession(args) {
+    if (!args.desiredBrowser)
+        throw new Error("You must provide a desiredBrowser");
+    if (!args.desiredBrowserVersion)
+        throw new Error("You must provide a desiredBrowserVersion");
+    return (0, start_session_1.startBrowserSession)({
+        platformType: types_1.PlatformType.DESKTOP,
+        url: args.desiredURL,
         os: args.desiredOS,
         osVersion: args.desiredOSVersion,
-        url: args.desiredURL,
+        browser: args.desiredBrowser,
         browserVersion: args.desiredBrowserVersion,
-        isLocal,
     });
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Successfully started a browser session. If a browser window did not open automatically, use the following URL to start the session: ${launchUrl}`,
-            },
-        ],
-    };
+}
+/**
+ * Launches a mobile browser session
+ */
+async function launchMobileSession(args) {
+    if (!args.desiredDevice)
+        throw new Error("You must provide a desiredDevice");
+    return (0, start_session_1.startBrowserSession)({
+        platformType: types_1.PlatformType.MOBILE,
+        browser: args.desiredBrowser,
+        url: args.desiredURL,
+        os: args.desiredOS,
+        osVersion: args.desiredOSVersion,
+        device: args.desiredDevice,
+    });
+}
+/**
+ * Handles the core logic for running a browser session
+ */
+async function runBrowserSession(rawArgs) {
+    // Validate and narrow
+    const args = LiveArgsSchema.parse(rawArgs);
+    try {
+        // Branch desktop vs mobile and delegate
+        const launchUrl = args.platformType === types_1.PlatformType.DESKTOP
+            ? await launchDesktopSession(args)
+            : await launchMobileSession(args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ Session started. If it didn't open automatically, visit:\n${launchUrl}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        logger_1.default.error("Live session failed: %s", err);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Failed to start session: ${err.message || err}`,
+                    isError: true,
+                },
+            ],
+            isError: true,
+        };
+    }
 }
 function addBrowserLiveTools(server) {
-    server.tool("runBrowserLiveSession", "Use this tool when user wants to manually check their website on a particular browser and OS combination using BrowserStack's cloud infrastructure. Can be used to debug layout issues, compatibility problems, etc.", {
-        desiredBrowser: zod_1.z
-            .enum(["Chrome", "IE", "Firefox", "Safari", "Edge"])
-            .describe("The browser to run the test on. Example: 'Chrome', 'IE', 'Safari', 'Edge'. Always ask the user for the browser they want to use, do not assume it."),
-        desiredOSVersion: zod_1.z
-            .string()
-            .describe("The OS version to run the browser on. Example: '10' for Windows, '12' for macOS, '14' for iOS"),
-        desiredOS: zod_1.z
-            .enum(["Windows", "OS X"])
-            .describe("The operating system to run the browser on. Example: 'Windows', 'OS X'"),
-        desiredURL: zod_1.z
-            .string()
-            .describe("The URL of the website to test. This can be a local URL (e.g., http://localhost:3000) or a public URL. Always ask the user for the URL, do not assume it."),
-        desiredBrowserVersion: zod_1.z
-            .string()
-            .describe("The version of the browser to use. Example: 133.0, 134.0, 87.0"),
-    }, async (args) => {
+    server.tool("runBrowserLiveSession", "Launch a BrowserStack Live session (desktop or mobile).", LiveArgsShape, async (args) => {
         try {
-            return startBrowserLiveSession(args);
+            const result = await runBrowserSession(args);
+            return result;
         }
         catch (error) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to start a browser live session. Error: ${error}. Please open an issue on GitHub if the problem persists`,
+                        text: `Failed to start a browser live session. Error: ${error}`,
                         isError: true,
                     },
                 ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "BrowserStack's Official MCP Server",
   "main": "dist/index.js",
   "repository": {

package/dist/tools/applive-utils/constants.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_LIVE_CONFIGURATIONS = void 0;
-exports.SUPPORTED_LIVE_CONFIGURATIONS = {
-    android: {
-        chrome: {
-            version: "100",
-        },
-        firefox: {
-            version: "100",
-        },
-        safari: {
-            version: "100",
-        },
-        "samsung browser": {
-            version: "100",
-        },
-        "internet-explorer": {
-            version: "100",
-        },
-    },
-    ios: {
-        chrome: {
-            version: "100",
-        },
-        firefox: {
-            version: "100",
-        },
-        edge: {
-            version: "100",
-        },
-        safari: {
-            version: "100",
-        },
-        "samsung browser": {
-            version: "100",
-        },
-        "internet-explorer": {
-            version: "100",
-        },
-    },
-    windows: {
-        chrome: {
-            version: "100",
-        },
-        firefox: {
-            version: "100",
-        },
-        edge: {
-            version: "100",
-        },
-        safari: {
-            version: "100",
-        },
-        "samsung browser": {
-            version: "100",
-        },
-        "internet-explorer": {
-            version: "100",
-        },
-    },
-    macos: {
-        chrome: {
-            version: "100",
-        },
-        firefox: {
-            version: "100",
-        },
-        edge: {
-            version: "100",
-        },
-        safari: {
-            version: "100",
-        },
-        "samsung browser": {
-            version: "100",
-        },
-        "internet-explorer": {
-            version: "100",
-        },
-    },
-};

package/dist/tools/applive-utils/device-cache.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAppLiveData = getAppLiveData;
-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", "app_live_cache");
-const CACHE_FILE = path_1.default.join(CACHE_DIR, "app_live.json");
-const TTL_MS = 24 * 60 * 60 * 1000; // 1 day
-/**
- * Fetches and caches the App Live devices JSON with a 1-day TTL.
- */
-async function getAppLiveData() {
-    if (!fs_1.default.existsSync(CACHE_DIR)) {
-        fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
-    }
-    if (fs_1.default.existsSync(CACHE_FILE)) {
-        const stats = fs_1.default.statSync(CACHE_FILE);
-        if (Date.now() - stats.mtimeMs < TTL_MS) {
-            return JSON.parse(fs_1.default.readFileSync(CACHE_FILE, "utf8"));
-        }
-    }
-    const response = await fetch("https://www.browserstack.com/list-of-browsers-and-platforms/app_live.json");
-    if (!response.ok) {
-        throw new Error(`Failed to fetch app live list: ${response.statusText}`);
-    }
-    const data = await response.json();
-    fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(data), "utf8");
-    return data;
-}

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });