@browserstack/mcp-server 1.1.9 → 1.2.1

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): Record<string, any>;
+export {};

package/dist/tools/getFailureLogs.js

@@ -1,11 +1,10 @@
 import { z } from "zod";
-import logger from "../logger.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import { retrieveNetworkFailures, retrieveSessionFailures, retrieveConsoleFailures, } from "./failurelogs-utils/automate.js";
 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 +52,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,8 +97,9 @@ export async function getFailureLogs(args) {
     return { content: results };
 }
 // Register tool with the MCP server
-export default function registerGetFailureLogs(server) {
-    server.tool("getFailureLogs", "Fetch various types of logs from a BrowserStack session. Supports both automate and app-automate sessions.", {
+export default function registerGetFailureLogs(server, config) {
+    const tools = {};
+    tools.getFailureLogs = 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])
             .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
@@ -122,18 +122,16 @@ 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);
-            logger.error("Failed to fetch logs: %s", message);
+            trackMCP("getFailureLogs", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to fetch logs: ${message}`,
+                        text: `Failed to fetch failure logs: ${error instanceof Error ? error.message : "Unknown error"}`,
                         isError: true,
                     },
                 ],
@@ -141,4 +139,5 @@ export default function registerGetFailureLogs(server) {
             };
         }
     });
+    return tools;
 }

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): Record<string, any>;

package/dist/tools/live.js

@@ -3,6 +3,7 @@ import logger from "../logger.js";
 import { startBrowserSession } from "./live-utils/start-session.js";
 import { PlatformType } from "./live-utils/types.js";
 import { trackMCP } from "../lib/instrumentation.js";
+import globalConfig from "../config.js";
 // Define the schema shape
 const LiveArgsShape = {
     platformType: z
@@ -28,7 +29,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 +41,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,36 +56,46 @@ 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);
-    return {
-        content: [
+        ? await launchDesktopSession(args, config)
+        : await launchMobileSession(args, config);
+    let response = [
+        {
+            type: "text",
+            text: `✅ Session started. If it didn't open automatically, visit:\n${launchUrl}`,
+        },
+    ];
+    if (globalConfig.REMOTE_MCP) {
+        response = [
             {
                 type: "text",
-                text: `✅ Session started. If it didn't open automatically, visit:\n${launchUrl}`,
+                text: `✅ To start the session. Click on ${launchUrl}`,
             },
-        ],
+        ];
+    }
+    return {
+        content: response,
     };
 }
