@browserstack/mcp-server 1.1.9 → 1.2.0

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;

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,7 +78,7 @@ function formatFinalInstructions(combinedInstructions) {
         ],
     };
 }
-export default function addSDKTools(server) {
+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)
@@ -95,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 {};