@browserstack/mcp-server 1.1.8 → 1.2.0

package/dist/tools/bstack-sdk.js

@@ -1,47 +1,73 @@
 import { z } from "zod";
-import { SDKSupportedLanguageEnum, SDKSupportedBrowserAutomationFrameworkEnum, SDKSupportedTestingFrameworkEnum, } from "./sdk-utils/types.js";
-import { generateBrowserStackYMLInstructions, getInstructionsForProjectConfiguration, } from "./sdk-utils/instructions.js";
 import { trackMCP } from "../lib/instrumentation.js";
-import { formatPercyInstructions, getPercyInstructions, } from "./sdk-utils/percy/instructions.js";
 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 instructions = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+        let combinedInstructions = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
         if (enablePercy) {
             const percyInstructions = getPercyInstructions(detectedLanguage, detectedBrowserAutomationFramework, detectedTestingFramework);
             if (percyInstructions) {
-                instructions += formatPercyInstructions(percyInstructions);
+                combinedInstructions +=
+                    "\n\n" + formatPercyInstructions(percyInstructions);
             }
             else {
                 throw new Error(`Percy is currently not supported through MCP for ${detectedLanguage} with ${detectedTestingFramework}. If you want to run the test cases without Percy, disable Percy and run it again.`);
             }
         }
-        return {
-            content: [{ type: "text", text: instructions, isError: false }],
-        };
+        // Apply consistent formatting for all configurations
+        return formatFinalInstructions(combinedInstructions);
     }
-    let fullInstructions = "";
-    // Add language-dependent prefix command
-    fullInstructions += getSDKPrefixCommand(detectedLanguage, detectedTestingFramework);
+    // Handle default flow using browserstack.yml
+    const sdkSetupCommand = getSDKPrefixCommand(detectedLanguage, detectedTestingFramework, username, accessKey);
     const ymlInstructions = generateBrowserStackYMLInstructions(desiredPlatforms, enablePercy);
-    fullInstructions += `${ymlInstructions}`;
-    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage);
+    const instructionsForProjectConfiguration = getInstructionsForProjectConfiguration(detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage, username, accessKey);
+    let combinedInstructions = "";
+    // Step 1: Add SDK setup command
+    if (sdkSetupCommand) {
+        combinedInstructions += sdkSetupCommand;
+    }
+    // Step 2: Add browserstack.yml setup
+    if (ymlInstructions) {
+        combinedInstructions += "\n\n---STEP---\n" + ymlInstructions;
+    }
+    // Step 3: Add language/framework-specific setup
+    if (instructionsForProjectConfiguration) {
+        combinedInstructions += "\n\n" + instructionsForProjectConfiguration;
+    }
+    // Step 4: Add Percy setup if applicable
     if (enablePercy) {
         const percyInstructions = getPercyInstructions(detectedLanguage, detectedBrowserAutomationFramework, detectedTestingFramework);
         if (percyInstructions) {
-            fullInstructions += formatPercyInstructions(percyInstructions);
+            combinedInstructions +=
+                "\n\n" + formatPercyInstructions(percyInstructions);
         }
         else {
             throw new Error(`Percy is currently not supported through MCP for ${detectedLanguage} with ${detectedTestingFramework}. If you want to run the test cases without Percy, disable Percy and run it again.`);
         }
     }
