@browserstack/mcp-server 1.1.4 → 1.1.6

package/dist/index.js

@@ -14,6 +14,7 @@ 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) {
     addSDKTools(server);
@@ -24,6 +25,7 @@ function registerTools(server) {
     addAppAutomationTools(server);
     addFailureLogsTools(server);
     addAutomateTools(server);
+    addSelfHealTools(server);
 }
 // Create an MCP server
 const server = new McpServer({

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

@@ -1,6 +1,6 @@
 import fetch from "node-fetch";
 import { parse } from "csv-parse/sync";
-export async function parseAccessibilityReportFromCSV(reportLink, { maxCharacterLength = 10_000, nextPage = 0 } = {}) {
+export async function parseAccessibilityReportFromCSV(reportLink, { maxCharacterLength = 5000, nextPage = 0 } = {}) {
     // 1) Download & parse
     const res = await fetch(reportLink);
     if (!res.ok)

package/dist/tools/applive-utils/device-search.js

@@ -0,0 +1,22 @@
+import { customFuzzySearch } from "../../lib/fuzzy.js";
+/**
+ * Find matching devices by name with exact match preference.
+ * Throws if none or multiple exact matches.
+ */
+export function findDeviceByName(devices, desiredPhone) {
+    const matches = customFuzzySearch(devices, ["display_name"], desiredPhone, 5);
+    if (matches.length === 0) {
+        const options = [...new Set(devices.map((d) => d.display_name))].join(", ");
+        throw new Error(`No devices matching "${desiredPhone}". Available devices: ${options}`);
+    }
+    // Exact-case-insensitive filter
+    const exact = matches.filter((m) => m.display_name.toLowerCase() === desiredPhone.toLowerCase());
+    if (exact.length)
+        return exact;
+    // If no exact but multiple fuzzy, ask user
+    if (matches.length > 1) {
+        const names = matches.map((d) => d.display_name).join(", ");
+        throw new Error(`Alternative Device/Device's found : ${names}. Please Select one.`);
+    }
+    return matches;
+}

package/dist/tools/applive-utils/start-session.js

@@ -1,129 +1,56 @@
-import childProcess from "child_process";
 import logger from "../../logger.js";
-import { BrowserStackProducts, getDevicesAndBrowsers, } from "../../lib/device-cache.js";
-import { fuzzySearchDevices } from "./fuzzy-search.js";
+import childProcess from "child_process";
+import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
 import { sanitizeUrlParam } from "../../lib/utils.js";
 import { uploadApp } from "./upload-app.js";
+import { findDeviceByName } from "./device-search.js";
+import { pickVersion } from "./version-utils.js";
 /**
- * Starts an App Live session after filtering, fuzzy matching, and launching.
- * @param args - The arguments for starting the session.
- * @returns The launch URL for the session.
- * @throws Will throw an error if no devices are found or if the app URL is invalid.
+ * Start an App Live session: filter, select, upload, and open.
  */
 export async function startSession(args) {
-    const { appPath, desiredPlatform, desiredPhone } = args;
-    let { desiredPlatformVersion } = args;
+    const { appPath, desiredPlatform, desiredPhone, desiredPlatformVersion } = args;
+    // 1) Fetch devices for APP_LIVE
     const data = await getDevicesAndBrowsers(BrowserStackProducts.APP_LIVE);
-    const allDevices = data.mobile.flatMap((group) => group.devices.map((dev) => ({ ...dev, os: group.os })));
-    desiredPlatformVersion = resolvePlatformVersion(allDevices, desiredPlatform, desiredPlatformVersion);
-    const filteredDevices = filterDevicesByPlatformAndVersion(allDevices, desiredPlatform, desiredPlatformVersion);
-    const matches = await fuzzySearchDevices(filteredDevices, desiredPhone);
-    const selectedDevice = validateAndSelectDevice(matches, desiredPhone, desiredPlatform, desiredPlatformVersion);
-    const { app_url } = await uploadApp(appPath);
-    validateAppUrl(app_url);
-    const launchUrl = constructLaunchUrl(app_url, selectedDevice, desiredPlatform, desiredPlatformVersion);
-    openBrowser(launchUrl);
-    return launchUrl;
-}
-/**
- * Resolves the platform version based on the desired platform and version.
- * @param allDevices - The list of all devices.
- * @param desiredPlatform - The desired platform (android or ios).
- * @param desiredPlatformVersion - The desired platform version.
- * @returns The resolved platform version.
- * @throws Will throw an error if the platform version is not valid.
- */
-function resolvePlatformVersion(allDevices, desiredPlatform, desiredPlatformVersion) {
-    if (desiredPlatformVersion === "latest" ||
-        desiredPlatformVersion === "oldest") {
-        const filtered = allDevices.filter((d) => d.os === desiredPlatform);
-        filtered.sort((a, b) => {
-            const versionA = parseFloat(a.os_version);
-            const versionB = parseFloat(b.os_version);
-            return desiredPlatformVersion === "latest"
-                ? versionB - versionA
-                : versionA - versionB;
-        });
-        return filtered[0].os_version;
+    const all = data.mobile.flatMap((grp) => grp.devices.map((dev) => ({ ...dev, os: grp.os })));
+    // 2) Filter by OS
+    const osMatches = all.filter((d) => d.os === desiredPlatform);
+    if (!osMatches.length) {
+        throw new Error(`No devices for OS "${desiredPlatform}"`);
     }
-    return desiredPlatformVersion;
-}
-/**
- * Filters devices based on the desired platform and version.
- * @param allDevices - The list of all devices.
- * @param desiredPlatform - The desired platform (android or ios).
- * @param desiredPlatformVersion - The desired platform version.
- * @returns The filtered list of devices.
- * @throws Will throw an error if the platform version is not valid.
- */
-function filterDevicesByPlatformAndVersion(allDevices, desiredPlatform, desiredPlatformVersion) {
-    return allDevices.filter((d) => {
-        if (d.os !== desiredPlatform)
-            return false;
-        try {
-            const versionA = parseFloat(d.os_version);
-            const versionB = parseFloat(desiredPlatformVersion);
-            return versionA === versionB;
-        }
-        catch {
-            return d.os_version === desiredPlatformVersion;
-        }
-    });
-}
-/**
- * Validates the selected device and handles multiple matches.
- * @param matches - The list of device matches.
- * @param desiredPhone - The desired phone name.
- * @param desiredPlatform - The desired platform (android or ios).
- * @param desiredPlatformVersion - The desired platform version.
- * @returns The selected device entry.
- */
-function validateAndSelectDevice(matches, desiredPhone, desiredPlatform, desiredPlatformVersion) {
-    if (matches.length === 0) {
-        throw new Error(`No devices found matching "${desiredPhone}" for ${desiredPlatform} ${desiredPlatformVersion}`);
-    }
-    const exactMatch = matches.find((d) => d.display_name.toLowerCase() === desiredPhone.toLowerCase());
-    if (exactMatch) {
-        return exactMatch;
+    // 3) Select by name
+    const nameMatches = findDeviceByName(osMatches, desiredPhone);
+    // 4) Resolve version
+    const versions = [...new Set(nameMatches.map((d) => d.os_version))];
+    const version = pickVersion(versions, desiredPlatformVersion);
+    // 5) Final candidates for version
+    const final = nameMatches.filter((d) => d.os_version === version);
+    if (!final.length) {
+        throw new Error(`No devices for version "${version}" on ${desiredPlatform}`);
     }
-    else if (matches.length >= 1) {
-        const names = matches.map((d) => d.display_name).join(", ");
-        const error_message = matches.length === 1
-            ? `Alternative device found: ${names}. Would you like to use it?`
-            : `Multiple devices found: ${names}. Please select one.`;
-        throw new Error(`${error_message}`);
-    }
-    return matches[0];
-}
-/**
- * Validates the app URL.
- * @param appUrl - The app URL to validate.
- * @throws Will throw an error if the app URL is not valid.
- */
-function validateAppUrl(appUrl) {
-    if (!appUrl.match("bs://")) {
-        throw new Error("The app path is not a valid BrowserStack app URL.");
+    const selected = final[0];
+    let note = "";
+    if (version != desiredPlatformVersion &&
+        desiredPlatformVersion !== "latest" &&
+        desiredPlatformVersion !== "oldest") {
+        note = `\n Note: The requested version "${desiredPlatformVersion}" is not available. Using "${version}" instead.`;
     }
-}
-/**
- * Constructs the launch URL for the App Live session.
- * @param appUrl - The app URL.
- * @param device - The selected device entry.
- * @param desiredPlatform - The desired platform (android or ios).
- * @param desiredPlatformVersion - The desired platform version.
- * @returns The constructed launch URL.
- */
-function constructLaunchUrl(appUrl, device, desiredPlatform, desiredPlatformVersion) {
-    const deviceParam = sanitizeUrlParam(device.display_name.replace(/\s+/g, "+"));
+    // 6) Upload app
+    const { app_url } = await uploadApp(appPath);
+    logger.info(`App uploaded: ${app_url}`);
+    // 7) Build URL & open
+    const deviceParam = sanitizeUrlParam(selected.display_name.replace(/\s+/g, "+"));
     const params = new URLSearchParams({
         os: desiredPlatform,
-        os_version: desiredPlatformVersion,
-        app_hashed_id: appUrl.split("bs://").pop() || "",
+        os_version: version,
+        app_hashed_id: app_url.split("bs://").pop() || "",
         scale_to_fit: "true",
         speed: "1",
         start: "true",
     });
-    return `https://app-live.browserstack.com/dashboard#${params.toString()}&device=${deviceParam}`;
+    const launchUrl = `https://app-live.browserstack.com/dashboard#${params.toString()}&device=${deviceParam}`;
+    openBrowser(launchUrl);
+    return launchUrl + note;
 }
 /**
  * Opens the launch URL in the default browser.

package/dist/tools/applive-utils/types.js

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

package/dist/tools/applive-utils/version-utils.js

@@ -0,0 +1,13 @@
+import { resolveVersion } from "../../lib/version-resolver.js";
+/**
+ * Resolve desired version against available list
+ */
+export function pickVersion(available, requested) {
+    try {
+        return resolveVersion(requested, available);
+    }
+    catch {
+        const opts = available.join(", ");
+        throw new Error(`Version "${requested}" not found. Available versions: ${opts}`);
+    }
+}

package/dist/tools/live-utils/desktop-filter.js

@@ -1,5 +1,5 @@
 import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
-import { resolveVersion } from "./version-resolver.js";
+import { resolveVersion } from "../../lib/version-resolver.js";
 import { customFuzzySearch } from "../../lib/fuzzy.js";
 export async function filterDesktop(args) {
     const data = await getDevicesAndBrowsers(BrowserStackProducts.LIVE);

package/dist/tools/live-utils/mobile-filter.js

@@ -1,5 +1,5 @@
 import { getDevicesAndBrowsers, BrowserStackProducts, } from "../../lib/device-cache.js";
-import { resolveVersion } from "./version-resolver.js";
+import { resolveVersion } from "../../lib/version-resolver.js";
 import { customFuzzySearch } from "../../lib/fuzzy.js";
 // Extract all mobile entries from the data
 function getAllMobileEntries(data) {

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

@@ -0,0 +1,51 @@
+import { assertOkResponse } from "../../lib/utils.js";
+import config from "../../config.js";
+export async function getSelfHealSelectors(sessionId) {
+    const credentials = `${config.browserstackUsername}:${config.browserstackAccessKey}`;
+    const auth = Buffer.from(credentials).toString("base64");
+    const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
+    const response = await fetch(url, {
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+    });
+    await assertOkResponse(response, "session logs");
+    const logText = await response.text();
+    return extractHealedSelectors(logText);
+}
+function extractHealedSelectors(logText) {
+    // Split log text into lines for easier context handling
+    const logLines = logText.split("\n");
+    // Pattern to match successful SELFHEAL entries only
+    const selfhealPattern = /SELFHEAL\s*{\s*"status":"true",\s*"data":\s*{\s*"using":"css selector",\s*"value":"(.*?)"}/;
+    // Pattern to match preceding selector requests
+    const requestPattern = /POST \/session\/[^/]+\/element.*?"using":"css selector","value":"(.*?)"/;
+    // Find all successful healed selectors with their line numbers and context
+    const healedMappings = [];
+    for (let i = 0; i < logLines.length; i++) {
+        const match = logLines[i].match(selfhealPattern);
+        if (match) {
+            const beforeLine = i > 0 ? logLines[i - 1] : "";
+            const afterLine = i < logLines.length - 1 ? logLines[i + 1] : "";
+            // Look backwards to find the most recent original selector request
+            let originalSelector = "UNKNOWN";
+            for (let j = i - 1; j >= 0; j--) {
+                const requestMatch = logLines[j].match(requestPattern);
+                if (requestMatch) {
+                    originalSelector = requestMatch[1];
+                    break;
+                }
+            }
+            healedMappings.push({
+                originalSelector,
+                healedSelector: match[1],
+                context: {
+                    before: beforeLine,
+                    after: afterLine,
+                },
+            });
+        }
+    }
+    return healedMappings;
+}

package/dist/tools/selfheal.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { getSelfHealSelectors } from "./selfheal-utils/selfheal.js";
+import logger from "../logger.js";
+import { trackMCP } from "../lib/instrumentation.js";
+// Tool function that fetches self-healing selectors
+export async function fetchSelfHealSelectorTool(args) {
+    try {
+        const selectors = await getSelfHealSelectors(args.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Self-heal selectors fetched successfully" +
+                        JSON.stringify(selectors),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.error("Error fetching self-heal selector suggestions", error);
+        throw error;
+    }
+}
+// Registers the fetchSelfHealSelector tool with the MCP server
+export default function addSelfHealTools(server) {
+    server.tool("fetchSelfHealedSelectors", "Retrieves AI-generated, self-healed selectors for a BrowserStack Automate session to resolve flaky tests caused by dynamic DOM changes.", {
+        sessionId: z.string().describe("The session ID of the test run"),
+    }, async (args) => {
+        try {
+            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion());
+            return await fetchSelfHealSelectorTool(args);
+        }
+        catch (error) {
+            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion(), error);
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error during fetching self-heal suggestions: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/testmanagement-utils/TCG-utils/api.js

@@ -127,7 +127,7 @@ export async function pollScenariosTestDetails(args, traceId, context, documentI
                                 progressToken: context._meta?.progressToken ?? traceId,
                                 progress: count,
                                 total: count,
-                                message: `Fetched ${count} scenarios`,
+                                message: `Generated ${count} scenarios`,
                             },
                         });
                     }
@@ -157,7 +157,7 @@ export async function pollScenariosTestDetails(args, traceId, context, documentI
                                     progressToken: context._meta?.progressToken ?? traceId,
                                     progress: iteratorCount,
                                     total,
-                                    message: `Fetched ${array.length} test cases for scenario ${iteratorCount} out of ${total}`,
+                                    message: `Generated ${array.length} test cases for scenario ${iteratorCount} out of ${total}`,
                                 },
                             });
                         }
@@ -214,7 +214,7 @@ export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fie
                 method: "notifications/progress",
                 params: {
                     progressToken: context._meta?.progressToken ?? "bulk-create",
-                    message: `Bulk create done for scenario ${doneCount} of ${total}`,
+                    message: `Saving and creating test cases...`,
                     total,
                     progress: doneCount,
                 },
@@ -226,7 +226,7 @@ export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fie
                 method: "notifications/progress",
                 params: {
                     progressToken: context._meta?.progressToken ?? traceId,
-                    message: `Bulk create failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    message: `Creation failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
                     total,
                     progress: doneCount,
                 },
@@ -257,3 +257,42 @@ export async function projectIdentifierToId(projectId) {
     }
     throw new Error(`Project with identifier ${projectId} not found.`);
 }
+export async function testCaseIdentifierToDetails(projectId, testCaseIdentifier) {
+    const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/search?q[query]=${testCaseIdentifier}`;
+    const response = await axios.get(url, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            accept: "application/json, text/plain, */*",
+        },
+    });
+    if (response.data.success !== true) {
+        throw new Error(`Failed to fetch test case details: ${response.statusText}`);
+    }
+    // Check if test_cases array exists and has items
+    if (!response.data.test_cases ||
+        !Array.isArray(response.data.test_cases) ||
+        response.data.test_cases.length === 0) {
+        throw new Error(`No test cases found in response for identifier ${testCaseIdentifier}`);
+    }
+    for (const testCase of response.data.test_cases) {
+        if (testCase.identifier === testCaseIdentifier) {
+            // Extract folder ID from the links.folder URL
+            // URL format: "/api/v1/projects/1930314/folder/10193436/test-cases"
+            let folderId = "";
+            if (testCase.links && testCase.links.folder) {
+                const folderMatch = testCase.links.folder.match(/\/folder\/(\d+)\//);
+                if (folderMatch && folderMatch[1]) {
+                    folderId = folderMatch[1];
+                }
+            }
+            if (!folderId) {
+                throw new Error(`Could not extract folder ID for test case ${testCaseIdentifier}`);
+            }
+            return {
+                testCaseId: testCase.id.toString(),
+                folderId: folderId,
+            };
+        }
+    }
+    throw new Error(`Test case with identifier ${testCaseIdentifier} not found.`);
+}

package/dist/tools/testmanagement-utils/create-lca-steps.js

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import axios from "axios";
+import config from "../../config.js";
+import { formatAxiosError } from "../../lib/error.js";
+import { projectIdentifierToId, testCaseIdentifierToDetails, } from "./TCG-utils/api.js";
+import { pollLCAStatus } from "./poll-lca-status.js";
+/**
+ * Schema for creating LCA steps for a test case
+ */
+export const CreateLCAStepsSchema = z.object({
+    project_identifier: z
+        .string()
+        .describe("ID of the project (Starts with 'PR-')"),
+    test_case_identifier: z
+        .string()
+        .describe("Identifier of the test case (e.g., 'TC-12345')"),
+    base_url: z.string().describe("Base URL for the test (e.g., 'google.com')"),
+    credentials: z
+        .object({
+        username: z.string().describe("Username for authentication"),
+        password: z.string().describe("Password for authentication"),
+    })
+        .optional()
+        .describe("Optional credentials for authentication. Extract from the test case details if provided in it. This is required for the test cases which require authentication."),
+    local_enabled: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Whether local testing is enabled"),
+    test_name: z.string().describe("Name of the test"),
+    test_case_details: z
+        .object({
+        name: z.string().describe("Name of the test case"),
+        description: z.string().describe("Description of the test case"),
+        preconditions: z.string().describe("Preconditions for the test case"),
+        test_case_steps: z
+            .array(z.object({
+            step: z.string().describe("Test step description"),
+            result: z.string().describe("Expected result"),
+        }))
+            .describe("Array of test case steps with expected results"),
+    })
+        .describe("Test case details including steps"),
+    wait_for_completion: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Whether to wait for LCA build completion (default: true)"),
+});
+/**
+ * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management
+ */
+export async function createLCASteps(args, context) {
+    try {
+        // Get the project ID from identifier
+        const projectId = await projectIdentifierToId(args.project_identifier);
+        // Get the test case ID and folder ID from identifier
+        const { testCaseId, folderId } = await testCaseIdentifierToDetails(projectId, args.test_case_identifier);
+        const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/lcnc`;
+        const payload = {
+            base_url: args.base_url,
+            credentials: args.credentials,
+            local_enabled: args.local_enabled,
+            test_name: args.test_name,
+            test_case_details: args.test_case_details,
+            version: "v2",
+            webhook_path: `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/webhooks/lcnc`,
+        };
+        const response = await axios.post(url, payload, {
+            headers: {
+                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                accept: "application/json, text/plain, */*",
+                "Content-Type": "application/json",
+            },
+        });
+        if (response.status >= 200 && response.status < 300) {
+            // Check if user wants to wait for completion
+            if (!args.wait_for_completion) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                        },
+                        {
+                            type: "text",
+                            text: "LCA build started. Check the BrowserStack Lowcode Automation UI for completion status.",
+                        },
+                    ],
+                };
+            }
+            // Start polling for LCA build completion
+            try {
+                const max_wait_minutes = 10; // Maximum wait time in minutes
+                const maxWaitMs = max_wait_minutes * 60 * 1000;
+                const lcaResult = await pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitMs, // max wait time
+                2 * 60 * 1000, // 2 minutes initial wait
+                10 * 1000);
+                if (lcaResult && lcaResult.status === "done") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Successfully created LCA steps for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                            },
+                            {
+                                type: "text",
+                                text: `LCA build completed! Resource URL: ${lcaResult.resource_path}`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                            },
+                            {
+                                type: "text",
+                                text: `Warning: LCA build did not complete within ${max_wait_minutes} minutes. You can check the status later in the BrowserStack Test Management UI.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            catch (pollError) {
+                console.error("Error during LCA polling:", pollError);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                        },
+                        {
+                            type: "text",
+                            text: "Warning: Error occurred while polling for LCA build completion. Check the BrowserStack Test Management UI for status.",
+                        },
+                    ],
+                };
+            }
+        }
+        else {
+            throw new Error(`Unexpected response: ${JSON.stringify(response.data)}`);
+        }
+    }
+    catch (error) {
+        // Add more specific error handling
+        if (error instanceof Error) {
+            if (error.message.includes("not found")) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error: ${error.message}. Please verify that the project identifier "${args.project_identifier}" and test case identifier "${args.test_case_identifier}" are correct.`,
+                            isError: true,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        return formatAxiosError(error, "Failed to create LCA steps");
+    }
+}

package/dist/tools/testmanagement-utils/poll-lca-status.js

@@ -0,0 +1,117 @@
+import axios from "axios";
+import config from "../../config.js";
+/**
+ * Poll test case details to check LCA build status
+ */
+export async function pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitTimeMs = 10 * 60 * 1000, // 10 minutes default
+initialWaitMs = 2 * 60 * 1000, // 2 minutes initial wait
+pollIntervalMs = 10 * 1000) {
+    const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/test-cases/${testCaseId}`;
+    const startTime = Date.now();
+    // Send initial notification that polling is starting
+    const notificationInterval = Math.min(initialWaitMs, pollIntervalMs);
+    const notificationStartTime = Date.now();
+    const notificationIntervalId = setInterval(async () => {
+        const elapsedTime = Date.now() - notificationStartTime;
+        const progressPercentage = Math.min(90, Math.floor((elapsedTime / maxWaitTimeMs) * 90));
+        await context.sendNotification({
+            method: "notifications/progress",
+            params: {
+                progressToken: context._meta?.progressToken ?? `lca-${testCaseId}`,
+                message: `Generating Low Code Automation Test..`,
+                progress: progressPercentage,
+                total: 100,
+            },
+        });
+        if (elapsedTime >= initialWaitMs) {
+            clearInterval(notificationIntervalId);
+        }
+    }, notificationInterval);
+    // Wait for initial period before starting to poll
+    await new Promise((resolve) => setTimeout(resolve, initialWaitMs));
+    clearInterval(notificationIntervalId);
+    return new Promise((resolve) => {
+        // Set up timeout to handle max wait time
+        const timeoutId = setTimeout(() => {
+            clearInterval(intervalId);
+            // Send timeout notification
+            context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken: context._meta?.progressToken ?? `lca-${testCaseId}`,
+                    message: `LCA build polling timed out after ${Math.floor(maxWaitTimeMs / 60000)} minutes`,
+                    progress: 100,
+                    total: 100,
+                },
+            });
+            resolve(null);
+        }, maxWaitTimeMs);
+        // Set up polling interval
+        const intervalId = setInterval(async () => {
+            try {
+                const response = await axios.get(url, {
+                    headers: {
+                        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                        accept: "application/json, text/plain, */*",
+                    },
+                });
+                if (response.data.data.success && response.data.data.test_case) {
+                    const testCase = response.data.data.test_case;
+                    // Check lcnc_build_map in both possible locations
+                    const lcncBuildMap = testCase.lcnc_build_map ||
+                        response.data.data.metadata?.lcnc_build_map;
+                    if (lcncBuildMap) {
+                        if (lcncBuildMap.status === "done") {
+                            // Clean up timers
+                            clearInterval(intervalId);
+                            clearTimeout(timeoutId);
+                            // Send completion notification
+                            await context.sendNotification({
+                                method: "notifications/progress",
+                                params: {
+                                    progressToken: context._meta?.progressToken ?? `lca-${testCaseId}`,
+                                    message: `LCA build completed successfully!`,
+                                    progress: 100,
+                                    total: 100,
+                                },
+                            });
+                            resolve({
+                                resource_path: lcncBuildMap.resource_path,
+                                status: lcncBuildMap.status,
+                            });
+                            return;
+                        }
+                        // Send progress notification with current status
+                        const elapsedTime = Date.now() - startTime;
+                        const progressPercentage = Math.min(90, Math.floor((elapsedTime / maxWaitTimeMs) * 90) + 10);
+                        // Cycle through different numbers of dots (2, 3, 4, 5, then back to 2)
+                        const dotCount = (Math.floor(elapsedTime / pollIntervalMs) % 4) + 2;
+                        const dots = ".".repeat(dotCount);
+                        await context.sendNotification({
+                            method: "notifications/progress",
+                            params: {
+                                progressToken: context._meta?.progressToken ?? `lca-${testCaseId}`,
+                                message: `Generating Low Code Automation Test${dots}`,
+                                progress: progressPercentage,
+                                total: 100,
+                            },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error polling LCA status:", error);
+                // Send error notification but continue polling
+                await context.sendNotification({
+                    method: "notifications/progress",
+                    params: {
+                        progressToken: context._meta?.progressToken ?? `lca-${testCaseId}`,
+                        message: `Error occurred while polling, retrying... (${error instanceof Error ? error.message : "Unknown error"})`,
+                        progress: Math.min(90, Math.floor(((Date.now() - startTime) / maxWaitTimeMs) * 90) + 10),
+                        total: 100,
+                    },
+                });
+            }
+        }, pollIntervalMs);
+    });
+}

package/dist/tools/testmanagement-utils/testcase-from-file.js

@@ -31,12 +31,17 @@ export async function createTestCasesFromFile(args, context) {
     const scenariosMap = await pollScenariosTestDetails(args, traceId, context, documentId, source);
     const resultString = await bulkCreateTestCases(scenariosMap, args.projectReferenceId, args.folderId, fieldMaps, booleanFieldId, traceId, context, documentId);
     signedUrlMap.delete(args.documentId);
+    const dashboardURL = `https://test-management.browserstack.com/projects/${args.projectReferenceId}/folder/${args.folderId}/test-cases`;
     return {
         content: [
             {
                 type: "text",
                 text: resultString,
             },
+            {
+                type: "text",
+                text: `Dashboard URL: ${dashboardURL}`,
+            },
         ],
     };
 }

package/dist/tools/testmanagement.js

@@ -11,6 +11,7 @@ import { addTestResult, AddTestResultSchema, } from "./testmanagement-utils/add-
 import { UploadFileSchema, uploadFile, } from "./testmanagement-utils/upload-file.js";
 import { createTestCasesFromFile } from "./testmanagement-utils/testcase-from-file.js";
 import { CreateTestCasesFromFileSchema } from "./testmanagement-utils/TCG-utils/types.js";
+import { createLCASteps, CreateLCAStepsSchema, } from "./testmanagement-utils/create-lca-steps.js";
 //TODO: Moving the traceMCP and catch block to the parent(server) function
 /**
  * Wrapper to call createProjectOrFolder util.
@@ -216,6 +217,28 @@ export async function createTestCasesFromFileTool(args, context) {
         };
     }
 }
+/**
+ * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management.
+ */
+export async function createLCAStepsTool(args, context) {
+    try {
+        trackMCP("createLCASteps", serverInstance.server.getClientVersion());
+        return await createLCASteps(args, context);
+    }
+    catch (err) {
+        trackMCP("createLCASteps", serverInstance.server.getClientVersion(), err);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to create LCA steps: ${err instanceof Error ? err.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
+                    isError: true,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
 /**
  * Registers both project/folder and test-case tools.
  */
@@ -228,6 +251,7 @@ export default function addTestManagementTools(server) {
     server.tool("listTestRuns", "List test runs in a project with optional filters (date ranges, assignee, state, etc.)", ListTestRunsSchema.shape, listTestRunsTool);
     server.tool("updateTestRun", "Update a test run in BrowserStack Test Management.", UpdateTestRunSchema.shape, updateTestRunTool);
     server.tool("addTestResult", "Add a test result to a specific test run via BrowserStack Test Management API.", AddTestResultSchema.shape, addTestResultTool);
-    server.tool("uploadProductRequirementFile", "Upload files such as PDRs or PDFs to BrowserStack Test Management and get file mapping ID back. Its Used for generating test cases from file.", UploadFileSchema.shape, uploadProductRequirementFileTool);
-    server.tool("createTestCasesFromFile", "Create test cases from a file in BrowserStack Test Management.", CreateTestCasesFromFileSchema.shape, createTestCasesFromFileTool);
+    server.tool("uploadProductRequirementFile", "Upload files (e.g., PDRs, PDFs) to BrowserStack Test Management and retrieve a file mapping ID. This is utilized for generating test cases from files and is part of the Test Case Generator AI Agent in BrowserStack.", UploadFileSchema.shape, uploadProductRequirementFileTool);
+    server.tool("createTestCasesFromFile", "Generate test cases from a file in BrowserStack Test Management using the Test Case Generator AI Agent.", CreateTestCasesFromFileSchema.shape, createTestCasesFromFileTool);
+    server.tool("createLCASteps", "Generate Low Code Automation (LCA) steps for a test case in BrowserStack Test Management using the Low Code Automation Agent.", CreateLCAStepsSchema.shape, createLCAStepsTool);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "BrowserStack's Official MCP Server",
   "main": "dist/index.js",
   "repository": {

package/dist/tools/applive-utils/fuzzy-search.js

@@ -1,8 +0,0 @@
-import { customFuzzySearch } from "../../lib/fuzzy.js";
-/**
- * Fuzzy searches App Live device entries by name.
- */
-export async function fuzzySearchDevices(devices, query, limit = 5) {
-    const top_match = customFuzzySearch(devices, ["device", "display_name"], query, limit);
-    return top_match;
-}