@browserstack/mcp-server 1.1.9 → 1.2.1

package/dist/tools/appautomate.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import logger from "../logger.js";
-import config from "../config.js";
+import { getBrowserStackAuth } from "../lib/get-auth.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import { maybeCompressBase64 } from "../lib/utils.js";
 import { remote } from "webdriverio";
@@ -19,7 +19,7 @@ async function takeAppScreenshot(args) {
     let driver;
     try {
         validateArgs(args);
-        const { desiredPlatform, desiredPhone, appPath } = args;
+        const { desiredPlatform, desiredPhone, appPath, config } = args;
         let { desiredPlatformVersion } = args;
         const platforms = (await getDevicesAndBrowsers(BrowserStackProducts.APP_AUTOMATE)).mobile;
         const platformData = platforms.find((p) => p.os === desiredPlatform.toLowerCase());
@@ -33,7 +33,9 @@ async function takeAppScreenshot(args) {
         if (!selectedDevice) {
             throw new Error(`Device "${desiredPhone}" with version ${desiredPlatformVersion} not found.`);
         }
-        const app_url = await uploadApp(appPath);
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const app_url = await uploadApp(appPath, username, password);
         logger.info(`App uploaded. URL: ${app_url}`);
         const capabilities = {
             platformName: desiredPlatform,
@@ -42,8 +44,8 @@ async function takeAppScreenshot(args) {
             "appium:app": app_url,
             "appium:autoGrantPermissions": true,
             "bstack:options": {
-                userName: config.browserstackUsername,
-                accessKey: config.browserstackAccessKey,
+                userName: username,
+                accessKey: password,
                 appiumVersion: "2.0.1",
             },
         };
@@ -86,12 +88,12 @@ async function takeAppScreenshot(args) {
     }
 }
 //Runs AppAutomate tests on BrowserStack by uploading app and test suite, then triggering a test run.
-async function runAppTestsOnBrowserStack(args) {
+async function runAppTestsOnBrowserStack(args, config) {
     switch (args.detectedAutomationFramework) {
         case AppTestPlatform.ESPRESSO: {
             try {
-                const app_url = await uploadEspressoApp(args.appPath);
-                const test_suite_url = await uploadEspressoTestSuite(args.testSuitePath);
+                const app_url = await uploadEspressoApp(args.appPath, config);
+                const test_suite_url = await uploadEspressoTestSuite(args.testSuitePath, config);
                 const build_id = await triggerEspressoBuild(app_url, test_suite_url, args.devices, args.project);
                 return {
                     content: [
@@ -109,9 +111,9 @@ async function runAppTestsOnBrowserStack(args) {
         }
         case AppTestPlatform.XCUITEST: {
             try {
-                const app_url = await uploadXcuiApp(args.appPath);
-                const test_suite_url = await uploadXcuiTestSuite(args.testSuitePath);
-                const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project);
+                const app_url = await uploadXcuiApp(args.appPath, config);
+                const test_suite_url = await uploadXcuiTestSuite(args.testSuitePath, config);
+                const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project, config);
                 return {
                     content: [
                         {
@@ -130,9 +132,9 @@ async function runAppTestsOnBrowserStack(args) {
             throw new Error(`Unsupported automation framework: ${args.detectedAutomationFramework}. If you need support for this framework, please open an issue at Github`);
     }
 }
-// Registers automation tools with the MCP server.
-export default function addAppAutomationTools(server) {
-    server.tool("takeAppScreenshot", "Use this tool to take a screenshot of an app running on a BrowserStack device. This is useful for visual testing and debugging.", {
+export default function addAppAutomationTools(server, config) {
+    const tools = {};
+    tools.takeAppScreenshot = server.tool("takeAppScreenshot", "Use this tool to take a screenshot of an app running on a BrowserStack device. This is useful for visual testing and debugging.", {
         desiredPhone: z
             .string()
             .describe("The full name of the device to run the app on. Example: 'iPhone 12 Pro' or 'Samsung Galaxy S20'. Always ask the user for the device they want to use."),
@@ -147,11 +149,11 @@ export default function addAppAutomationTools(server) {
             .describe("The path to the .apk or .ipa file. Required for app installation."),
     }, async (args) => {
         try {
-            trackMCP("takeAppScreenshot", server.server.getClientVersion());
-            return await takeAppScreenshot(args);
+            trackMCP("takeAppScreenshot", server.server.getClientVersion(), undefined, config);
+            return await takeAppScreenshot({ ...args, config });
         }
         catch (error) {
-            trackMCP("takeAppScreenshot", server.server.getClientVersion(), error);
+            trackMCP("takeAppScreenshot", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
@@ -163,7 +165,7 @@ export default function addAppAutomationTools(server) {
             };
         }
     });
-    server.tool("runAppTestsOnBrowserStack", "Run AppAutomate tests on BrowserStack by uploading app and test suite. If running from Android Studio or Xcode, the tool will help export app and test files automatically. For other environments, you'll need to provide the paths to your pre-built app and test files.", {
+    tools.runAppTestsOnBrowserStack = server.tool("runAppTestsOnBrowserStack", "Run AppAutomate tests on BrowserStack by uploading app and test suite. If running from Android Studio or Xcode, the tool will help export app and test files automatically. For other environments, you'll need to provide the paths to your pre-built app and test files.", {
         appPath: z
             .string()
             .describe("Path to your application file:\n" +
@@ -197,11 +199,11 @@ export default function addAppAutomationTools(server) {
             .describe("The automation framework used in the project, such as 'espresso' (Android) or 'xcuitest' (iOS)."),
     }, async (args) => {
         try {
-            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion());
-            return await runAppTestsOnBrowserStack(args);
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), undefined, config);
+            return await runAppTestsOnBrowserStack(args, config);
         }
         catch (error) {
-            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), error);
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
@@ -214,4 +216,5 @@ export default function addAppAutomationTools(server) {
             };
         }
     });
+    return tools;
 }

package/dist/tools/applive-utils/device-search.d.ts

@@ -0,0 +1,6 @@
+import { DeviceEntry } from "./types.js";
+/**
+ * Find matching devices by name with exact match preference.
+ * Throws if none or multiple exact matches.
+ */
+export declare function findDeviceByName(devices: DeviceEntry[], desiredPhone: string): DeviceEntry[];

package/dist/tools/applive-utils/start-session.d.ts

@@ -0,0 +1,15 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+interface StartSessionArgs {
+    appPath: string;
+    desiredPlatform: "android" | "ios";
+    desiredPhone: string;
+    desiredPlatformVersion: string;
+}
+interface StartSessionOptions {
+    config: BrowserStackConfig;
+}
+/**
+ * Start an App Live session: filter, select, upload, and open.
+ */
+export declare function startSession(args: StartSessionArgs, options: StartSessionOptions): Promise<string>;
+export {};

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

@@ -1,15 +1,18 @@
 import logger from "../../logger.js";
-import childProcess from "child_process";
 import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
 import { sanitizeUrlParam } from "../../lib/utils.js";
 import { uploadApp } from "./upload-app.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { findDeviceByName } from "./device-search.js";
 import { pickVersion } from "./version-utils.js";
+import childProcess from "child_process";
+import envConfig from "../../config.js";
 /**
  * Start an App Live session: filter, select, upload, and open.
  */
-export async function startSession(args) {
+export async function startSession(args, options) {
     const { appPath, desiredPlatform, desiredPhone, desiredPlatformVersion } = args;
+    const { config } = options;
     // 1) Fetch devices for APP_LIVE
     const data = await getDevicesAndBrowsers(BrowserStackProducts.APP_LIVE);
     const all = data.mobile.flatMap((grp) => grp.devices.map((dev) => ({ ...dev, os: grp.os })));
@@ -36,7 +39,9 @@ export async function startSession(args) {
         note = `\n Note: The requested version "${desiredPlatformVersion}" is not available. Using "${version}" instead.`;
     }
     // 6) Upload app
-    const { app_url } = await uploadApp(appPath);
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
+    const { app_url } = await uploadApp(appPath, username, password);
     logger.info(`App uploaded: ${app_url}`);
     if (!app_url) {
         throw new Error("Failed to upload app. Please try again.");
@@ -52,7 +57,9 @@ export async function startSession(args) {
         start: "true",
     });
     const launchUrl = `https://app-live.browserstack.com/dashboard#${params.toString()}&device=${deviceParam}`;
-    openBrowser(launchUrl);
+    if (!envConfig.REMOTE_MCP) {
+        openBrowser(launchUrl);
+    }
     return launchUrl + note;
 }
 /**

package/dist/tools/applive-utils/types.d.ts

@@ -0,0 +1,7 @@
+export interface DeviceEntry {
+    display_name: string;
+    device: string;
+    os: string;
+    os_version: string;
+    real_mobile: boolean;
+}

package/dist/tools/applive-utils/upload-app.d.ts

@@ -0,0 +1,5 @@
+interface UploadResponse {
+    app_url: string;
+}
+export declare function uploadApp(filePath: string, username: string, password: string): Promise<UploadResponse>;
+export {};

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

@@ -1,29 +1,25 @@
-import axios, { AxiosError } from "axios";
+import { apiClient } from "../../lib/apiClient.js";
 import FormData from "form-data";
 import fs from "fs";
-import config from "../../config.js";
-export async function uploadApp(filePath) {
+export async function uploadApp(filePath, username, password) {
     if (!fs.existsSync(filePath)) {
         throw new Error(`File not found at path: ${filePath}`);
     }
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
     try {
-        const response = await axios.post("https://api-cloud.browserstack.com/app-live/upload", formData, {
+        const response = await apiClient.post({
+            url: "https://api-cloud.browserstack.com/app-live/upload",
             headers: {
                 ...formData.getHeaders(),
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
-            },
+            body: formData,
         });
         return response.data;
     }
     catch (error) {
-        if (error instanceof AxiosError) {
-            throw new Error(`Failed to upload app: ${error.response?.data?.message || error.message}`);
-        }
-        throw error;
+        const msg = error?.response?.data?.message || error?.message || String(error);
+        throw new Error(`Failed to upload app: ${msg}`);
     }
 }

package/dist/tools/applive-utils/version-utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Resolve desired version against available list
+ */
+export declare function pickVersion(available: string[], requested: string): string;

package/dist/tools/applive.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../lib/types.js";
+/**
+ * Launches an App Live Session on BrowserStack.
+ */
+export declare function startAppLiveSession(args: {
+    desiredPlatform: string;
+    desiredPlatformVersion: string;
+    appPath: string;
+    desiredPhone: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;
+export default function addAppLiveTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/applive.js

@@ -6,7 +6,7 @@ import { trackMCP } from "../lib/instrumentation.js";
 /**
  * Launches an App Live Session on BrowserStack.
  */
-export async function startAppLiveSession(args) {
+export async function startAppLiveSession(args, config) {
     if (!args.desiredPlatform) {
         throw new Error("You must provide a desiredPlatform.");
     }
@@ -38,7 +38,7 @@ export async function startAppLiveSession(args) {
         desiredPlatform: args.desiredPlatform,
         desiredPhone: args.desiredPhone,
         desiredPlatformVersion: args.desiredPlatformVersion,
-    });
+    }, { config });
     return {
         content: [
             {
@@ -48,8 +48,9 @@ export async function startAppLiveSession(args) {
         ],
     };
 }
-export default 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.", {
+export default function addAppLiveTools(server, config) {
+    const tools = {};
+    tools.runAppLiveSession = 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: 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. "),
@@ -64,12 +65,12 @@ export default 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 {
-            trackMCP("runAppLiveSession", server.server.getClientVersion());
-            return await startAppLiveSession(args);
+            trackMCP("runAppLiveSession", server.server.getClientVersion(), undefined, config);
+            return await startAppLiveSession(args, config);
         }
         catch (error) {
             logger.error("App live session failed: %s", error);
-            trackMCP("runAppLiveSession", server.server.getClientVersion(), error);
+            trackMCP("runAppLiveSession", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {
@@ -82,4 +83,5 @@ export default function addAppLiveTools(server) {
             };
         }
     });
+    return tools;
 }

package/dist/tools/automate-utils/fetch-screenshots.d.ts

@@ -0,0 +1,6 @@
+import { SessionType } from "../../lib/constants.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function fetchAutomationScreenshots(sessionId: string, sessionType: SessionType | undefined, config: BrowserStackConfig): Promise<{
+    url: string;
+    base64: string;
+}[]>;

package/dist/tools/automate-utils/fetch-screenshots.js

@@ -1,20 +1,24 @@
-import config from "../../config.js";
 import { assertOkResponse, maybeCompressBase64 } from "../../lib/utils.js";
 import { SessionType } from "../../lib/constants.js";
-//Extracts screenshot URLs from BrowserStack session logs
-async function extractScreenshotUrls(sessionId, sessionType) {
-    const credentials = `${config.browserstackUsername}:${config.browserstackAccessKey}`;
-    const auth = Buffer.from(credentials).toString("base64");
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { apiClient } from "../../lib/apiClient.js";
+async function extractScreenshotUrls(sessionId, sessionType, config) {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
     const baseUrl = `https://api.browserstack.com/${sessionType === SessionType.Automate ? "automate" : "app-automate"}`;
     const url = `${baseUrl}/sessions/${sessionId}/logs`;
-    const response = await fetch(url, {
+    const response = await apiClient.get({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
+        raise_error: false,
     });
     await assertOkResponse(response, "Session");
-    const text = await response.text();
+    const text = typeof response.data === "string"
+        ? response.data
+        : JSON.stringify(response.data);
     const urls = [];
     const SCREENSHOT_PATTERN = /REQUEST.*GET.*\/screenshot/;
     const RESPONSE_VALUE_PATTERN = /"value"\s*:\s*"([^"]+)"/;
@@ -35,9 +39,9 @@ async function extractScreenshotUrls(sessionId, sessionType) {
 //Converts screenshot URLs to base64 encoded images
 async function convertUrlsToBase64(urls) {
     const screenshots = await Promise.all(urls.map(async (url) => {
-        const response = await fetch(url);
-        const arrayBuffer = await response.arrayBuffer();
-        const base64 = Buffer.from(arrayBuffer).toString("base64");
+        const response = await apiClient.get({ url });
+        // Axios returns response.data as a Buffer for binary data
+        const base64 = Buffer.from(response.data).toString("base64");
         // Compress the base64 image if needed
         const compressedBase64 = await maybeCompressBase64(base64);
         return {
@@ -48,8 +52,8 @@ async function convertUrlsToBase64(urls) {
     return screenshots;
 }
 //Fetches and converts screenshot URLs to base64 encoded images
-export async function fetchAutomationScreenshots(sessionId, sessionType = SessionType.Automate) {
-    const urls = await extractScreenshotUrls(sessionId, sessionType);
+export async function fetchAutomationScreenshots(sessionId, sessionType = SessionType.Automate, config) {
+    const urls = await extractScreenshotUrls(sessionId, sessionType, config);
     if (urls.length === 0) {
         return [];
     }

package/dist/tools/automate.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { SessionType } from "../lib/constants.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function fetchAutomationScreenshotsTool(args: {
+    sessionId: string;
+    sessionType: SessionType;
+}, config: BrowserStackConfig): Promise<CallToolResult>;
+export default function addAutomationTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/automate.js

@@ -4,9 +4,9 @@ import { SessionType } from "../lib/constants.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import logger from "../logger.js";
 // Tool function that fetches and processes screenshots from BrowserStack Automate session
-export async function fetchAutomationScreenshotsTool(args) {
+export async function fetchAutomationScreenshotsTool(args, config) {
     try {
-        const screenshots = await fetchAutomationScreenshots(args.sessionId, args.sessionType);
+        const screenshots = await fetchAutomationScreenshots(args.sessionId, args.sessionType, config);
         if (screenshots.length === 0) {
             return {
                 content: [
@@ -41,8 +41,9 @@ export async function fetchAutomationScreenshotsTool(args) {
     }
 }
 //Registers the fetchAutomationScreenshots tool with the MCP server
-export default function addAutomationTools(server) {
-    server.tool("fetchAutomationScreenshots", "Fetch and process screenshots from a BrowserStack Automate session", {
+export default function addAutomationTools(server, config) {
+    const tools = {};
+    tools.fetchAutomationScreenshots = server.tool("fetchAutomationScreenshots", "Fetch and process screenshots from a BrowserStack Automate session", {
         sessionId: z
             .string()
             .describe("The BrowserStack session ID to fetch screenshots from"),
@@ -51,11 +52,11 @@ export default function addAutomationTools(server) {
             .describe("Type of BrowserStack session"),
     }, async (args) => {
         try {
-            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion());
-            return await fetchAutomationScreenshotsTool(args);
+            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion(), undefined, config);
+            return await fetchAutomationScreenshotsTool(args, config);
         }
         catch (error) {
-            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion(), error);
+            trackMCP("fetchAutomationScreenshots", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
@@ -67,4 +68,5 @@ export default function addAutomationTools(server) {
             };
         }
     });
+    return tools;
 }

package/dist/tools/bstack-sdk.d.ts

@@ -0,0 +1,17 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { SDKSupportedBrowserAutomationFramework, SDKSupportedLanguage, SDKSupportedTestingFramework } from "./sdk-utils/types.js";
+import { BrowserStackConfig } from "../lib/types.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 declare function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, enablePercy, config, }: {
+    detectedBrowserAutomationFramework: SDKSupportedBrowserAutomationFramework;
+    detectedTestingFramework: SDKSupportedTestingFramework;
+    detectedLanguage: SDKSupportedLanguage;
+    desiredPlatforms: string[];
+    enablePercy: boolean;
+    config: BrowserStackConfig;
+}): Promise<CallToolResult>;
+export default function addSDKTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/bstack-sdk.js

@@ -4,15 +4,19 @@ import { getSDKPrefixCommand } from "./sdk-utils/commands.js";
 import { SDKSupportedLanguageEnum, SDKSupportedBrowserAutomationFrameworkEnum, SDKSupportedTestingFrameworkEnum, } from "./sdk-utils/types.js";
 import { generateBrowserStackYMLInstructions, getInstructionsForProjectConfiguration, formatInstructionsWithNumbers, } from "./sdk-utils/instructions.js";
 import { formatPercyInstructions, getPercyInstructions, } from "./sdk-utils/percy/instructions.js";
+import { getBrowserStackAuth } from "../lib/get-auth.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, enablePercy, }) {
+export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, desiredPlatforms, enablePercy, config, }) {
+    // Get credentials from config
+    const authString = getBrowserStackAuth(config);
+    const [username, accessKey] = authString.split(":");
     // Handle frameworks with unique setup instructions that don't use browserstack.yml
     if (detectedBrowserAutomationFramework === "cypress" ||
         detectedTestingFramework === "webdriverio") {
-        let combinedInstructions = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+        let combinedInstructions = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
         if (enablePercy) {
             const percyInstructions = getPercyInstructions(detectedLanguage, detectedBrowserAutomationFramework, detectedTestingFramework);
             if (percyInstructions) {
@@ -27,9 +31,9 @@ export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramewo
         return formatFinalInstructions(combinedInstructions);
     }
     // Handle default flow using browserstack.yml
-    const sdkSetupCommand = getSDKPrefixCommand(detectedLanguage, detectedTestingFramework);
+    const sdkSetupCommand = getSDKPrefixCommand(detectedLanguage, detectedTestingFramework, username, accessKey);
     const ymlInstructions = generateBrowserStackYMLInstructions(desiredPlatforms, enablePercy);
-    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
     let combinedInstructions = "";
     // Step 1: Add SDK setup command
     if (sdkSetupCommand) {
@@ -74,8 +78,9 @@ function formatFinalInstructions(combinedInstructions) {
         ],
     };
 }
-export default function addSDKTools(server) {
-    server.tool("runTestsOnBrowserStack", "Use this tool to get instructions for running tests on BrowserStack and BrowserStack Percy. It sets up the BrowserStack SDK and runs your test cases on BrowserStack.", {
+export default function addSDKTools(server, config) {
+    const tools = {};
+    tools.setupBrowserStackAutomateTests = server.tool("setupBrowserStackAutomateTests", "Set up and run automated web-based tests on BrowserStack using the BrowserStack SDK. Use for functional or integration tests on BrowserStack, with optional Percy visual testing for supported frameworks. Example prompts: run this test on browserstack; run this test on browserstack with Percy; set up this project for browserstack with Percy. Integrate BrowserStack SDK into your project", {
         detectedBrowserAutomationFramework: z
             .nativeEnum(SDKSupportedBrowserAutomationFrameworkEnum)
             .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
@@ -95,17 +100,18 @@ export default function addSDKTools(server) {
             .describe("Set to true if the user wants to enable Percy for visual testing. Defaults to false."),
     }, async (args) => {
         try {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion());
+            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), undefined, config);
             return await bootstrapProjectWithSDK({
                 detectedBrowserAutomationFramework: args.detectedBrowserAutomationFramework,
                 detectedTestingFramework: args.detectedTestingFramework,
                 detectedLanguage: args.detectedLanguage,
                 desiredPlatforms: args.desiredPlatforms,
                 enablePercy: args.enablePercy,
+                config,
             });
         }
         catch (error) {
-            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error);
+            trackMCP("runTestsOnBrowserStack", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {
@@ -118,4 +124,5 @@ export default function addSDKTools(server) {
             };
         }
     });
+    return tools;
 }

package/dist/tools/failurelogs-utils/app-automate.d.ts

@@ -0,0 +1,7 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function retrieveDeviceLogs(sessionId: string, buildId: string, config: BrowserStackConfig): Promise<string>;
+export declare function retrieveAppiumLogs(sessionId: string, buildId: string, config: BrowserStackConfig): Promise<string>;
+export declare function retrieveCrashLogs(sessionId: string, buildId: string, config: BrowserStackConfig): Promise<string>;
+export declare function filterDeviceFailures(logText: string): string[];
+export declare function filterAppiumFailures(logText: string): string[];
+export declare function filterCrashFailures(logText: string): string[];

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

@@ -1,55 +1,73 @@
-import config from "../../config.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { filterLinesByKeywords, validateLogResponse } from "./utils.js";
-const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
+import { apiClient } from "../../lib/apiClient.js";
 // DEVICE LOGS
-export async function retrieveDeviceLogs(sessionId, buildId) {
+export async function retrieveDeviceLogs(sessionId, buildId, config) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/deviceLogs`;
-    const response = await fetch(url, {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.get({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
+        raise_error: false,
     });
     const validationError = validateLogResponse(response, "device logs");
     if (validationError)
         return validationError.message;
-    const logText = await response.text();
+    const logText = typeof response.data === "string"
+        ? response.data
+        : JSON.stringify(response.data);
     const logs = filterDeviceFailures(logText);
     return logs.length > 0
         ? `Device Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No device failures found";
 }
 // APPIUM LOGS
-export async function retrieveAppiumLogs(sessionId, buildId) {
+export async function retrieveAppiumLogs(sessionId, buildId, config) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/appiumlogs`;
-    const response = await fetch(url, {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.get({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
+        raise_error: false,
     });
     const validationError = validateLogResponse(response, "Appium logs");
     if (validationError)
         return validationError.message;
-    const logText = await response.text();
+    const logText = typeof response.data === "string"
+        ? response.data
+        : JSON.stringify(response.data);
     const logs = filterAppiumFailures(logText);
     return logs.length > 0
         ? `Appium Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No Appium failures found";
 }
 // CRASH LOGS
-export async function retrieveCrashLogs(sessionId, buildId) {
+export async function retrieveCrashLogs(sessionId, buildId, config) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/crashlogs`;
-    const response = await fetch(url, {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.get({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
+        raise_error: false,
     });
     const validationError = validateLogResponse(response, "crash logs");
     if (validationError)
         return validationError.message;
-    const logText = await response.text();
+    const logText = typeof response.data === "string"
+        ? response.data
+        : JSON.stringify(response.data);
     const logs = filterCrashFailures(logText);
     return logs.length > 0
         ? `Crash Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`

package/dist/tools/failurelogs-utils/automate.d.ts

@@ -0,0 +1,6 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function retrieveNetworkFailures(sessionId: string, config: BrowserStackConfig): Promise<string>;
+export declare function retrieveSessionFailures(sessionId: string, config: BrowserStackConfig): Promise<string>;
+export declare function retrieveConsoleFailures(sessionId: string, config: BrowserStackConfig): Promise<string>;
+export declare function filterSessionFailures(logText: string): string[];
+export declare function filterConsoleFailures(logText: string): string[];