@browserstack/mcp-server 1.0.8 → 1.0.9

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

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 fuzzy_search_1 = require("./fuzzy-search");
+const utils_1 = require("../../lib/utils");
+const upload_app_1 = require("./upload-app");
+/**
+ * Starts an App Live session after filtering, fuzzy matching, and launching.
+ * @param args - The arguments for starting the session.
+ * @returns The launch URL for the session.
+ * @throws Will throw an error if no devices are found or if the app URL is invalid.
+ */
+async function startSession(args) {
+    const { appPath, desiredPlatform, desiredPhone } = args;
+    let { desiredPlatformVersion } = args;
+    const data = await (0, device_cache_1.getAppLiveData)();
+    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);
+    const matches = await (0, fuzzy_search_1.fuzzySearchDevices)(filteredDevices, desiredPhone);
+    const selectedDevice = validateAndSelectDevice(matches, desiredPhone, desiredPlatform, desiredPlatformVersion);
+    const { app_url } = await (0, upload_app_1.uploadApp)(appPath);
+    validateAppUrl(app_url);
+    const launchUrl = constructLaunchUrl(app_url, selectedDevice, desiredPlatform, desiredPlatformVersion);
+    openBrowser(launchUrl);
+    return launchUrl;
+}
+/**
+ * Resolves the platform version based on the desired platform and version.
+ * @param allDevices - The list of all devices.
+ * @param desiredPlatform - The desired platform (android or ios).
+ * @param desiredPlatformVersion - The desired platform version.
+ * @returns The resolved platform version.
+ * @throws Will throw an error if the platform version is not valid.
+ */
+function resolvePlatformVersion(allDevices, desiredPlatform, desiredPlatformVersion) {
+    if (desiredPlatformVersion === "latest" ||
+        desiredPlatformVersion === "oldest") {
+        const filtered = allDevices.filter((d) => d.os === desiredPlatform);
+        filtered.sort((a, b) => {
+            const versionA = parseFloat(a.os_version);
+            const versionB = parseFloat(b.os_version);
+            return desiredPlatformVersion === "latest"
+                ? versionB - versionA
+                : versionA - versionB;
+        });
+        return filtered[0].os_version;
+    }
+    return desiredPlatformVersion;
+}
+/**
+ * Filters devices based on the desired platform and version.
+ * @param allDevices - The list of all devices.
+ * @param desiredPlatform - The desired platform (android or ios).
+ * @param desiredPlatformVersion - The desired platform version.
+ * @returns The filtered list of devices.
+ * @throws Will throw an error if the platform version is not valid.
+ */
+function filterDevicesByPlatformAndVersion(allDevices, desiredPlatform, desiredPlatformVersion) {
+    return allDevices.filter((d) => {
+        if (d.os !== desiredPlatform)
+            return false;
+        try {
+            const versionA = parseFloat(d.os_version);
+            const versionB = parseFloat(desiredPlatformVersion);
+            return versionA === versionB;
+        }
+        catch {
+            return d.os_version === desiredPlatformVersion;
+        }
+    });
+}
+/**
+ * Validates the selected device and handles multiple matches.
+ * @param matches - The list of device matches.
+ * @param desiredPhone - The desired phone name.
+ * @param desiredPlatform - The desired platform (android or ios).
+ * @param desiredPlatformVersion - The desired platform version.
+ * @returns The selected device entry.
+ */
+function validateAndSelectDevice(matches, desiredPhone, desiredPlatform, desiredPlatformVersion) {
+    if (matches.length === 0) {
+        throw new Error(`No devices found matching "${desiredPhone}" for ${desiredPlatform} ${desiredPlatformVersion}`);
+    }
+    const exactMatch = matches.find((d) => d.display_name.toLowerCase() === desiredPhone.toLowerCase());
+    if (exactMatch) {
+        return exactMatch;
+    }
+    else if (matches.length >= 1) {
+        const names = matches.map((d) => d.display_name).join(", ");
+        const error_message = matches.length === 1
+            ? `Alternative device found: ${names}. Would you like to use it?`
+            : `Multiple devices found: ${names}. Please select one.`;
+        throw new Error(`${error_message}`);
+    }
+    return matches[0];
+}
+/**
+ * Validates the app URL.
+ * @param appUrl - The app URL to validate.
+ * @throws Will throw an error if the app URL is not valid.
+ */
+function validateAppUrl(appUrl) {
+    if (!appUrl.match("bs://")) {
+        throw new Error("The app path is not a valid BrowserStack app URL.");
+    }
+}
+/**
+ * Constructs the launch URL for the App Live session.
+ * @param appUrl - The app URL.
+ * @param device - The selected device entry.
+ * @param desiredPlatform - The desired platform (android or ios).
+ * @param desiredPlatformVersion - The desired platform version.
+ * @returns The constructed launch URL.
+ */
+function constructLaunchUrl(appUrl, device, desiredPlatform, desiredPlatformVersion) {
+    const deviceParam = (0, utils_1.sanitizeUrlParam)(device.display_name.replace(/\s+/g, "+"));
+    const params = new URLSearchParams({
+        os: desiredPlatform,
+        os_version: desiredPlatformVersion,
+        app_hashed_id: appUrl.split("bs://").pop() || "",
+        scale_to_fit: "true",
+        speed: "1",
+        start: "true",
+    });
+    return `https://app-live.browserstack.com/dashboard#${params.toString()}&device=${deviceParam}`;
+}
+/**
+ * Opens the launch URL in the default browser.
+ * @param launchUrl - The URL to open.
+ * @throws Will throw an error if the browser fails to open.
+ */
+function openBrowser(launchUrl) {
+    try {
+        const command = process.platform === "darwin"
+            ? ["open", launchUrl]
+            : process.platform === "win32"
+                ? ["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), {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.on("error", (error) => {
+            logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
+        });
+        child.unref();
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
+    }
+}

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

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