-    fullInstructions += `\n\nAfter setting up the files above, follow these final steps:\n${instructionsForProjectConfiguration}`;
+    // Apply consistent formatting for all configurations
+    return formatFinalInstructions(combinedInstructions);
+}
+// Helper function to apply consistent formatting to all instruction types
+function formatFinalInstructions(combinedInstructions) {
+    const fullInstructions = `⚠️ IMPORTANT: DO NOT SKIP ANY STEP
+  All the setup steps described in this file MUST be executed regardless of any existing configuration or setup.
+  This ensures proper BrowserStack SDK setup.
+
+  ${formatInstructionsWithNumbers(combinedInstructions)}`;
     return {
         content: [
             {
@@ -52,8 +78,8 @@ export async function bootstrapProjectWithSDK({ detectedBrowserAutomationFramewo
         ],
     };
 }
-export default function addSDKTools(server) {
-    server.tool("runTestsOnBrowserStack", "Use this tool to get instructions for running tests on BrowserStack and browserstack percy", {
+export default function addSDKTools(server, config) {
+    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.", {
         detectedBrowserAutomationFramework: z
             .nativeEnum(SDKSupportedBrowserAutomationFrameworkEnum)
             .describe("The automation framework configured in the project. Example: 'playwright', 'selenium'"),
@@ -73,17 +99,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: [
                     {

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[];

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

@@ -1,20 +1,23 @@
-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";
 // NETWORK LOGS
-export async function retrieveNetworkFailures(sessionId) {
+export async function retrieveNetworkFailures(sessionId, config) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/networklogs`;
-    const response = await fetch(url, {
-        method: "GET",
+    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, "network logs");
     if (validationError)
         return validationError.message;
-    const networklogs = await response.json();
+    const networklogs = response.data;
     const failureEntries = networklogs.log.entries.filter((entry) => entry.response.status === 0 ||
         entry.response.status >= 400 ||
         entry.response._error !== undefined);
@@ -37,36 +40,48 @@ export async function retrieveNetworkFailures(sessionId) {
         : "No network failures found";
 }
 // SESSION LOGS
-export async function retrieveSessionFailures(sessionId) {
+export async function retrieveSessionFailures(sessionId, config) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
-    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, "session 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 = filterSessionFailures(logText);
     return logs.length > 0
         ? `Session Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No session failures found";
 }
 // CONSOLE LOGS
-export async function retrieveConsoleFailures(sessionId) {
+export async function retrieveConsoleFailures(sessionId, config) {
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/consolelogs`;
-    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, "console 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 = filterConsoleFailures(logText);
     return logs.length > 0
         ? `Console Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`

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

@@ -0,0 +1,30 @@
+import type { ApiResponse } from "../../lib/apiClient.js";
+export interface LogResponse {
+    logs?: any[];
+    message?: string;
+}
+export interface HarFile {
+    log: {
+        entries: HarEntry[];
+    };
+}
+export interface HarEntry {
+    startedDateTime: string;
+    request: {
+        method: string;
+        url: string;
+        queryString?: {
+            name: string;
+            value: string;
+        }[];
+    };
+    response: {
+        status: number;
+        statusText?: string;
+        _error?: string;
+    };
+    serverIPAddress?: string;
+    time?: number;
+}
+export declare function validateLogResponse(response: Response | ApiResponse, logType: string): LogResponse | null;
+export declare function filterLinesByKeywords(logText: string, keywords: string[]): string[];

package/dist/tools/getFailureLogs.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../lib/types.js";
+import { AppAutomateLogType, AutomateLogType, SessionType } from "../lib/constants.js";
+type LogType = AutomateLogType | AppAutomateLogType;
+type SessionTypeValues = SessionType;
+export declare function getFailureLogs(args: {
+    sessionId: string;
+    buildId?: string;
+    logTypes: LogType[];
+    sessionType: SessionTypeValues;
+}, config: BrowserStackConfig): Promise<CallToolResult>;
+export default function registerGetFailureLogs(server: McpServer, config: BrowserStackConfig): void;
+export {};

package/dist/tools/getFailureLogs.js

@@ -5,7 +5,7 @@ import { retrieveNetworkFailures, retrieveSessionFailures, retrieveConsoleFailur
 import { retrieveDeviceLogs, retrieveAppiumLogs, retrieveCrashLogs, } from "./failurelogs-utils/app-automate.js";
 import { AppAutomateLogType, AutomateLogType, SessionType, } from "../lib/constants.js";
 // Main log fetcher function
-export async function getFailureLogs(args) {
+export async function getFailureLogs(args, config) {
     const results = [];
     const errors = [];
     let validLogTypes = [];
@@ -53,32 +53,32 @@ export async function getFailureLogs(args) {
         for (const logType of validLogTypes) {
             switch (logType) {
                 case AutomateLogType.NetworkLogs: {
-                    response = await retrieveNetworkFailures(args.sessionId);
+                    response = await retrieveNetworkFailures(args.sessionId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AutomateLogType.SessionLogs: {
-                    response = await retrieveSessionFailures(args.sessionId);
+                    response = await retrieveSessionFailures(args.sessionId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AutomateLogType.ConsoleLogs: {
-                    response = await retrieveConsoleFailures(args.sessionId);
+                    response = await retrieveConsoleFailures(args.sessionId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.DeviceLogs: {
-                    response = await retrieveDeviceLogs(args.sessionId, args.buildId);
+                    response = await retrieveDeviceLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.AppiumLogs: {
-                    response = await retrieveAppiumLogs(args.sessionId, args.buildId);
+                    response = await retrieveAppiumLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.CrashLogs: {
-                    response = await retrieveCrashLogs(args.sessionId, args.buildId);
+                    response = await retrieveCrashLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
@@ -98,7 +98,7 @@ export async function getFailureLogs(args) {
     return { content: results };
 }
 // Register tool with the MCP server
-export default function registerGetFailureLogs(server) {
+export default function registerGetFailureLogs(server, config) {
     server.tool("getFailureLogs", "Fetch various types of logs from a BrowserStack session. Supports both automate and app-automate sessions.", {
         sessionType: z
             .enum([SessionType.Automate, SessionType.AppAutomate])
@@ -122,12 +122,12 @@ export default function registerGetFailureLogs(server) {
             .describe("The types of logs to fetch."),
     }, async (args) => {
         try {
-            trackMCP("getFailureLogs", server.server.getClientVersion());
-            return await getFailureLogs(args);
+            trackMCP("getFailureLogs", server.server.getClientVersion(), undefined, config);
+            return await getFailureLogs(args, config);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            trackMCP("getFailureLogs", server.server.getClientVersion(), error);
+            trackMCP("getFailureLogs", server.server.getClientVersion(), error, config);
             logger.error("Failed to fetch logs: %s", message);
             return {
                 content: [

package/dist/tools/live-utils/desktop-filter.d.ts

@@ -0,0 +1,2 @@
+import { DesktopSearchArgs, DesktopEntry } from "./types.js";
+export declare function filterDesktop(args: DesktopSearchArgs): Promise<DesktopEntry>;

package/dist/tools/live-utils/mobile-filter.d.ts

@@ -0,0 +1,2 @@
+import { MobileSearchArgs, MobileEntry } from "./types.js";
+export declare function filterMobile(args: MobileSearchArgs): Promise<MobileEntry>;

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

@@ -0,0 +1,6 @@
+import { DesktopSearchArgs, MobileSearchArgs } from "./types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Entrypoint: detects platformType & delegates.
+ */
+export declare function startBrowserSession(args: DesktopSearchArgs | MobileSearchArgs, config: BrowserStackConfig): Promise<string>;

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

@@ -4,13 +4,18 @@ import { filterDesktop } from "./desktop-filter.js";
 import { filterMobile } from "./mobile-filter.js";
 import { PlatformType, } from "./types.js";
 import { isLocalURL, ensureLocalBinarySetup, killExistingBrowserStackLocalProcesses, } from "../../lib/local.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import envConfig from "../../config.js";
 /**
  * Prepares local tunnel setup based on URL type
  */
-async function prepareLocalTunnel(url) {
+async function prepareLocalTunnel(url, username, password) {
     const isLocal = isLocalURL(url);
+    if (isLocal && envConfig.REMOTE_MCP) {
+        throw new Error("Local URLs are not supported in this remote mcp. Please use a public URL.");
+    }
     if (isLocal) {
-        await ensureLocalBinarySetup();
+        await ensureLocalBinarySetup(username, password);
     }
     else {
         await killExistingBrowserStackLocalProcesses();
@@ -20,15 +25,23 @@ async function prepareLocalTunnel(url) {
 /**
  * Entrypoint: detects platformType & delegates.
  */
-export async function startBrowserSession(args) {
+export async function startBrowserSession(args, config) {
     const entry = args.platformType === PlatformType.DESKTOP
         ? await filterDesktop(args)
         : await filterMobile(args);
-    const isLocal = await prepareLocalTunnel(args.url);
+    // Get credentials from config
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
+    if (!username || !password) {
+        throw new Error("BrowserStack credentials are not set. Please configure them in the server settings.");
+    }
+    const isLocal = await prepareLocalTunnel(args.url, username, password);
     const url = args.platformType === PlatformType.DESKTOP
         ? buildDesktopUrl(args, entry, isLocal)
         : buildMobileUrl(args, entry, isLocal);
-    openBrowser(url);
+    if (!envConfig.REMOTE_MCP) {
+        openBrowser(url);
+    }
     return entry.notes ? `${url}, ${entry.notes}` : url;
 }
 function buildDesktopUrl(args, e, isLocal) {

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

@@ -0,0 +1,33 @@
+export interface DesktopSearchArgs {
+    platformType: "desktop";
+    url: string;
+    os: string;
+    osVersion: string;
+    browser: string;
+    browserVersion: string;
+}
+export interface DesktopEntry {
+    os: string;
+    os_version: string;
+    browser: string;
+    browser_version: string;
+    notes?: string;
+}
+export interface MobileSearchArgs {
+    platformType: "mobile";
+    url: string;
+    os: string;
+    osVersion: string;
+    device: string;
+    browser: string;
+}
+export interface MobileEntry {
+    os: string;
+    os_version: string;
+    display_name: string;
+    notes?: string;
+}
+export declare enum PlatformType {
+    DESKTOP = "desktop",
+    MOBILE = "mobile"
+}

package/dist/tools/live.d.ts

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

package/dist/tools/live.js

@@ -28,7 +28,7 @@ const LiveArgsSchema = z.object(LiveArgsShape);
 /**
  * Launches a desktop browser session
  */
-async function launchDesktopSession(args) {
+async function launchDesktopSession(args, config) {
     if (!args.desiredBrowser)
         throw new Error("You must provide a desiredBrowser");
     if (!args.desiredBrowserVersion)
@@ -40,12 +40,12 @@ async function launchDesktopSession(args) {
         osVersion: args.desiredOSVersion,
         browser: args.desiredBrowser,
         browserVersion: args.desiredBrowserVersion,
-    });
+    }, config);
 }
 /**
  * Launches a mobile browser session
  */
-async function launchMobileSession(args) {
+async function launchMobileSession(args, config) {
     if (!args.desiredDevice)
         throw new Error("You must provide a desiredDevice");
     return startBrowserSession({
@@ -55,18 +55,18 @@ async function launchMobileSession(args) {
         os: args.desiredOS,
         osVersion: args.desiredOSVersion,
         device: args.desiredDevice,
-    });
+    }, config);
 }
 /**
  * Handles the core logic for running a browser session
  */
-async function runBrowserSession(rawArgs) {
+async function runBrowserSession(rawArgs, config) {
     // Validate and narrow
     const args = LiveArgsSchema.parse(rawArgs);
     // Branch desktop vs mobile and delegate
     const launchUrl = args.platformType === PlatformType.DESKTOP
-        ? await launchDesktopSession(args)
-        : await launchMobileSession(args);
+        ? await launchDesktopSession(args, config)
+        : await launchMobileSession(args, config);
     return {
         content: [
             {
@@ -76,15 +76,15 @@ async function runBrowserSession(rawArgs) {
         ],
     };
 }
-export default function addBrowserLiveTools(server) {
+export default function addBrowserLiveTools(server, config) {
     server.tool("runBrowserLiveSession", "Launch a BrowserStack Live session (desktop or mobile).", LiveArgsShape, async (args) => {
         try {
-            trackMCP("runBrowserLiveSession", server.server.getClientVersion());
-            return await runBrowserSession(args);
+            trackMCP("runBrowserLiveSession", server.server.getClientVersion(), undefined, config);
+            return await runBrowserSession(args, config);
         }
         catch (error) {
             logger.error("Live session failed: %s", error);
-            trackMCP("runBrowserLiveSession", server.server.getClientVersion(), error);
+            trackMCP("runBrowserLiveSession", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {

package/dist/tools/observability.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function getFailuresInLastRun(buildName: string, projectName: string, config: BrowserStackConfig): Promise<CallToolResult>;
+export default function addObservabilityTools(server: McpServer, config: BrowserStackConfig): void;