@browserstack/mcp-server 1.1.5 → 1.1.7

package/dist/config.js

@@ -1,12 +1,44 @@
+// List of supported BrowserStack Local option names (as per SDK)
+const BROWSERSTACK_LOCAL_OPTION_KEYS = [
+    "proxyHost",
+    "proxyPort",
+    "proxyUser",
+    "proxyPass",
+    "useCaCertificate",
+    "localProxyHost",
+    "localProxyPort",
+    "localProxyUser",
+    "localProxyPass",
+    "pacFile",
+    "force",
+    "forceLocal",
+    "onlyAutomate",
+    "verbose",
+    "logFile",
+    "binarypath",
+    "f",
+    "excludeHosts",
+];
+// Build browserstackLocalOptions from individual env vars
+const browserstackLocalOptions = {};
+for (const key of BROWSERSTACK_LOCAL_OPTION_KEYS) {
+    // Env var name: BROWSERSTACK_LOCAL_OPTION_<UPPERCASE_KEY>
+    const envVar = process.env[`BROWSERSTACK_LOCAL_OPTION_${key.toUpperCase()}`];
+    if (envVar !== undefined) {
+        browserstackLocalOptions[key] = envVar;
+    }
+}
 export class Config {
     browserstackUsername;
     browserstackAccessKey;
     DEV_MODE;
-    constructor(browserstackUsername, browserstackAccessKey, DEV_MODE) {
+    browserstackLocalOptions;
+    constructor(browserstackUsername, browserstackAccessKey, DEV_MODE, browserstackLocalOptions) {
         this.browserstackUsername = browserstackUsername;
         this.browserstackAccessKey = browserstackAccessKey;
         this.DEV_MODE = DEV_MODE;
+        this.browserstackLocalOptions = browserstackLocalOptions;
     }
 }
-const config = new Config(process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY, process.env.DEV_MODE === "true");
+const config = new Config(process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY, process.env.DEV_MODE === "true", browserstackLocalOptions);
 export default config;

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/lib/local.js

@@ -69,15 +69,17 @@ export async function ensureLocalBinarySetup(localIdentifier) {
     logger.info("Ensuring local binary setup as it is required for private URLs...");
     const localBinary = new Local();
     await killExistingBrowserStackLocalProcesses();
-    const requestBody = {
+    // Use a single options object from config and extend with required fields
+    const bsLocalArgs = {
+        ...(config.browserstackLocalOptions || {}),
         key: config.browserstackAccessKey,
         username: config.browserstackUsername,
     };
     if (localIdentifier) {
-        requestBody.localIdentifier = localIdentifier;
+        bsLocalArgs.localIdentifier = localIdentifier;
     }
     return await new Promise((resolve, reject) => {
-        localBinary.start(requestBody, (error) => {
+        localBinary.start(bsLocalArgs, (error) => {
             if (error) {
                 logger.error(`Unable to start BrowserStack Local... please check your credentials and try again. Error: ${error}`);
                 reject(new Error(`Unable to configure local tunnel binary, please check your credentials and try again. Error: ${error}`));

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

@@ -56,6 +56,9 @@ export class AccessibilityScanner {
         }
         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;

package/dist/tools/appautomate.js

@@ -47,13 +47,19 @@ async function takeAppScreenshot(args) {
             },
         };
         logger.info("Starting WebDriver session on BrowserStack...");
-        driver = await remote({
-            protocol: "https",
-            hostname: "hub.browserstack.com",
-            port: 443,
-            path: "/wd/hub",
-            capabilities,
-        });
+        try {
+            driver = await remote({
+                protocol: "https",
+                hostname: "hub.browserstack.com",
+                port: 443,
+                path: "/wd/hub",
+                capabilities,
+            });
+        }
+        catch (error) {
+            logger.error("Error initializing WebDriver:", error);
+            throw new Error("Failed to initialize the WebDriver or a timeout occurred. Please try again.");
+        }
         const screenshotBase64 = await driver.takeScreenshot();
         const compressed = await maybeCompressBase64(screenshotBase64);
         return {

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

@@ -11,7 +11,7 @@ export function findDeviceByName(devices, desiredPhone) {
     }
     // Exact-case-insensitive filter
     const exact = matches.filter((m) => m.display_name.toLowerCase() === desiredPhone.toLowerCase());
-    if (exact)
+    if (exact.length)
         return exact;
     // If no exact but multiple fuzzy, ask user
     if (matches.length > 1) {

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

@@ -38,6 +38,9 @@ export async function startSession(args) {
     // 6) Upload app
     const { app_url } = await uploadApp(appPath);
     logger.info(`App uploaded: ${app_url}`);
+    if (!app_url) {
+        throw new Error("Failed to upload app. Please try again.");
+    }
     // 7) Build URL & open
     const deviceParam = sanitizeUrlParam(selected.display_name.replace(/\s+/g, "+"));
     const params = new URLSearchParams({

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

@@ -29,6 +29,43 @@ In order to run tests on BrowserStack, run the following command:
 browserstack-sdk python <path-to-test-file>
 \`\`\`
 `;
+const argsInstruction = '<argLine>-javaagent:"${com.browserstack:browserstack-java-sdk:jar}"</argLine>';
+const javaInstructions = `
+Strictly Add the following dependencies to your \`pom.xml\`:
+\`\`\`xml
+<dependency>
+    <groupId>com.browserstack</groupId>
+    <artifactId>browserstack-java-sdk</artifactId>
+    <version>LATEST</version>
+    <scope>compile</scope>
+</dependency>
+
+${argsInstruction}
+\`\`\`
+
+For Gradle projects, add to \`build.gradle\`:
+\`\`\`groovy
+dependencies {
+    implementation 'com.browserstack:browserstack-java-sdk:LATEST'
+}
+\`\`\`
+
+Inform user to export:
+\`\`\`bash
+export BROWSERSTACK_USERNAME=${config.browserstackUsername}
+export BROWSERSTACK_ACCESS_KEY=${config.browserstackAccessKey}
+\`\`\`
+
+Run tests using:
+\`\`\`bash
+mvn clean test 
+\`\`\`
+
+Or for Gradle:
+\`\`\`bash
+gradle clean test
+\`\`\`
+`;
 export const SUPPORTED_CONFIGURATIONS = {
     nodejs: {
         playwright: {
@@ -55,4 +92,12 @@ export const SUPPORTED_CONFIGURATIONS = {
             behave: { instructions: pythonInstructions },
         },
     },
+    java: {
+        playwright: {},
+        selenium: {
+            testng: { instructions: javaInstructions },
+            cucumber: { instructions: javaInstructions },
+            junit: { instructions: javaInstructions },
+        },
+    },
 };

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.5",
+  "version": "1.1.7",
   "description": "BrowserStack's Official MCP Server",
   "main": "dist/index.js",
   "repository": {