package/dist/tools/applive-utils/upload-app.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadApp = uploadApp;
+const axios_1 = __importStar(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = __importDefault(require("../../config"));
+async function uploadApp(filePath) {
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`File not found at path: ${filePath}`);
+    }
+    const formData = new form_data_1.default();
+    formData.append("file", fs_1.default.createReadStream(filePath));
+    try {
+        const response = await axios_1.default.post("https://api-cloud.browserstack.com/app-live/upload", formData, {
+            headers: {
+                ...formData.getHeaders(),
+            },
+            auth: {
+                username: config_1.default.browserstackUsername,
+                password: config_1.default.browserstackAccessKey,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (error instanceof axios_1.AxiosError) {
+            throw new Error(`Failed to upload app: ${error.response?.data?.message || error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/tools/applive.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAppLiveSession = startAppLiveSession;
+exports.default = addAppLiveTools;
+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"));
+/**
+ * Launches an App Live Session on BrowserStack.
+ */
+async function startAppLiveSession(args) {
+    if (!args.desiredPlatform) {
+        throw new Error("You must provide a desiredPlatform.");
+    }
+    if (!args.appPath) {
+        throw new Error("You must provide a appPath.");
+    }
+    if (!args.desiredPhone) {
+        throw new Error("You must provide a desiredPhone.");
+    }
+    if (args.desiredPlatform === "android" && !args.appPath.endsWith(".apk")) {
+        throw new Error("You must provide a valid Android app path.");
+    }
+    if (args.desiredPlatform === "ios" && !args.appPath.endsWith(".ipa")) {
+        throw new Error("You must provide a valid iOS app path.");
+    }
+    // check if the app path exists && is readable
+    try {
+        if (!fs_1.default.existsSync(args.appPath)) {
+            throw new Error("The app path does not exist.");
+        }
+        fs_1.default.accessSync(args.appPath, fs_1.default.constants.R_OK);
+    }
+    catch (error) {
+        logger_1.default.error("The app path does not exist or is not readable: %s", error);
+        throw new Error("The app path does not exist or is not readable.");
+    }
+    const launchUrl = await (0, start_session_1.startSession)({
+        appPath: args.appPath,
+        desiredPlatform: args.desiredPlatform,
+        desiredPhone: args.desiredPhone,
+        desiredPlatformVersion: args.desiredPlatformVersion,
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Successfully started a session. If a browser window did not open automatically, use the following URL to start the session: ${launchUrl}`,
+            },
+        ],
+    };
+}
+function addAppLiveTools(server) {
+    server.tool("runAppLiveSession", "Use this tool when user wants to manually check their app on a particular mobile device using BrowserStack's cloud infrastructure. Can be used to debug crashes, slow performance, etc.", {
+        desiredPhone: zod_1.z
+            .string()
+            .describe("The full name of the device to run the app on. Example: 'iPhone 12 Pro' or 'Samsung Galaxy S20' or 'Google Pixel 6'. Always ask the user for the device they want to use, do not assume it. "),
+        desiredPlatformVersion: zod_1.z
+            .string()
+            .describe("Specifies the platform version to run the app on. For example, use '12.0' for Android or '16.0' for iOS. If the user says 'latest', 'newest', or similar, normalize it to 'latest'. Likewise, convert terms like 'earliest' or 'oldest' to 'oldest'."),
+        desiredPlatform: zod_1.z
+            .enum(["android", "ios"])
+            .describe("Which platform to run on, examples: 'android', 'ios'. Set this based on the app path provided."),
+        appPath: zod_1.z
+            .string()
+            .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);
+        }
+        catch (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`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/automate.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.getNetworkFailures = getNetworkFailures;
+exports.default = addAutomateTools;
+const zod_1 = require("zod");
+const logger_1 = __importDefault(require("../logger"));
+const api_1 = require("../lib/api");
+/**
+ * Fetches failed network requests from a BrowserStack Automate session.
+ * Returns network requests that resulted in errors or failed to complete.
+ */
+async function getNetworkFailures(args) {
+    try {
+        const failureLogs = await (0, api_1.retrieveNetworkFailures)(args.sessionId);
+        logger_1.default.info("Successfully fetched failure network logs for session: %s", args.sessionId);
+        // Check if there are any failures
+        const hasFailures = failureLogs.totalFailures > 0;
+        const text = hasFailures
+            ? `${failureLogs.totalFailures} network failure(s) found for session :\n\n${JSON.stringify(failureLogs.failures, null, 2)}`
+            : `No network failures found for session`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text,
+                },
+            ],
+        };
+    }
+    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,
+        };
+    }
+}
+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);
+}

package/dist/tools/bstack-sdk.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapProjectWithSDK = bootstrapProjectWithSDK;
+exports.default = addSDKTools;
+const zod_1 = require("zod");
+const instructions_1 = require("./sdk-utils/instructions");
+/**
+ * BrowserStack SDK hooks into your test framework to seamlessly run tests on BrowserStack.
+ * This tool gives instructions to setup a browserstack.yml file in the project root and installs the necessary dependencies.
+ */
+async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, }) {
+    const instructions = (0, instructions_1.generateBrowserStackYMLInstructions)(desiredPlatforms);
+    const instructionsForProjectConfiguration = (0, instructions_1.getInstructionsForProjectConfiguration)(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${instructions}\n\n After creating the browserstack.yml file above, do the following: ${instructionsForProjectConfiguration}`,
+                isError: false,
+            },
+        ],
+    };
+}
+function addSDKTools(server) {
+    server.tool("runTestsOnBrowserStack", "Use this tool to get instructions for running tests on BrowserStack.", {
+        detectedBrowserAutomationFramework: zod_1.z
+            .string()
+            .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
+        detectedTestingFramework: zod_1.z
+            .string()
+            .describe("The testing framework used in the project. Example: 'jest', 'pytest'"),
+        detectedLanguage: zod_1.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"]))
+            .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,
+            });
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to bootstrap project with BrowserStack SDK. Error: ${error}. Please open an issue on GitHub if the problem persists`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

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

@@ -0,0 +1,58 @@
+"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 utils_1 = require("../../lib/utils");
+const logger_1 = __importDefault(require("../../logger"));
+const child_process_1 = __importDefault(require("child_process"));
+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 params = new URLSearchParams({
+        os: sanitizedArgs.os,
+        os_version: sanitizedArgs.osVersion,
+        browser: sanitizedArgs.browser,
+        browser_version: sanitizedArgs.browserVersion,
+        scale_to_fit: "true",
+        url: sanitizedArgs.url,
+        resolution: "responsive-mode",
+        speed: "1",
+        local: sanitizedArgs.isLocal ? "true" : "false",
+        start: "true",
+    });
+    const launchUrl = `https://live.browserstack.com/dashboard#${params.toString()}`;
+    try {
+        // Use platform-specific commands with proper escaping
+        const command = process.platform === "darwin"
+            ? ["open", launchUrl]
+            : process.platform === "win32"
+                ? ["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), {
+            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.unref();
+        return launchUrl;
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to open browser automatically: ${error}. Please open this URL manually: ${launchUrl}`);
+        return launchUrl;
+    }
+}

package/dist/tools/live.js

@@ -0,0 +1,97 @@
+"use strict";
+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");
+/**
+ * Launches a Browser Live Session on BrowserStack.
+ */
+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,
+        os: args.desiredOS,
+        osVersion: args.desiredOSVersion,
+        url: args.desiredURL,
+        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}`,
+            },
+        ],
+    };
+}
+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) => {
+        try {
+            return startBrowserLiveSession(args);
+        }
+        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`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/observability.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFailuresInLastRun = getFailuresInLastRun;
+exports.default = addObservabilityTools;
+const zod_1 = require("zod");
+const api_1 = require("../lib/api");
+async function getFailuresInLastRun(buildName, projectName) {
+    const buildsData = await (0, api_1.getLatestO11YBuildInfo)(buildName, projectName);
+    const observabilityUrl = buildsData.observability_url;
+    if (!observabilityUrl) {
+        throw new Error("No observability URL found in build data, this is likely because the build is not yet available on BrowserStack Observability.");
+    }
+    let overview = "No overview available";
+    if (buildsData.unique_errors?.overview?.insight) {
+        overview = buildsData.unique_errors.overview.insight;
+    }
+    let details = "No error details available";
+    if (buildsData.unique_errors?.top_unique_errors?.length > 0) {
+        details = buildsData.unique_errors.top_unique_errors
+            .map((error) => error.error)
+            .filter(Boolean)
+            .join("\n");
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Observability URL: ${observabilityUrl}\nOverview: ${overview}\nError Details: ${details}`,
+            },
+        ],
+    };
+}
+function addObservabilityTools(server) {
+    server.tool("getFailuresInLastRun", "Use this tool to debug failures in the last run of the test suite on BrowserStack. Use only when browserstack.yml file is present in the project root.", {
+        buildName: zod_1.z
+            .string()
+            .describe("Name of the build to get failures for. This is the 'build' key in the browserstack.yml file. If not sure, ask the user for the build name."),
+        projectName: zod_1.z
+            .string()
+            .describe("Name of the project to get failures for. This is the 'projectName' key in the browserstack.yml file. If not sure, ask the user for the project name."),
+    }, async (args) => {
+        try {
+            return getFailuresInLastRun(args.buildName, args.projectName);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get failures in the last run. Error: ${error}. Please open an issue on GitHub if this is an issue with BrowserStack`,
+                        isError: true,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}