@browserstack/mcp-server 1.1.9 → 1.2.0

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * USE_OWN_LOCAL_BINARY_PROCESS:
+ *   If true, the system will not start a new local binary process, but will use the user's own process.
+ */
+export declare class Config {
+    readonly DEV_MODE: boolean;
+    readonly browserstackLocalOptions: Record<string, any>;
+    readonly USE_OWN_LOCAL_BINARY_PROCESS: boolean;
+    readonly REMOTE_MCP: boolean;
+    constructor(DEV_MODE: boolean, browserstackLocalOptions: Record<string, any>, USE_OWN_LOCAL_BINARY_PROCESS: boolean, REMOTE_MCP: boolean);
+}
+declare const config: Config;
+export default config;

package/dist/config.js

@@ -33,18 +33,16 @@ for (const key of BROWSERSTACK_LOCAL_OPTION_KEYS) {
  *   If true, the system will not start a new local binary process, but will use the user's own process.
  */
 export class Config {
-    browserstackUsername;
-    browserstackAccessKey;
     DEV_MODE;
     browserstackLocalOptions;
     USE_OWN_LOCAL_BINARY_PROCESS;
-    constructor(browserstackUsername, browserstackAccessKey, DEV_MODE, browserstackLocalOptions, USE_OWN_LOCAL_BINARY_PROCESS) {
-        this.browserstackUsername = browserstackUsername;
-        this.browserstackAccessKey = browserstackAccessKey;
+    REMOTE_MCP;
+    constructor(DEV_MODE, browserstackLocalOptions, USE_OWN_LOCAL_BINARY_PROCESS, REMOTE_MCP) {
         this.DEV_MODE = DEV_MODE;
         this.browserstackLocalOptions = browserstackLocalOptions;
         this.USE_OWN_LOCAL_BINARY_PROCESS = USE_OWN_LOCAL_BINARY_PROCESS;
+        this.REMOTE_MCP = REMOTE_MCP;
     }
 }
-const config = new Config(process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY, process.env.DEV_MODE === "true", browserstackLocalOptions, process.env.USE_OWN_LOCAL_BINARY_PROCESS === "true");
+const config = new Config(process.env.DEV_MODE === "true", browserstackLocalOptions, process.env.USE_OWN_LOCAL_BINARY_PROCESS === "true", process.env.REMOTE_MCP === "true");
 export default config;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import "dotenv/config";
+export { createMcpServer } from "./server-factory.js";
+export { setLogger } from "./logger.js";

package/dist/index.js

@@ -1,43 +1,31 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 import "dotenv/config";
 import logger from "./logger.js";
-import addSDKTools from "./tools/bstack-sdk.js";
-import addAppLiveTools from "./tools/applive.js";
-import addBrowserLiveTools from "./tools/live.js";
-import addAccessibilityTools from "./tools/accessibility.js";
-import addTestManagementTools from "./tools/testmanagement.js";
-import addAppAutomationTools from "./tools/appautomate.js";
-import addFailureLogsTools from "./tools/getFailureLogs.js";
-import addAutomateTools from "./tools/automate.js";
-import addSelfHealTools from "./tools/selfheal.js";
-import { setupOnInitialized } from "./oninitialized.js";
-function registerTools(server) {
-    addAccessibilityTools(server);
-    addSDKTools(server);
-    addAppLiveTools(server);
-    addBrowserLiveTools(server);
-    addTestManagementTools(server);
-    addAppAutomationTools(server);
-    addFailureLogsTools(server);
-    addAutomateTools(server);
-    addSelfHealTools(server);
-}
-// Create an MCP server
-const server = new McpServer({
-    name: "BrowserStack MCP Server",
-    version: packageJson.version,
-});
-setupOnInitialized(server);
-registerTools(server);
+import { createMcpServer } from "./server-factory.js";
 async function main() {
     logger.info("Launching BrowserStack MCP server, version %s", packageJson.version);
-    // Start receiving messages on stdin and sending messages on stdout
+    const remoteMCP = process.env.REMOTE_MCP === "true";
+    if (remoteMCP) {
+        logger.info("Running in remote MCP mode");
+        return;
+    }
+    const username = process.env.BROWSERSTACK_USERNAME;
+    const accessKey = process.env.BROWSERSTACK_ACCESS_KEY;
+    if (!username) {
+        throw new Error("BROWSERSTACK_USERNAME environment variable is required");
+    }
+    if (!accessKey) {
+        throw new Error("BROWSERSTACK_ACCESS_KEY environment variable is required");
+    }
     const transport = new StdioServerTransport();
+    const server = createMcpServer({
+        "browserstack-username": username,
+        "browserstack-access-key": accessKey,
+    });
     await server.connect(transport);
 }
 main().catch(console.error);
@@ -45,3 +33,5 @@ main().catch(console.error);
 process.on("exit", () => {
     logger.flush();
 });
+export { createMcpServer } from "./server-factory.js";
+export { setLogger } from "./logger.js";

package/dist/lib/api.d.ts

@@ -0,0 +1,2 @@
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function getLatestO11YBuildInfo(buildName: string, projectName: string, config: BrowserStackConfig): Promise<import("./apiClient.js").ApiResponse<any>>;

package/dist/lib/api.js

@@ -1,10 +1,15 @@
-import config from "../config.js";
-export async function getLatestO11YBuildInfo(buildName, projectName) {
+import { getBrowserStackAuth } from "./get-auth.js";
+import { apiClient } from "./apiClient.js";
+export async function getLatestO11YBuildInfo(buildName, projectName, config) {
     const buildsUrl = `https://api-observability.browserstack.com/ext/v1/builds/latest?build_name=${encodeURIComponent(buildName)}&project_name=${encodeURIComponent(projectName)}`;
-    const buildsResponse = await fetch(buildsUrl, {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const buildsResponse = await apiClient.get({
+        url: buildsUrl,
         headers: {
-            Authorization: `Basic ${Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64")}`,
+            Authorization: `Basic ${auth}`,
         },
+        raise_error: false,
     });
     if (!buildsResponse.ok) {
         if (buildsResponse.statusText === "Unauthorized") {
@@ -12,5 +17,5 @@ export async function getLatestO11YBuildInfo(buildName, projectName) {
         }
         throw new Error(`Failed to fetch builds: ${buildsResponse.statusText}`);
     }
-    return buildsResponse.json();
+    return buildsResponse;
 }

package/dist/lib/apiClient.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+type RequestOptions = {
+    url: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number>;
+    body?: any;
+    raise_error?: boolean;
+};
+declare class ApiResponse<T = any> {
+    private _response;
+    constructor(response: AxiosResponse<T>);
+    get data(): T;
+    get status(): number;
+    get statusText(): string;
+    get headers(): Record<string, string>;
+    get config(): AxiosRequestConfig;
+    get url(): string | undefined;
+    get ok(): boolean;
+}
+declare class ApiClient {
+    private instance;
+    private get axiosAgent();
+    private requestWrapper;
+    get<T = any>({ url, headers, params, raise_error, }: RequestOptions): Promise<ApiResponse<T>>;
+    post<T = any>({ url, headers, body, raise_error, }: RequestOptions): Promise<ApiResponse<T>>;
+    put<T = any>({ url, headers, body, raise_error, }: RequestOptions): Promise<ApiResponse<T>>;
+    patch<T = any>({ url, headers, body, raise_error, }: RequestOptions): Promise<ApiResponse<T>>;
+    delete<T = any>({ url, headers, params, raise_error, }: RequestOptions): Promise<ApiResponse<T>>;
+}
+export declare const apiClient: ApiClient;
+export type { ApiResponse, RequestOptions };

package/dist/lib/apiClient.js

@@ -0,0 +1,108 @@
+import axios from "axios";
+import httpsProxyAgentPkg from "https-proxy-agent";
+const { HttpsProxyAgent } = httpsProxyAgentPkg;
+import * as https from "https";
+import * as fs from "fs";
+import config from "../config.js";
+class ApiResponse {
+    _response;
+    constructor(response) {
+        this._response = response;
+    }
+    get data() {
+        return this._response.data;
+    }
+    get status() {
+        return this._response.status;
+    }
+    get statusText() {
+        return this._response.statusText;
+    }
+    get headers() {
+        const raw = this._response.headers;
+        const sanitized = {};
+        for (const key in raw) {
+            const value = raw[key];
+            if (typeof value === "string") {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    get config() {
+        return this._response.config;
+    }
+    get url() {
+        return this._response.config.url;
+    }
+    get ok() {
+        return this._response.status >= 200 && this._response.status < 300;
+    }
+}
+// Utility to create HTTPS agent if needed (proxy/CA)
+function getAxiosAgent() {
+    const proxyHost = config.browserstackLocalOptions.proxyHost;
+    const proxyPort = config.browserstackLocalOptions.proxyPort;
+    const caCertPath = config.browserstackLocalOptions.useCaCertificate;
+    // If both proxy host and port are defined
+    if (proxyHost && proxyPort) {
+        const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+        if (caCertPath && fs.existsSync(caCertPath)) {
+            // Proxy + CA cert
+            const ca = fs.readFileSync(caCertPath);
+            return new HttpsProxyAgent({
+                host: proxyHost,
+                port: Number(proxyPort),
+                ca,
+                rejectUnauthorized: false, // Set to true if you want strict SSL
+            });
+        }
+        else {
+            // Proxy only
+            return new HttpsProxyAgent(proxyUrl);
+        }
+    }
+    else if (caCertPath && fs.existsSync(caCertPath)) {
+        // CA only
+        return new https.Agent({
+            ca: fs.readFileSync(caCertPath),
+            rejectUnauthorized: false, // Set to true for strict SSL
+        });
+    }
+    // Default agent (no proxy, no CA)
+    return undefined;
+}
+class ApiClient {
+    instance = axios.create();
+    get axiosAgent() {
+        return getAxiosAgent();
+    }
+    async requestWrapper(fn, raise_error = true) {
+        try {
+            const res = await fn(this.axiosAgent);
+            return new ApiResponse(res);
+        }
+        catch (error) {
+            if (error.response && !raise_error) {
+                return new ApiResponse(error.response);
+            }
+            throw error;
+        }
+    }
+    async get({ url, headers, params, raise_error = true, }) {
+        return this.requestWrapper((agent) => this.instance.get(url, { headers, params, httpsAgent: agent }), raise_error);
+    }
+    async post({ url, headers, body, raise_error = true, }) {
+        return this.requestWrapper((agent) => this.instance.post(url, body, { headers, httpsAgent: agent }), raise_error);
+    }
+    async put({ url, headers, body, raise_error = true, }) {
+        return this.requestWrapper((agent) => this.instance.put(url, body, { headers, httpsAgent: agent }), raise_error);
+    }
+    async patch({ url, headers, body, raise_error = true, }) {
+        return this.requestWrapper((agent) => this.instance.patch(url, body, { headers, httpsAgent: agent }), raise_error);
+    }
+    async delete({ url, headers, params, raise_error = true, }) {
+        return this.requestWrapper((agent) => this.instance.delete(url, { headers, params, httpsAgent: agent }), raise_error);
+    }
+}
+export const apiClient = new ApiClient();

package/dist/lib/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const SessionType: {
+    readonly Automate: "automate";
+    readonly AppAutomate: "app-automate";
+};
+export declare const AutomateLogType: {
+    readonly NetworkLogs: "networkLogs";
+    readonly SessionLogs: "sessionLogs";
+    readonly ConsoleLogs: "consoleLogs";
+};
+export declare const AppAutomateLogType: {
+    readonly DeviceLogs: "deviceLogs";
+    readonly AppiumLogs: "appiumLogs";
+    readonly CrashLogs: "crashLogs";
+};
+export type SessionType = (typeof SessionType)[keyof typeof SessionType];
+export type AutomateLogType = (typeof AutomateLogType)[keyof typeof AutomateLogType];
+export type AppAutomateLogType = (typeof AppAutomateLogType)[keyof typeof AppAutomateLogType];

package/dist/lib/device-cache.d.ts

@@ -0,0 +1,9 @@
+export declare enum BrowserStackProducts {
+    LIVE = "live",
+    APP_LIVE = "app_live",
+    APP_AUTOMATE = "app_automate"
+}
+/**
+ * Fetches and caches BrowserStack datasets (live + app_live + app_automate) with a shared TTL.
+ */
+export declare function getDevicesAndBrowsers(type: BrowserStackProducts): Promise<any>;

package/dist/lib/device-cache.js

@@ -1,6 +1,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { apiClient } from "./apiClient.js";
 const CACHE_DIR = path.join(os.homedir(), ".browserstack", "combined_cache");
 const CACHE_FILE = path.join(CACHE_DIR, "data.json");
 const TTL_MS = 24 * 60 * 60 * 1000; // 1 day
@@ -38,13 +39,12 @@ export async function getDevicesAndBrowsers(type) {
             }
         }
     }
-    const liveRes = await fetch(URLS[type]);
+    const liveRes = await apiClient.get({ url: URLS[type], raise_error: false });
     if (!liveRes.ok) {
         throw new Error(`Failed to fetch configuration from BrowserStack : ${type}=${liveRes.statusText}`);
     }
-    const data = await liveRes.json();
     cache = {
-        [type]: data,
+        [type]: liveRes.data,
     };
     fs.writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf8");
     return cache[type];

package/dist/lib/error.d.ts

@@ -0,0 +1,7 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Formats an AxiosError into a CallToolResult with an appropriate message.
+ * @param err - The error object to format
+ * @param defaultText - The fallback error message
+ */
+export declare function formatAxiosError(err: unknown, defaultText: string): CallToolResult;

package/dist/lib/fuzzy.d.ts

@@ -0,0 +1 @@
+export declare function customFuzzySearch<T>(list: T[], keys: Array<keyof T | string>, query: string, limit?: number, maxDistance?: number): T[];

package/dist/lib/get-auth.d.ts

@@ -0,0 +1,2 @@
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function getBrowserStackAuth(config: BrowserStackConfig): string;

package/dist/lib/get-auth.js

@@ -0,0 +1,8 @@
+export function getBrowserStackAuth(config) {
+    const username = config["browserstack-username"];
+    const accessKey = config["browserstack-access-key"];
+    if (!username || !accessKey) {
+        throw new Error("BrowserStack credentials not set on server.authHeaders");
+    }
+    return `${username}:${accessKey}`;
+}

package/dist/lib/inmemory-store.d.ts

@@ -0,0 +1 @@
+export declare const signedUrlMap: Map<string, object>;

package/dist/lib/instrumentation.d.ts

@@ -0,0 +1,4 @@
+export declare function trackMCP(toolName: string, clientInfo: {
+    name?: string;
+    version?: string;
+}, error?: unknown, config?: any): void;

package/dist/lib/instrumentation.js

@@ -1,14 +1,10 @@
 import logger from "../logger.js";
-import config from "../config.js";
+import { getBrowserStackAuth } from "./get-auth.js";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const packageJson = require("../../package.json");
 import axios from "axios";
-export function trackMCP(toolName, clientInfo, error) {
-    if (config.DEV_MODE) {
-        logger.info("Tracking MCP is disabled in dev mode");
-        return;
-    }
+export function trackMCP(toolName, clientInfo, error, config) {
     const instrumentationEndpoint = "https://api.browserstack.com/sdk/v1/event";
     const isSuccess = !error;
     const mcpClient = clientInfo?.name || "unknown";
@@ -35,11 +31,16 @@ export function trackMCP(toolName, clientInfo, error) {
         event.event_properties.error_type =
             error instanceof Error ? error.constructor.name : "Unknown";
     }
+    let authHeader = undefined;
+    if (config) {
+        const authString = getBrowserStackAuth(config);
+        authHeader = `Basic ${Buffer.from(authString).toString("base64")}`;
+    }
     axios
         .post(instrumentationEndpoint, event, {
         headers: {
             "Content-Type": "application/json",
-            Authorization: `Basic ${Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64")}`,
+            ...(authHeader ? { Authorization: authHeader } : {}),
         },
         timeout: 2000,
     })

package/dist/lib/local.d.ts

@@ -0,0 +1,3 @@
+export declare function killExistingBrowserStackLocalProcesses(): Promise<void>;
+export declare function ensureLocalBinarySetup(username: string, password: string, localIdentifier?: string): Promise<void>;
+export declare function isLocalURL(url: string): boolean;

package/dist/lib/local.js

@@ -65,7 +65,7 @@ export async function killExistingBrowserStackLocalProcesses() {
         // Continue execution as there may not be any processes running
     }
 }
-export async function ensureLocalBinarySetup(localIdentifier) {
+export async function ensureLocalBinarySetup(username, password, localIdentifier) {
     logger.info("Ensuring local binary setup as it is required for private URLs...");
     if (config.USE_OWN_LOCAL_BINARY_PROCESS) {
         logger.info("Using user's own BrowserStack Local binary process, checking if it's running...");
@@ -81,8 +81,8 @@ export async function ensureLocalBinarySetup(localIdentifier) {
     // Use a single options object from config and extend with required fields
     const bsLocalArgs = {
         ...(config.browserstackLocalOptions || {}),
-        key: config.browserstackAccessKey,
-        username: config.browserstackUsername,
+        key: password,
+        username,
     };
     if (localIdentifier) {
         bsLocalArgs.localIdentifier = localIdentifier;

package/dist/lib/types.d.ts

@@ -0,0 +1,4 @@
+export type BrowserStackConfig = {
+    "browserstack-username": string;
+    "browserstack-access-key": string;
+};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ApiResponse } from "./apiClient.js";
+export declare function sanitizeUrlParam(param: string): string;
+export declare function maybeCompressBase64(base64: string): Promise<string>;
+export declare function assertOkResponse(response: Response | ApiResponse, action: string): Promise<void>;

package/dist/lib/version-resolver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * If req === "latest" or "oldest", returns max/min numeric (or lex)
+ * Else if exact match, returns that
+ * Else picks the numerically closest (or first)
+ */
+export declare function resolveVersion(requested: string, available: string[]): string;

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+declare const logger: any;
+export declare function setLogger(customLogger: any): void;
+export default logger;

package/dist/logger.js

@@ -1,7 +1,8 @@
 import { pino } from "pino";
-let logger;
+// 1. The actual logger instance, swapped out as needed
+let currentLogger;
 if (process.env.NODE_ENV === "development") {
-    logger = pino({
+    currentLogger = pino({
         level: "debug",
         transport: {
             targets: [
@@ -21,8 +22,8 @@ if (process.env.NODE_ENV === "development") {
     });
 }
 else {
-    // NULL logger
-    logger = pino({
+    // Null logger (logs go to /dev/null or NUL)
+    currentLogger = pino({
         level: "info",
         transport: {
             target: "pino/file",
@@ -32,4 +33,19 @@ else {
         },
     });
 }
+// 2. Proxy logger: always delegates to the currentLogger
+const logger = new Proxy({}, {
+    get(_target, prop) {
+        // Forward function calls to currentLogger
+        if (typeof currentLogger[prop] === "function") {
+            return (...args) => currentLogger[prop](...args);
+        }
+        // Forward property gets
+        return currentLogger[prop];
+    },
+});
+// 3. Setter to update the logger instance everywhere
+export function setLogger(customLogger) {
+    currentLogger = customLogger;
+}
 export default logger;

package/dist/oninitialized.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function setupOnInitialized(server: McpServer, config?: any): void;

package/dist/oninitialized.js

@@ -1,16 +1,11 @@
-import config from "./config.js";
 import { trackMCP } from "./lib/instrumentation.js";
-export function setupOnInitialized(server) {
+export function setupOnInitialized(server, config) {
     const nodeVersion = process.versions.node;
     // Check for Node.js version
     if (nodeVersion < "18.0.0") {
         throw new Error("Node version is not supported. Please upgrade to 18.0.0 or later.");
     }
-    // Check for BrowserStack credentials
-    if (!config.browserstackUsername || !config.browserstackAccessKey) {
-        throw new Error("BrowserStack credentials are missing. Please provide a valid username and access key.");
-    }
     server.server.oninitialized = () => {
-        trackMCP("started", server.server.getClientVersion());
+        trackMCP("started", server.server.getClientVersion(), undefined, config);
     };
 }

package/dist/server-factory.d.ts

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

package/dist/server-factory.js

@@ -0,0 +1,37 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+import logger from "./logger.js";
+import addSDKTools from "./tools/bstack-sdk.js";
+import addBrowserLiveTools from "./tools/live.js";
+import addAccessibilityTools from "./tools/accessibility.js";
+import addTestManagementTools from "./tools/testmanagement.js";
+import addAppAutomationTools from "./tools/appautomate.js";
+import addFailureLogsTools from "./tools/getFailureLogs.js";
+import addAutomateTools from "./tools/automate.js";
+import addSelfHealTools from "./tools/selfheal.js";
+import addAppLiveTools from "./tools/applive.js";
+import { setupOnInitialized } from "./oninitialized.js";
+function registerTools(server, config) {
+    addAccessibilityTools(server, config);
+    addSDKTools(server, config);
+    addAppLiveTools(server, config);
+    addBrowserLiveTools(server, config);
+    addTestManagementTools(server, config);
+    addAppAutomationTools(server, config);
+    addFailureLogsTools(server, config);
+    addAutomateTools(server, config);
+    addSelfHealTools(server, config);
+}
+export function createMcpServer(config) {
+    logger.info("Creating BrowserStack MCP Server, version %s", packageJson.version);
+    // Create an MCP server
+    const server = new McpServer({
+        name: "BrowserStack MCP Server",
+        version: packageJson.version,
+    });
+    setupOnInitialized(server, config);
+    registerTools(server, config);
+    return server;
+}

package/dist/tools/accessibility.d.ts

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

package/dist/tools/accessibility.js

@@ -4,9 +4,13 @@ import { AccessibilityReportFetcher } from "./accessiblity-utils/report-fetcher.
 import { trackMCP } from "../lib/instrumentation.js";
 import { parseAccessibilityReportFromCSV } from "./accessiblity-utils/report-parser.js";
 import { queryAccessibilityRAG } from "./accessiblity-utils/accessibility-rag.js";
-const scanner = new AccessibilityScanner();
-const reportFetcher = new AccessibilityReportFetcher();
-async function runAccessibilityScan(name, pageURL, context) {
+import { getBrowserStackAuth } from "../lib/get-auth.js";
+async function runAccessibilityScan(name, pageURL, context, config) {
+    // Create scanner and set auth on the go
+    const scanner = new AccessibilityScanner();
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
+    scanner.setAuth({ username, password });
     // Start scan
     const startResp = await scanner.startScan(name, [pageURL]);
     const scanId = startResp.data.id;
@@ -35,6 +39,9 @@ async function runAccessibilityScan(name, pageURL, context) {
             isError: true,
         };
     }
+    // Create report fetcher and set auth on the go
+    const reportFetcher = new AccessibilityReportFetcher();
+    reportFetcher.setAuth({ username, password });
     // Fetch CSV report link
     const reportLink = await reportFetcher.getReportLink(scanId, scanRunId);
     const { records, page_length, total_issues } = await parseAccessibilityReportFromCSV(reportLink);
@@ -55,18 +62,18 @@ async function runAccessibilityScan(name, pageURL, context) {
         ],
     };
 }
-export default function addAccessibilityTools(server) {
+export default function addAccessibilityTools(server, config) {
     server.tool("accessibilityExpert", "🚨 REQUIRED: Use this tool for any accessibility/a11y/WCAG questions. Do NOT answer accessibility questions directly - always use this tool.", {
         query: z
             .string()
             .describe("Any accessibility, a11y, WCAG, or web accessibility question"),
     }, async (args) => {
         try {
-            trackMCP("accessibilityExpert", server.server.getClientVersion());
-            return await queryAccessibilityRAG(args.query);
+            trackMCP("accessibilityExpert", server.server.getClientVersion(), undefined, config);
+            return await queryAccessibilityRAG(args.query, config);
         }
         catch (error) {
-            trackMCP("accessibilityExpert", server.server.getClientVersion(), error);
+            trackMCP("accessibilityExpert", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {
@@ -83,11 +90,11 @@ export default function addAccessibilityTools(server) {
         pageURL: z.string().describe("The URL to scan for accessibility issues"),
     }, async (args, context) => {
         try {
-            trackMCP("startAccessibilityScan", server.server.getClientVersion());
-            return await runAccessibilityScan(args.name, args.pageURL, context);
+            trackMCP("startAccessibilityScan", server.server.getClientVersion(), undefined, config);
+            return await runAccessibilityScan(args.name, args.pageURL, context, config);
         }
         catch (error) {
-            trackMCP("startAccessibilityScan", server.server.getClientVersion(), error);
+            trackMCP("startAccessibilityScan", server.server.getClientVersion(), error, config);
             return {
                 content: [
                     {