-export default function addBrowserLiveTools(server) {
-    server.tool("runBrowserLiveSession", "Launch a BrowserStack Live session (desktop or mobile).", LiveArgsShape, async (args) => {
+export default function addBrowserLiveTools(server, config) {
+    const tools = {};
+    tools.runBrowserLiveSession = 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: [
                     {
@@ -97,4 +108,5 @@ export default function addBrowserLiveTools(server) {
             };
         }
     });
+    return tools;
 }

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;

package/dist/tools/observability.js

@@ -2,19 +2,22 @@ import { z } from "zod";
 import { getLatestO11YBuildInfo } from "../lib/api.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import logger from "../logger.js";
-export async function getFailuresInLastRun(buildName, projectName) {
-    const buildsData = await getLatestO11YBuildInfo(buildName, projectName);
-    const observabilityUrl = buildsData.observability_url;
+export async function getFailuresInLastRun(buildName, projectName, config) {
+    const buildsData = await getLatestO11YBuildInfo(buildName, projectName, config);
+    if (!buildsData.data) {
+        throw new Error("No observability URL found in build data, this is likely because the build is not yet available on BrowserStack Observability.");
+    }
+    const observabilityUrl = buildsData.data.observability_url;
     if (!observabilityUrl) {
         throw new Error("No observability URL found in build data, this is likely because the build is not yet available on BrowserStack Observability.");
     }
     let overview = "No overview available";
-    if (buildsData.unique_errors?.overview?.insight) {
-        overview = buildsData.unique_errors.overview.insight;
+    if (buildsData.data.unique_errors?.overview?.insight) {
+        overview = buildsData.data.unique_errors.overview.insight;
     }
     let details = "No error details available";
-    if (buildsData.unique_errors?.top_unique_errors?.length > 0) {
-        details = buildsData.unique_errors.top_unique_errors
+    if (buildsData.data.unique_errors?.top_unique_errors?.length > 0) {
+        details = buildsData.data.unique_errors.top_unique_errors
             .map((error) => error.error)
             .filter(Boolean)
             .join("\n");
@@ -28,7 +31,7 @@ export async function getFailuresInLastRun(buildName, projectName) {
         ],
     };
 }
-export default function addObservabilityTools(server) {
+export default function addObservabilityTools(server, config) {
     server.tool("getFailuresInLastRun", "Use this tool to debug failures in the last run of the test suite on BrowserStack. Use only when browserstack.yml file is present in the project root.", {
         buildName: z
             .string()
@@ -38,12 +41,12 @@ export default function addObservabilityTools(server) {
             .describe("Name of the project to get failures for. This is the 'projectName' key in the browserstack.yml file. If not sure, ask the user for the project name."),
     }, async (args) => {
         try {
-            trackMCP("getFailuresInLastRun", server.server.getClientVersion());
-            return await getFailuresInLastRun(args.buildName, args.projectName);
+            trackMCP("getFailuresInLastRun", server.server.getClientVersion(), undefined, config);
+            return await getFailuresInLastRun(args.buildName, args.projectName, config);
         }
         catch (error) {
             logger.error("Failed to get failures in the last run: %s", error);
-            trackMCP("getFailuresInLastRun", server.server.getClientVersion(), error);
+            trackMCP("getFailuresInLastRun", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {

package/dist/tools/sdk-utils/commands.d.ts

@@ -0,0 +1,3 @@
+import { SDKSupportedLanguage } from "./types.js";
+export declare function getSDKPrefixCommand(language: SDKSupportedLanguage, framework: string, username: string, accessKey: string): string;
+export declare function getJavaFrameworkForMaven(framework: string): string;

package/dist/tools/sdk-utils/commands.js

@@ -4,6 +4,7 @@ const JAVA_FRAMEWORK_MAP = {
     junit5: "junit5",
     junit4: "junit4",
     cucumber: "cucumber-testng",
+    serenity: "serenity",
 };
 // Common Gradle setup instructions (platform-independent)
 const GRADLE_SETUP_INSTRUCTIONS = `
@@ -17,7 +18,7 @@ const GRADLE_SETUP_INSTRUCTIONS = `
 3. Add javaagent to gradle tasks:
    jvmArgs "-javaagent:\${browserstackSDKArtifact.file}"
 `;
-export function getSDKPrefixCommand(language, framework) {
+export function getSDKPrefixCommand(language, framework, username, accessKey) {
     switch (language) {
         case "nodejs":
             return `---STEP---
@@ -28,7 +29,7 @@ npm i -D browserstack-node-sdk@latest
 ---STEP---
 Run the following command to setup browserstack sdk:
 \`\`\`bash
-npx setup --username ${process.env.BROWSERSTACK_USERNAME} --key ${process.env.BROWSERSTACK_ACCESS_KEY}
+npx setup --username ${username} --key ${accessKey}
 \`\`\`
 ---STEP---
 Edit the browserstack.yml file that was created in the project root to add your desired platforms and browsers.`;
@@ -40,8 +41,8 @@ Edit the browserstack.yml file that was created in the project root to add your
                 : `mvn archetype:generate -B -DarchetypeGroupId=com.browserstack \\
 -DarchetypeArtifactId=browserstack-sdk-archetype-integrate -DarchetypeVersion=1.0 \\
 -DgroupId=com.browserstack -DartifactId=browserstack-sdk-archetype-integrate -Dversion=1.0 \\
--DBROWSERSTACK_USERNAME="${process.env.BROWSERSTACK_USERNAME}" \\
--DBROWSERSTACK_ACCESS_KEY="${process.env.BROWSERSTACK_ACCESS_KEY}" \\
+-DBROWSERSTACK_USERNAME="${username}" \\
+-DBROWSERSTACK_ACCESS_KEY="${accessKey}" \\
 -DBROWSERSTACK_FRAMEWORK="${mavenFramework}"`;
             const platformLabel = isWindows ? "Windows" : "macOS/Linux";
             return `---STEP---

package/dist/tools/sdk-utils/constants.d.ts

@@ -0,0 +1,2 @@
+import { ConfigMapping } from "./types.js";
+export declare const SUPPORTED_CONFIGURATIONS: ConfigMapping;