@browserstack/mcp-server 1.1.8 → 1.2.0

package/dist/tools/appautomate-utils/appautomate.js

@@ -1,7 +1,6 @@
 import fs from "fs";
-import axios from "axios";
-import config from "../../config.js";
 import FormData from "form-data";
+import { apiClient } from "../../lib/apiClient.js";
 import { customFuzzySearch } from "../../lib/fuzzy.js";
 /**
  * Finds devices that exactly match the provided display name.
@@ -70,26 +69,113 @@ export function validateArgs(args) {
 /**
  * Uploads an application file to AppAutomate and returns the app URL
  */
-export async function uploadApp(appPath) {
+export async function uploadApp(appPath, username, password) {
     const filePath = appPath;
     if (!fs.existsSync(filePath)) {
         throw new Error(`File not found at path: ${filePath}`);
     }
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
-    const response = await axios.post("https://api-cloud.browserstack.com/app-automate/upload", formData, {
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/upload",
         headers: {
             ...formData.getHeaders(),
+            Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
         },
-        auth: {
-            username: config.browserstackUsername,
-            password: config.browserstackAccessKey,
-        },
+        body: formData,
     });
     if (response.data.app_url) {
         return response.data.app_url;
     }
     else {
-        throw new Error(`Failed to upload app: ${response.data}`);
+        throw new Error(`Failed to upload app: ${JSON.stringify(response.data)}`);
+    }
+}
+// Helper to upload a file to a given BrowserStack endpoint and return a specific property from the response.
+async function uploadFileToBrowserStack(filePath, endpoint, responseKey, config) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found at path: ${filePath}`);
+    }
+    const formData = new FormData();
+    formData.append("file", fs.createReadStream(filePath));
+    const authHeader = "Basic " +
+        Buffer.from(`${config["browserstack-username"]}:${config["browserstack-access-key"]}`).toString("base64");
+    const response = await apiClient.post({
+        url: endpoint,
+        headers: {
+            ...formData.getHeaders(),
+            Authorization: authHeader,
+        },
+        body: formData,
+    });
+    if (response.data[responseKey]) {
+        return response.data[responseKey];
+    }
+    throw new Error(`Failed to upload file: ${JSON.stringify(response.data)}`);
+}
+//Uploads an Android app (.apk or .aab) to BrowserStack Espresso endpoint and returns the app_url
+export async function uploadEspressoApp(appPath, config) {
+    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/app", "app_url", config);
+}
+//Uploads an Espresso test suite (.apk) to BrowserStack and returns the test_suite_url
+export async function uploadEspressoTestSuite(testSuitePath, config) {
+    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/test-suite", "test_suite_url", config);
+}
+//Uploads an iOS app (.ipa) to BrowserStack XCUITest endpoint and returns the app_url
+export async function uploadXcuiApp(appPath, config) {
+    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/app", "app_url", config);
+}
+//Uploads an XCUITest test suite (.zip) to BrowserStack and returns the test_suite_url
+export async function uploadXcuiTestSuite(testSuitePath, config) {
+    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/test-suite", "test_suite_url", config);
+}
+// Triggers an Espresso test run on BrowserStack and returns the build_id
+export async function triggerEspressoBuild(app_url, test_suite_url, devices, project) {
+    const auth = {
+        username: process.env.BROWSERSTACK_USERNAME || "",
+        password: process.env.BROWSERSTACK_ACCESS_KEY || "",
+    };
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/espresso/v2/build",
+        headers: {
+            Authorization: "Basic " +
+                Buffer.from(`${auth.username}:${auth.password}`).toString("base64"),
+            "Content-Type": "application/json",
+        },
+        body: {
+            app: app_url,
+            testSuite: test_suite_url,
+            devices,
+            project,
+        },
+    });
+    if (response.data.build_id) {
+        return response.data.build_id;
+    }
+    throw new Error(`Failed to trigger Espresso build: ${JSON.stringify(response.data)}`);
+}
+// Triggers an XCUITest run on BrowserStack and returns the build_id
+export async function triggerXcuiBuild(app_url, test_suite_url, devices, project, config) {
+    const auth = {
+        username: config["browserstack-username"],
+        password: config["browserstack-access-key"],
+    };
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/build",
+        headers: {
+            Authorization: "Basic " +
+                Buffer.from(`${auth.username}:${auth.password}`).toString("base64"),
+            "Content-Type": "application/json",
+        },
+        body: {
+            app: app_url,
+            testSuite: test_suite_url,
+            devices,
+            project,
+        },
+    });
+    if (response.data.build_id) {
+        return response.data.build_id;
     }
+    throw new Error(`Failed to trigger XCUITest build: ${JSON.stringify(response.data)}`);
 }

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

@@ -0,0 +1,5 @@
+export declare enum AppTestPlatform {
+    ESPRESSO = "espresso",
+    APPIUM = "appium",
+    XCUITEST = "xcuitest"
+}

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

@@ -0,0 +1,6 @@
+export var AppTestPlatform;
+(function (AppTestPlatform) {
+    AppTestPlatform["ESPRESSO"] = "espresso";
+    AppTestPlatform["APPIUM"] = "appium";
+    AppTestPlatform["XCUITEST"] = "xcuitest";
+})(AppTestPlatform || (AppTestPlatform = {}));

package/dist/tools/appautomate.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export default function addAppAutomationTools(server: McpServer, config: BrowserStackConfig): void;

package/dist/tools/appautomate.js

@@ -1,11 +1,12 @@
 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";
+import { AppTestPlatform } from "./appautomate-utils/types.js";
 import { getDevicesAndBrowsers, BrowserStackProducts, } from "../lib/device-cache.js";
-import { findMatchingDevice, getDeviceVersions, resolveVersion, validateArgs, uploadApp, } from "./appautomate-utils/appautomate.js";
+import { findMatchingDevice, getDeviceVersions, resolveVersion, validateArgs, uploadApp, uploadEspressoApp, uploadEspressoTestSuite, triggerEspressoBuild, uploadXcuiApp, uploadXcuiTestSuite, triggerXcuiBuild, } from "./appautomate-utils/appautomate.js";
 var Platform;
 (function (Platform) {
     Platform["ANDROID"] = "android";
@@ -18,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());
@@ -32,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,
@@ -41,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",
             },
         };
@@ -84,10 +87,52 @@ async function takeAppScreenshot(args) {
         }
     }
 }
-/**
- * Registers the `takeAppScreenshot` tool with the MCP server.
- */
-export default function addAppAutomationTools(server) {
+//Runs AppAutomate tests on BrowserStack by uploading app and test suite, then triggering a test run.
+async function runAppTestsOnBrowserStack(args, config) {
+    switch (args.detectedAutomationFramework) {
+        case AppTestPlatform.ESPRESSO: {
+            try {
+                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: [
+                        {
+                            type: "text",
+                            text: `✅ Espresso run started successfully!\n\n🔧 Build ID: ${build_id}\n🔗 View your build: https://app-automate.browserstack.com/builds/${build_id}`,
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                logger.error("Error running App Automate test", err);
+                throw err;
+            }
+        }
+        case AppTestPlatform.XCUITEST: {
+            try {
+                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: [
+                        {
+                            type: "text",
+                            text: `✅ XCUITest run started successfully!\n\n🔧 Build ID: ${build_id}\n🔗 View your build: https://app-automate.browserstack.com/builds/${build_id}`,
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                logger.error("Error running XCUITest App Automate test", err);
+                throw err;
+            }
+        }
+        default:
+            throw new Error(`Unsupported automation framework: ${args.detectedAutomationFramework}. If you need support for this framework, please open an issue at Github`);
+    }
+}
+export default function addAppAutomationTools(server, config) {
     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()
@@ -103,11 +148,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: [
@@ -119,4 +164,55 @@ 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.", {
+        appPath: z
+            .string()
+            .describe("Path to your application file:\n" +
+            "If in development IDE directory:\n" +
+            "• For Android: 'gradle assembleDebug'\n" +
+            "• For iOS:\n" +
+            "  xcodebuild clean -scheme YOUR_SCHEME && \\\n" +
+            "  xcodebuild archive -scheme YOUR_SCHEME -configuration Release -archivePath build/app.xcarchive && \\\n" +
+            "  xcodebuild -exportArchive -archivePath build/app.xcarchive -exportPath build/ipa -exportOptionsPlist exportOptions.plist\n\n" +
+            "If in other directory, provide existing app path"),
+        testSuitePath: z
+            .string()
+            .describe("Path to your test suite file:\n" +
+            "If in development IDE directory:\n" +
+            "• For Android: 'gradle assembleAndroidTest'\n" +
+            "• For iOS:\n" +
+            "  xcodebuild test-without-building -scheme YOUR_SCHEME -destination 'generic/platform=iOS' && \\\n" +
+            "  cd ~/Library/Developer/Xcode/DerivedData/*/Build/Products/Debug-iphonesimulator/ && \\\n" +
+            "  zip -r Tests.zip *.xctestrun *-Runner.app\n\n" +
+            "If in other directory, provide existing test file path"),
+        devices: z
+            .array(z.string())
+            .describe("List of devices to run the test on, e.g., ['Samsung Galaxy S20-10.0', 'iPhone 12 Pro-16.0']."),
+        project: z
+            .string()
+            .optional()
+            .default("BStack-AppAutomate-Suite")
+            .describe("Project name for organizing test runs on BrowserStack."),
+        detectedAutomationFramework: z
+            .string()
+            .describe("The automation framework used in the project, such as 'espresso' (Android) or 'xcuitest' (iOS)."),
+    }, async (args) => {
+        try {
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), undefined, config);
+            return await runAppTestsOnBrowserStack(args, config);
+        }
+        catch (error) {
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), error, config);
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error running App Automate test: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
 }

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): void;

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,7 +48,7 @@ export async function startAppLiveSession(args) {
         ],
     };
 }
-export default function addAppLiveTools(server) {
+export default function addAppLiveTools(server, config) {
     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()
@@ -64,12 +64,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: [
                     {

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): void;

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,7 +41,7 @@ export async function fetchAutomationScreenshotsTool(args) {
     }
 }
 //Registers the fetchAutomationScreenshots tool with the MCP server
-export default function addAutomationTools(server) {
+export default function addAutomationTools(server, config) {
     server.tool("fetchAutomationScreenshots", "Fetch and process screenshots from a BrowserStack Automate session", {
         sessionId: z
             .string()
@@ -51,11 +51,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: [

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): void;