@browserstack/mcp-server 1.1.9 → 1.2.0

package/dist/tools/accessiblity-utils/accessibility-rag.d.ts

@@ -0,0 +1,12 @@
+export interface RAGChunk {
+    url: string;
+    content: string;
+}
+import { BrowserStackConfig } from "../../lib/types.js";
+export interface AccessibilityRAGResponse {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+export declare function queryAccessibilityRAG(userQuery: string, config: BrowserStackConfig): Promise<any>;

package/dist/tools/accessiblity-utils/accessibility-rag.js

@@ -1,23 +1,27 @@
-import fetch from "node-fetch";
-import config from "../../config.js";
-export async function queryAccessibilityRAG(userQuery) {
+import { apiClient } from "../../lib/apiClient.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+export async function queryAccessibilityRAG(userQuery, config) {
     const url = "https://accessibility.browserstack.com/api/tcg-proxy/search";
-    const auth = Buffer.from(`${config.browserstackUsername}:${config.browserstackAccessKey}`).toString("base64");
-    const response = await fetch(url, {
-        method: "POST",
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.post({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
-        body: JSON.stringify({
+        body: {
             query: userQuery,
-        }),
+        },
+        raise_error: false,
     });
     if (!response.ok) {
-        const errorText = await response.text();
+        const errorText = typeof response.data === "string"
+            ? response.data
+            : JSON.stringify(response.data);
         throw new Error(`RAG endpoint error: ${response.status} ${errorText}`);
     }
-    const responseData = (await response.json());
+    const responseData = response.data;
     if (!responseData.success) {
         throw new Error("Something went wrong: " + responseData.message);
     }
@@ -26,8 +30,14 @@ export async function queryAccessibilityRAG(userQuery) {
     try {
         parsedData = JSON.parse(responseData.data);
     }
-    catch {
-        throw new Error("Failed to parse RAG response data as JSON");
+    catch (err) {
+        throw new Error("Failed to parse RAG response data as JSON: " +
+            (err instanceof Error ? err.message : String(err)));
+    }
+    if (!parsedData ||
+        !parsedData.data ||
+        !Array.isArray(parsedData.data.chunks)) {
+        throw new Error("RAG response data is missing expected 'data.chunks' array");
     }
     const chunks = parsedData.data.chunks;
     // Format the response properly

package/dist/tools/accessiblity-utils/report-fetcher.d.ts

@@ -0,0 +1,8 @@
+export declare class AccessibilityReportFetcher {
+    private auth;
+    setAuth(auth: {
+        username: string;
+        password: string;
+    }): void;
+    getReportLink(scanId: string, scanRunId: string): Promise<string>;
+}

package/dist/tools/accessiblity-utils/report-fetcher.js

@@ -1,28 +1,38 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 export class AccessibilityReportFetcher {
-    auth = {
-        username: config.browserstackUsername,
-        password: config.browserstackAccessKey,
-    };
+    auth;
+    setAuth(auth) {
+        this.auth = auth;
+    }
     async getReportLink(scanId, scanRunId) {
         // Initiate CSV link generation
         const initUrl = `https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/issues?scan_run_id=${scanRunId}`;
-        const initResp = await axios.get(initUrl, {
-            auth: this.auth,
+        let basicAuthHeader = undefined;
+        if (this.auth) {
+            const { username, password } = this.auth;
+            basicAuthHeader =
+                "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
+        }
+        const initResp = await apiClient.get({
+            url: initUrl,
+            headers: basicAuthHeader ? { Authorization: basicAuthHeader } : undefined,
         });
-        if (!initResp.data.success) {
-            throw new Error(`Failed to initiate report: ${initResp.data.error || initResp.data.data.message}`);
+        const initData = initResp.data;
+        if (!initData.success) {
+            throw new Error(`Failed to initiate report: ${initData.error || initData.data.message}`);
         }
-        const taskId = initResp.data.data.task_id;
+        const taskId = initData.data.task_id;
         // Fetch the generated CSV link
         const reportUrl = `https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/issues?task_id=${encodeURIComponent(taskId)}`;
-        const reportResp = await axios.get(reportUrl, {
-            auth: this.auth,
+        // Use apiClient for the report link request as well
+        const reportResp = await apiClient.get({
+            url: reportUrl,
+            headers: basicAuthHeader ? { Authorization: basicAuthHeader } : undefined,
         });
-        if (!reportResp.data.success) {
-            throw new Error(`Failed to fetch report: ${reportResp.data.error}`);
+        const reportData = reportResp.data;
+        if (!reportData.success) {
+            throw new Error(`Failed to fetch report: ${reportData.error}`);
         }
-        return reportResp.data.data.reportLink;
+        return reportData.data.reportLink;
     }
 }

package/dist/tools/accessiblity-utils/report-parser.d.ts

@@ -0,0 +1,23 @@
+type SimplifiedAccessibilityIssue = {
+    issue_type: string;
+    component: string;
+    issue_description: string;
+    HTML_snippet: string;
+    how_to_fix: string;
+    severity: string;
+};
+type PaginationOptions = {
+    /** How many JSON-chars max per “page” (default 10000) */
+    maxCharacterLength?: number;
+    /** Character offset to start from (default 0) */
+    nextPage?: number;
+};
+type PaginatedResult = {
+    records: SimplifiedAccessibilityIssue[];
+    /** Character offset for the next page, or null if done */
+    page_length: number;
+    total_issues: number;
+    next_page: number | null;
+};
+export declare function parseAccessibilityReportFromCSV(reportLink: string, { maxCharacterLength, nextPage }?: PaginationOptions): Promise<PaginatedResult>;
+export {};

package/dist/tools/accessiblity-utils/report-parser.js

@@ -1,11 +1,11 @@
-import fetch from "node-fetch";
+import { apiClient } from "../../lib/apiClient.js";
 import { parse } from "csv-parse/sync";
 export async function parseAccessibilityReportFromCSV(reportLink, { maxCharacterLength = 5000, nextPage = 0 } = {}) {
     // 1) Download & parse
-    const res = await fetch(reportLink);
+    const res = await apiClient.get({ url: reportLink });
     if (!res.ok)
         throw new Error(`Failed to download report: ${res.statusText}`);
-    const text = await res.text();
+    const text = typeof res.data === "string" ? res.data : JSON.stringify(res.data);
     const all = parse(text, {
         columns: true,
         skip_empty_lines: true,

package/dist/tools/accessiblity-utils/scanner.d.ts

@@ -0,0 +1,25 @@
+export interface AccessibilityScanResponse {
+    success: boolean;
+    data?: {
+        id: string;
+        scanRunId: string;
+    };
+    errors?: string[];
+}
+export interface AccessibilityScanStatus {
+    success: boolean;
+    data?: {
+        status: string;
+    };
+    errors?: string[];
+}
+export declare class AccessibilityScanner {
+    private auth;
+    setAuth(auth: {
+        username: string;
+        password: string;
+    }): void;
+    startScan(name: string, urlList: string[]): Promise<AccessibilityScanResponse>;
+    pollStatus(scanId: string, scanRunId: string): Promise<AccessibilityScanStatus>;
+    waitUntilComplete(scanId: string, scanRunId: string, context: any): Promise<string>;
+}

package/dist/tools/accessiblity-utils/scanner.js

@@ -1,23 +1,30 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
+import { randomUUID } from "node:crypto";
 import logger from "../../logger.js";
 import { isLocalURL, ensureLocalBinarySetup, killExistingBrowserStackLocalProcesses, } from "../../lib/local.js";
+import config from "../../config.js";
 export class AccessibilityScanner {
-    auth = {
-        username: config.browserstackUsername,
-        password: config.browserstackAccessKey,
-    };
+    auth;
+    setAuth(auth) {
+        this.auth = auth;
+    }
     async startScan(name, urlList) {
+        if (!this.auth?.username || !this.auth?.password) {
+            throw new Error("BrowserStack credentials are not set for AccessibilityScanner.");
+        }
         // Check if any URL is local
         const hasLocal = urlList.some(isLocalURL);
-        const localIdentifier = crypto.randomUUID();
+        const localIdentifier = randomUUID();
         const localHosts = new Set(["127.0.0.1", "localhost", "0.0.0.0"]);
         const BS_LOCAL_DOMAIN = "bs-local.com";
         if (config.USE_OWN_LOCAL_BINARY_PROCESS && hasLocal) {
             throw new Error("Cannot start scan with local URLs when using own BrowserStack Local binary process. Please set USE_OWN_LOCAL_BINARY_PROCESS to false.");
         }
+        if (config.REMOTE_MCP && hasLocal) {
+            throw new Error("Local URLs are not supported in this remote mcp. Please use a public URL.");
+        }
         if (hasLocal) {
-            await ensureLocalBinarySetup(localIdentifier);
+            await ensureLocalBinarySetup(this.auth.username, this.auth.password, localIdentifier);
         }
         else {
             await killExistingBrowserStackLocalProcesses();
@@ -52,37 +59,49 @@ export class AccessibilityScanner {
             requestBody = { ...baseRequestBody, ...localConfig };
         }
         try {
-            const { data } = await axios.post("https://api-accessibility.browserstack.com/api/website-scanner/v1/scans", requestBody, { auth: this.auth });
+            const response = await apiClient.post({
+                url: "https://api-accessibility.browserstack.com/api/website-scanner/v1/scans",
+                headers: {
+                    Authorization: "Basic " +
+                        Buffer.from(`${this.auth.username}:${this.auth.password}`).toString("base64"),
+                    "Content-Type": "application/json",
+                },
+                body: requestBody,
+            });
+            const data = response.data;
             if (!data.success)
                 throw new Error(`Unable to start scan: ${data.errors?.join(", ")}`);
             return data;
         }
         catch (err) {
-            if (axios.isAxiosError(err) && err.response?.data) {
-                if (err.response.status === 422) {
-                    throw new Error("A scan with this name already exists. please update the name and run again.");
-                }
-                const msg = err.response.data.error ||
-                    err.response.data.message ||
-                    err.message;
-                throw new Error(`Failed to start scan: ${msg}`);
+            // apiClient throws generic errors, try to extract message
+            if (err?.response?.status === 422) {
+                throw new Error("A scan with this name already exists. please update the name and run again.");
             }
-            throw err;
+            const msg = err?.response?.data?.error ||
+                err?.response?.data?.message ||
+                err?.message ||
+                String(err);
+            throw new Error(`Failed to start scan: ${msg}`);
         }
     }
     async pollStatus(scanId, scanRunId) {
         try {
-            const { data } = await axios.get(`https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/${scanRunId}/status`, { auth: this.auth });
+            const response = await apiClient.get({
+                url: `https://api-accessibility.browserstack.com/api/website-scanner/v1/scans/${scanId}/scan_runs/${scanRunId}/status`,
+                headers: {
+                    Authorization: "Basic " +
+                        Buffer.from(`${this.auth?.username}:${this.auth?.password}`).toString("base64"),
+                },
+            });
+            const data = response.data;
             if (!data.success)
                 throw new Error(`Failed to get status: ${data.errors?.join(", ")}`);
             return data;
         }
         catch (err) {
-            if (axios.isAxiosError(err) && err.response?.data) {
-                const msg = err.response.data.message || err.message;
-                throw new Error(`Failed to get scan status: ${msg}`);
-            }
-            throw err;
+            const msg = err?.response?.data?.message || err?.message || String(err);
+            throw new Error(`Failed to get scan status: ${msg}`);
         }
     }
     async waitUntilComplete(scanId, scanRunId, context) {

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

@@ -0,0 +1,42 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+interface Device {
+    device: string;
+    display_name: string;
+    os_version: string;
+    real_mobile: boolean;
+}
+/**
+ * Finds devices that exactly match the provided display name.
+ * Uses fuzzy search first, and then filters for exact case-insensitive match.
+ */
+export declare function findMatchingDevice(devices: Device[], deviceName: string): Device[];
+/**
+ * Extracts all unique OS versions from a device list and sorts them.
+ */
+export declare function getDeviceVersions(devices: Device[]): string[];
+/**
+ * Resolves the requested platform version against available versions.
+ * Supports 'latest' and 'oldest' as dynamic selectors.
+ */
+export declare function resolveVersion(versions: string[], requestedVersion: string): string;
+/**
+ * Validates the input arguments for taking app screenshots.
+ * Checks for presence and correctness of platform, device, and file types.
+ */
+export declare function validateArgs(args: {
+    desiredPlatform: string;
+    desiredPlatformVersion: string;
+    appPath: string;
+    desiredPhone: string;
+}): void;
+/**
+ * Uploads an application file to AppAutomate and returns the app URL
+ */
+export declare function uploadApp(appPath: string, username: string, password: string): Promise<string>;
+export declare function uploadEspressoApp(appPath: string, config: BrowserStackConfig): Promise<string>;
+export declare function uploadEspressoTestSuite(testSuitePath: string, config: BrowserStackConfig): Promise<string>;
+export declare function uploadXcuiApp(appPath: string, config: BrowserStackConfig): Promise<string>;
+export declare function uploadXcuiTestSuite(testSuitePath: string, config: BrowserStackConfig): Promise<string>;
+export declare function triggerEspressoBuild(app_url: string, test_suite_url: string, devices: string[], project: string): Promise<string>;
+export declare function triggerXcuiBuild(app_url: string, test_suite_url: string, devices: string[], project: string, config: BrowserStackConfig): Promise<string>;
+export {};

package/dist/tools/appautomate-utils/appautomate.js

@@ -1,12 +1,7 @@
 import fs from "fs";
-import axios from "axios";
-import config from "../../config.js";
 import FormData from "form-data";
+import { apiClient } from "../../lib/apiClient.js";
 import { customFuzzySearch } from "../../lib/fuzzy.js";
-const auth = {
-    username: config.browserstackUsername,
-    password: config.browserstackAccessKey,
-};
 /**
  * Finds devices that exactly match the provided display name.
  * Uses fuzzy search first, and then filters for exact case-insensitive match.
@@ -74,34 +69,44 @@ export function validateArgs(args) {
 /**
  * Uploads an application file to AppAutomate and returns the app URL
  */
-export async function uploadApp(appPath) {
+export async function uploadApp(appPath, username, password) {
     const filePath = appPath;
     if (!fs.existsSync(filePath)) {
         throw new Error(`File not found at path: ${filePath}`);
     }
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
-    const response = await axios.post("https://api-cloud.browserstack.com/app-automate/upload", formData, {
-        headers: formData.getHeaders(),
-        auth,
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/upload",
+        headers: {
+            ...formData.getHeaders(),
+            Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
+        },
+        body: formData,
     });
     if (response.data.app_url) {
         return response.data.app_url;
     }
     else {
-        throw new Error(`Failed to upload app: ${response.data}`);
+        throw new Error(`Failed to upload app: ${JSON.stringify(response.data)}`);
     }
 }
 // Helper to upload a file to a given BrowserStack endpoint and return a specific property from the response.
-async function uploadFileToBrowserStack(filePath, endpoint, responseKey) {
+async function uploadFileToBrowserStack(filePath, endpoint, responseKey, config) {
     if (!fs.existsSync(filePath)) {
         throw new Error(`File not found at path: ${filePath}`);
     }
     const formData = new FormData();
     formData.append("file", fs.createReadStream(filePath));
-    const response = await axios.post(endpoint, formData, {
-        headers: formData.getHeaders(),
-        auth,
+    const authHeader = "Basic " +
+        Buffer.from(`${config["browserstack-username"]}:${config["browserstack-access-key"]}`).toString("base64");
+    const response = await apiClient.post({
+        url: endpoint,
+        headers: {
+            ...formData.getHeaders(),
+            Authorization: authHeader,
+        },
+        body: formData,
     });
     if (response.data[responseKey]) {
         return response.data[responseKey];
@@ -109,30 +114,40 @@ async function uploadFileToBrowserStack(filePath, endpoint, responseKey) {
     throw new Error(`Failed to upload file: ${JSON.stringify(response.data)}`);
 }
 //Uploads an Android app (.apk or .aab) to BrowserStack Espresso endpoint and returns the app_url
-export async function uploadEspressoApp(appPath) {
-    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/app", "app_url");
+export async function uploadEspressoApp(appPath, config) {
+    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/app", "app_url", config);
 }
 //Uploads an Espresso test suite (.apk) to BrowserStack and returns the test_suite_url
-export async function uploadEspressoTestSuite(testSuitePath) {
-    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/test-suite", "test_suite_url");
+export async function uploadEspressoTestSuite(testSuitePath, config) {
+    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/espresso/v2/test-suite", "test_suite_url", config);
 }
 //Uploads an iOS app (.ipa) to BrowserStack XCUITest endpoint and returns the app_url
-export async function uploadXcuiApp(appPath) {
-    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/app", "app_url");
+export async function uploadXcuiApp(appPath, config) {
+    return uploadFileToBrowserStack(appPath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/app", "app_url", config);
 }
 //Uploads an XCUITest test suite (.zip) to BrowserStack and returns the test_suite_url
-export async function uploadXcuiTestSuite(testSuitePath) {
-    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/test-suite", "test_suite_url");
+export async function uploadXcuiTestSuite(testSuitePath, config) {
+    return uploadFileToBrowserStack(testSuitePath, "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/test-suite", "test_suite_url", config);
 }
 // Triggers an Espresso test run on BrowserStack and returns the build_id
 export async function triggerEspressoBuild(app_url, test_suite_url, devices, project) {
-    const response = await axios.post("https://api-cloud.browserstack.com/app-automate/espresso/v2/build", {
-        app: app_url,
-        testSuite: test_suite_url,
-        devices,
-        project,
-    }, {
-        auth,
+    const auth = {
+        username: process.env.BROWSERSTACK_USERNAME || "",
+        password: process.env.BROWSERSTACK_ACCESS_KEY || "",
+    };
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/espresso/v2/build",
+        headers: {
+            Authorization: "Basic " +
+                Buffer.from(`${auth.username}:${auth.password}`).toString("base64"),
+            "Content-Type": "application/json",
+        },
+        body: {
+            app: app_url,
+            testSuite: test_suite_url,
+            devices,
+            project,
+        },
     });
     if (response.data.build_id) {
         return response.data.build_id;
@@ -140,14 +155,24 @@ export async function triggerEspressoBuild(app_url, test_suite_url, devices, pro
     throw new Error(`Failed to trigger Espresso build: ${JSON.stringify(response.data)}`);
 }
 // Triggers an XCUITest run on BrowserStack and returns the build_id
-export async function triggerXcuiBuild(app_url, test_suite_url, devices, project) {
-    const response = await axios.post("https://api-cloud.browserstack.com/app-automate/xcuitest/v2/build", {
-        app: app_url,
-        testSuite: test_suite_url,
-        devices,
-        project,
-    }, {
-        auth,
+export async function triggerXcuiBuild(app_url, test_suite_url, devices, project, config) {
+    const auth = {
+        username: config["browserstack-username"],
+        password: config["browserstack-access-key"],
+    };
+    const response = await apiClient.post({
+        url: "https://api-cloud.browserstack.com/app-automate/xcuitest/v2/build",
+        headers: {
+            Authorization: "Basic " +
+                Buffer.from(`${auth.username}:${auth.password}`).toString("base64"),
+            "Content-Type": "application/json",
+        },
+        body: {
+            app: app_url,
+            testSuite: test_suite_url,
+            devices,
+            project,
+        },
     });
     if (response.data.build_id) {
         return response.data.build_id;

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

@@ -0,0 +1,5 @@
+export declare enum AppTestPlatform {
+    ESPRESSO = "espresso",
+    APPIUM = "appium",
+    XCUITEST = "xcuitest"
+}

package/dist/tools/appautomate.d.ts

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

package/dist/tools/appautomate.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import logger from "../logger.js";
-import config from "../config.js";
+import { getBrowserStackAuth } from "../lib/get-auth.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import { maybeCompressBase64 } from "../lib/utils.js";
 import { remote } from "webdriverio";
@@ -19,7 +19,7 @@ async function takeAppScreenshot(args) {
     let driver;
     try {
         validateArgs(args);
-        const { desiredPlatform, desiredPhone, appPath } = args;
+        const { desiredPlatform, desiredPhone, appPath, config } = args;
         let { desiredPlatformVersion } = args;
         const platforms = (await getDevicesAndBrowsers(BrowserStackProducts.APP_AUTOMATE)).mobile;
         const platformData = platforms.find((p) => p.os === desiredPlatform.toLowerCase());
@@ -33,7 +33,9 @@ async function takeAppScreenshot(args) {
         if (!selectedDevice) {
             throw new Error(`Device "${desiredPhone}" with version ${desiredPlatformVersion} not found.`);
         }
-        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. URL: ${app_url}`);
         const capabilities = {
             platformName: desiredPlatform,
@@ -42,8 +44,8 @@ async function takeAppScreenshot(args) {
             "appium:app": app_url,
             "appium:autoGrantPermissions": true,
             "bstack:options": {
-                userName: config.browserstackUsername,
-                accessKey: config.browserstackAccessKey,
+                userName: username,
+                accessKey: password,
                 appiumVersion: "2.0.1",
             },
         };
@@ -86,12 +88,12 @@ async function takeAppScreenshot(args) {
     }
 }
 //Runs AppAutomate tests on BrowserStack by uploading app and test suite, then triggering a test run.
-async function runAppTestsOnBrowserStack(args) {
+async function runAppTestsOnBrowserStack(args, config) {
     switch (args.detectedAutomationFramework) {
         case AppTestPlatform.ESPRESSO: {
             try {
-                const app_url = await uploadEspressoApp(args.appPath);
-                const test_suite_url = await uploadEspressoTestSuite(args.testSuitePath);
+                const app_url = await uploadEspressoApp(args.appPath, config);
+                const test_suite_url = await uploadEspressoTestSuite(args.testSuitePath, config);
                 const build_id = await triggerEspressoBuild(app_url, test_suite_url, args.devices, args.project);
                 return {
                     content: [
@@ -109,9 +111,9 @@ async function runAppTestsOnBrowserStack(args) {
         }
         case AppTestPlatform.XCUITEST: {
             try {
-                const app_url = await uploadXcuiApp(args.appPath);
-                const test_suite_url = await uploadXcuiTestSuite(args.testSuitePath);
-                const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project);
+                const app_url = await uploadXcuiApp(args.appPath, config);
+                const test_suite_url = await uploadXcuiTestSuite(args.testSuitePath, config);
+                const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project, config);
                 return {
                     content: [
                         {
@@ -130,8 +132,7 @@ async function runAppTestsOnBrowserStack(args) {
             throw new Error(`Unsupported automation framework: ${args.detectedAutomationFramework}. If you need support for this framework, please open an issue at Github`);
     }
 }
-// Registers automation tools with the MCP server.
-export default function addAppAutomationTools(server) {
+export default function addAppAutomationTools(server, config) {
     server.tool("takeAppScreenshot", "Use this tool to take a screenshot of an app running on a BrowserStack device. This is useful for visual testing and debugging.", {
         desiredPhone: z
             .string()
@@ -147,11 +148,11 @@ export default function addAppAutomationTools(server) {
             .describe("The path to the .apk or .ipa file. Required for app installation."),
     }, async (args) => {
         try {
-            trackMCP("takeAppScreenshot", server.server.getClientVersion());
-            return await takeAppScreenshot(args);
+            trackMCP("takeAppScreenshot", server.server.getClientVersion(), undefined, config);
+            return await takeAppScreenshot({ ...args, config });
         }
         catch (error) {
-            trackMCP("takeAppScreenshot", server.server.getClientVersion(), error);
+            trackMCP("takeAppScreenshot", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
@@ -197,11 +198,11 @@ export default function addAppAutomationTools(server) {
             .describe("The automation framework used in the project, such as 'espresso' (Android) or 'xcuitest' (iOS)."),
     }, async (args) => {
         try {
-            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion());
-            return await runAppTestsOnBrowserStack(args);
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), undefined, config);
+            return await runAppTestsOnBrowserStack(args, config);
         }
         catch (error) {
-            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), error);
+            trackMCP("runAppTestsOnBrowserStack", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [

package/dist/tools/applive-utils/device-search.d.ts

@@ -0,0 +1,6 @@
+import { DeviceEntry } from "./types.js";
+/**
+ * Find matching devices by name with exact match preference.
+ * Throws if none or multiple exact matches.
+ */
+export declare function findDeviceByName(devices: DeviceEntry[], desiredPhone: string): DeviceEntry[];

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

@@ -0,0 +1,15 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+interface StartSessionArgs {
+    appPath: string;
+    desiredPlatform: "android" | "ios";
+    desiredPhone: string;
+    desiredPlatformVersion: string;
+}
+interface StartSessionOptions {
+    config: BrowserStackConfig;
+}
+/**
+ * Start an App Live session: filter, select, upload, and open.
+ */
+export declare function startSession(args: StartSessionArgs, options: StartSessionOptions): Promise<string>;
+export {};