@browserstack/mcp-server 2.2.2 → 2.2.3

package/dist/lib/error.d.ts

@@ -1,4 +1,14 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Returns the most specific human-readable text for an error raised by an
+ * API call, capped at 500 characters. For an AxiosError with a response body
+ * it prefers the body's `message`, `error` or `errors` field, serialising
+ * objects, and uses the whole body when none of those fields exist. An empty,
+ * whitespace-only or HTML-document body falls back to the error's own message.
+ * @param err - The error object to describe
+ * @param defaultText - The fallback error message
+ */
+export declare function errorText(err: unknown, defaultText: string): string;
 /**
  * Formats an AxiosError into a CallToolResult with an appropriate message.
  * @param err - The error object to format

package/dist/lib/error.js

@@ -1,23 +1,75 @@
 import { AxiosError } from "axios";
+const MAX_ERROR_TEXT = 500;
+const BODY_FIELDS = ["message", "error", "errors"];
+function clip(text) {
+    return text.length > MAX_ERROR_TEXT ? text.slice(0, MAX_ERROR_TEXT) : text;
+}
+const HTML_DOCUMENT = /^\s*<(!doctype|html)\b/i;
+function stringify(value) {
+    if (typeof value === "string") {
+        return HTML_DOCUMENT.test(value) ? "" : value.trim();
+    }
+    if (value === undefined || value === null)
+        return "";
+    try {
+        const json = JSON.stringify(value);
+        return json === "{}" || json === "[]" ? "" : (json ?? "");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Text taken from an API error body: the first non-empty `message`, `error`
+ * or `errors` field when any of them is present, otherwise the whole body.
+ * Returns undefined when the body carries no usable text.
+ */
+function bodyText(data) {
+    if (typeof data !== "object" || data === null) {
+        const text = stringify(data);
+        return text ? clip(text) : undefined;
+    }
+    const record = data;
+    const named = BODY_FIELDS.filter((key) => key in record);
+    if (named.length > 0) {
+        for (const key of named) {
+            const text = stringify(record[key]);
+            if (text)
+                return clip(text);
+        }
+        return undefined;
+    }
+    const text = stringify(record);
+    return text ? clip(text) : undefined;
+}
+/**
+ * Returns the most specific human-readable text for an error raised by an
+ * API call, capped at 500 characters. For an AxiosError with a response body
+ * it prefers the body's `message`, `error` or `errors` field, serialising
+ * objects, and uses the whole body when none of those fields exist. An empty,
+ * whitespace-only or HTML-document body falls back to the error's own message.
+ * @param err - The error object to describe
+ * @param defaultText - The fallback error message
+ */
+export function errorText(err, defaultText) {
+    if (err instanceof AxiosError) {
+        const text = bodyText(err.response?.data);
+        if (text)
+            return text;
+        return clip(err.message || defaultText);
+    }
+    if (err instanceof Error)
+        return clip(err.message || defaultText);
+    return defaultText;
+}
 /**
  * Formats an AxiosError into a CallToolResult with an appropriate message.
  * @param err - The error object to format
  * @param defaultText - The fallback error message
  */
 export function formatAxiosError(err, defaultText) {
-    let text = defaultText;
-    if (err instanceof AxiosError && err.response?.data) {
-        const message = err.response.data.message ||
-            err.response.data.error ||
-            err.message ||
-            defaultText;
-        text = message;
-    }
-    else if (err instanceof Error) {
-        text = err.message;
-    }
     return {
-        content: [{ type: "text", text }],
+        content: [{ type: "text", text: errorText(err, defaultText) }],
         isError: true,
     };
 }

package/dist/lib/utils.js

@@ -7,6 +7,9 @@ export function sanitizeUrlParam(param) {
     return param.replace(/[;&|`$(){}[\]<>]/g, "");
 }
 const ONE_MB = 1048576;
+// sharp's default (~268M px) lets one image decode to ~1 GB of RGBA; 25M px caps it near 100 MB.
+const MAX_INPUT_PIXELS = 25_000_000;
+const MAX_IMAGE_DIMENSION = 1920;
 let sharpConfigured = false;
 //Compresses a base64 image intelligently to keep it under 1 MB if needed.
 export async function maybeCompressBase64(base64) {
@@ -25,11 +28,19 @@ export async function maybeCompressBase64(base64) {
             sharp.concurrency(1);
             sharpConfigured = true;
         }
-        const compressedBuffer = await sharp(buffer).png({ quality }).toBuffer();
+        const image = globalConfig.REMOTE_MCP
+            ? sharp(buffer, { limitInputPixels: MAX_INPUT_PIXELS }).resize({
+                width: MAX_IMAGE_DIMENSION,
+                height: MAX_IMAGE_DIMENSION,
+                fit: "inside",
+                withoutEnlargement: true,
+            })
+            : sharp(buffer);
+        const compressedBuffer = await image.png({ quality }).toBuffer();
         return compressedBuffer.toString("base64");
     }
     catch (err) {
-        logger.warn("Image compression unavailable (sharp failed to load); returning the uncompressed image. %s", err instanceof Error ? err.message : String(err));
+        logger.warn("Image compression failed; returning the uncompressed image. %s", err instanceof Error ? err.message : String(err));
         return base64;
     }
 }

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

@@ -1,6 +1,10 @@
 import { SessionType } from "../../lib/constants.js";
 import { BrowserStackConfig } from "../../lib/types.js";
-export declare function fetchAutomationScreenshots(sessionId: string, sessionType: SessionType | undefined, config: BrowserStackConfig): Promise<{
+export declare const MAX_SCREENSHOT_BYTES: number | undefined;
+export declare function parseScreenshotUrls(text: string): string[];
+export type Screenshot = {
     url: string;
     base64: string;
-}[]>;
+    mimeType: string;
+};
+export declare function fetchAutomationScreenshots(sessionId: string, sessionType: SessionType | undefined, config: BrowserStackConfig): Promise<Screenshot[]>;

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

@@ -3,6 +3,10 @@ import { SessionType } from "../../lib/constants.js";
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { apiClient } from "../../lib/apiClient.js";
 import globalConfig from "../../config.js";
+import { MAX_LOG_BYTES } from "../failurelogs-utils/utils.js";
+export const MAX_SCREENSHOT_BYTES = globalConfig.REMOTE_MCP
+    ? 10 * 1024 * 1024
+    : undefined;
 async function extractScreenshotUrls(sessionId, sessionType, config) {
     const authString = getBrowserStackAuth(config);
     const auth = Buffer.from(authString).toString("base64");
@@ -14,47 +18,112 @@ async function extractScreenshotUrls(sessionId, sessionType, config) {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
+        maxContentLength: MAX_LOG_BYTES,
         raise_error: false,
     });
+    if (response.status === 413) {
+        throw new Error("The logs for this session are too large (over 5 MB) to find screenshots here. Open the session in the BrowserStack dashboard to view them.");
+    }
     await assertOkResponse(response, "Session");
     const text = typeof response.data === "string"
         ? response.data
         : JSON.stringify(response.data);
+    return parseScreenshotUrls(text);
+}
+const LOG_PREFIX = String.raw `^\d{4}-\d{2}-\d{2} \d{1,2}:\d{1,2}:\d{1,2}:\d{1,3} `;
+const LINE_TYPE_PATTERN = new RegExp(`${LOG_PREFIX}([A-Z_]+) `);
+const SCREENSHOT_REQUEST_PATTERN = new RegExp(String.raw `${LOG_PREFIX}REQUEST \[[^\]]+\] GET /session/[^/\s]+/screenshot(\s|$)`);
+const RESPONSE_VALUE_PATTERN = new RegExp(String.raw `${LOG_PREFIX}RESPONSE \{"value"\s*:\s*"(https://[^"]+)"`);
+const DEBUG_SCREENSHOT_PATTERN = new RegExp(String.raw `${LOG_PREFIX}DEBUG (https://\S+)$`);
+const TRUSTED_HOST_PATTERN = /(^|\.)browserstack\.com$|\.s3([.-][a-z0-9-]+)*\.amazonaws\.com$|\.backblazeb2\.com$/;
+function isTrustedScreenshotUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && TRUSTED_HOST_PATTERN.test(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function parseScreenshotUrls(text) {
     const urls = [];
-    const SCREENSHOT_PATTERN = /REQUEST.*GET.*\/screenshot/;
-    const RESPONSE_VALUE_PATTERN = /"value"\s*:\s*"([^"]+)"/;
-    // Split logs into lines and process them
-    const lines = text.split("\n");
-    for (let i = 0; i < lines.length - 1; i++) {
-        const currentLine = lines[i];
-        const nextLine = lines[i + 1];
-        if (SCREENSHOT_PATTERN.test(currentLine)) {
-            const match = nextLine.match(RESPONSE_VALUE_PATTERN);
-            if (match && match[1]) {
-                urls.push(match[1]);
+    const lines = text.split("\n").map((line) => line.trimEnd());
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const debugMatch = line.match(DEBUG_SCREENSHOT_PATTERN);
+        if (debugMatch) {
+            urls.push(debugMatch[1]);
+            continue;
+        }
+        if (!SCREENSHOT_REQUEST_PATTERN.test(line)) {
+            continue;
+        }
+        for (let j = i + 1; j < lines.length; j++) {
+            const lineType = lines[j].match(LINE_TYPE_PATTERN)?.[1];
+            if (lineType === "REQUEST") {
+                break;
+            }
+            if (lineType === "RESPONSE") {
+                const valueMatch = lines[j].match(RESPONSE_VALUE_PATTERN);
+                if (valueMatch) {
+                    urls.push(valueMatch[1]);
+                }
+                break;
             }
         }
     }
-    return urls;
+    return [...new Set(urls)].filter(isTrustedScreenshotUrl);
+}
+function detectImageMimeType(buffer) {
+    if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    return "image/png";
 }
+// Returns null for a screenshot over MAX_SCREENSHOT_BYTES so the rest still load.
 async function fetchAndCompress(url) {
-    const response = await apiClient.get({ url, responseType: "arraybuffer" });
+    const response = await apiClient.get({
+        url,
+        responseType: "arraybuffer",
+        maxContentLength: MAX_SCREENSHOT_BYTES,
+        raise_error: false,
+    });
+    if (response.status === 413) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to download screenshot: ${response.status} ${response.statusText}`);
+    }
     // Axios returns response.data as a Buffer for binary data
-    const base64 = Buffer.from(response.data).toString("base64");
-    return { url, base64: await maybeCompressBase64(base64) };
+    const buffer = Buffer.from(response.data);
+    const base64 = await maybeCompressBase64(buffer.toString("base64"));
+    // Detect AFTER compression: sharp re-encodes anything over 1 MB to PNG, so
+    // reading the original bytes would label a large JPEG with the wrong type.
+    return {
+        url,
+        base64,
+        mimeType: detectImageMimeType(Buffer.from(base64, "base64")),
+    };
 }
 //Converts screenshot URLs to base64 encoded images
 async function convertUrlsToBase64(urls) {
+    let results;
     // Hosted pods are memory-constrained: process one image at a time. Local runs
     // keep the concurrent path.
     if (globalConfig.REMOTE_MCP) {
-        const screenshots = [];
+        results = [];
         for (const url of urls) {
-            screenshots.push(await fetchAndCompress(url));
+            results.push(await fetchAndCompress(url));
         }
-        return screenshots;
     }
-    return Promise.all(urls.map(fetchAndCompress));
+    else {
+        results = await Promise.all(urls.map(fetchAndCompress));
+    }
+    const screenshots = results.filter((s) => s !== null);
+    if (urls.length > 0 && screenshots.length === 0) {
+        throw new Error("The screenshots in this session are too large (over 10 MB each) to fetch here. Open the session in the BrowserStack dashboard to view them.");
+    }
+    return screenshots;
 }
 //Fetches and converts screenshot URLs to base64 encoded images
 export async function fetchAutomationScreenshots(sessionId, sessionType = SessionType.Automate, config) {

package/dist/tools/automate.js

@@ -14,7 +14,7 @@ export async function fetchAutomationScreenshotsTool(args, config) {
                 content: [
                     {
                         type: "text",
-                        text: "No screenshots found in the session or some unexpected error occurred",
+                        text: "No screenshots found in the session logs. Run with browserstack.debug: true to capture visual-log screenshots.",
                     },
                 ],
                 isError: true,
@@ -23,7 +23,7 @@ export async function fetchAutomationScreenshotsTool(args, config) {
         const results = screenshots.map((screenshot, index) => ({
             type: "image",
             data: screenshot.base64,
-            mimeType: "image/png",
+            mimeType: screenshot.mimeType,
             _meta: { url: screenshot.url, index: index + 1 },
         }));
         return {

package/dist/tools/testmanagement-utils/update-testcase.js

@@ -1,6 +1,6 @@
 import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js";
+import { errorText } from "../../lib/error.js";
 import { fetchFormFields, normalizeDefaultFields as normalizeDefaultFieldsFromForm, projectIdentifierToId, } from "./TCG-utils/api.js";
 import { getTMBaseURL } from "../../lib/tm-base-url.js";
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
@@ -218,12 +218,14 @@ Error details: ${JSON.stringify(err.response?.data || err.message)}`,
                 isError: true,
             };
         }
-        const errorMessage = formatAxiosError(err, "Failed to update test case");
+        const status = err.response?.status;
+        const detail = errorText(err, "unknown error");
+        const hint = status === 401 ? " Check the BrowserStack credentials in use." : "";
         return {
             content: [
                 {
                     type: "text",
-                    text: `Failed to update test case: ${errorMessage}. Please verify your credentials and try again.`,
+                    text: `Failed to update test case${status ? ` (HTTP ${status})` : ""}: ${detail}.${hint}`,
                 },
             ],
             isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "BrowserStack's Official MCP Server",
   "mcpName": "io.github.browserstack/mcp-server",
   "main": "dist/index.js",