@browserstack/mcp-server 1.2.4 → 1.2.6

package/dist/tools/appautomate-utils/appium-sdk/handler.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { getBrowserStackAuth } from "../../../lib/get-auth.js";
+import { validateAppAutomateDevices } from "../../sdk-utils/common/device-validator.js";
 import { getAppUploadInstruction, validateSupportforAppAutomate, } from "./utils.js";
 import { getAppSDKPrefixCommand, generateAppBrowserStackYMLInstructions, } from "./index.js";
 import { formatAppInstructionsWithNumbers, getAppInstructionsForProjectConfiguration, SETUP_APP_AUTOMATE_SCHEMA, } from "./index.js";
@@ -11,18 +12,31 @@ export async function setupAppAutomateHandler(rawInput, config) {
     // Use variables for all major input properties
     const testingFramework = input.detectedTestingFramework;
     const language = input.detectedLanguage;
-    const platforms = input.desiredPlatforms ?? ["android"];
+    const inputDevices = input.devices ?? [];
     const appPath = input.appPath;
     const framework = input.detectedFramework;
     //Validating if supported framework or not
     validateSupportforAppAutomate(framework, language, testingFramework);
+    // Use default mobile devices when array is empty
+    const devices = inputDevices.length === 0
+        ? [["android", "Samsung Galaxy S24", "latest"]]
+        : inputDevices;
+    // Validate devices against real BrowserStack device data
+    const validatedEnvironments = await validateAppAutomateDevices(devices);
+    // Extract platforms for backward compatibility (if needed)
+    const platforms = validatedEnvironments.map((env) => env.platform);
     // Step 1: Generate SDK setup command
     const sdkCommand = getAppSDKPrefixCommand(language, testingFramework, username, accessKey, appPath);
     if (sdkCommand) {
         instructions.push({ content: sdkCommand, type: "setup" });
     }
     // Step 2: Generate browserstack.yml configuration
-    const configInstructions = generateAppBrowserStackYMLInstructions(platforms, username, accessKey, appPath, testingFramework);
+    const configInstructions = generateAppBrowserStackYMLInstructions({
+        validatedEnvironments,
+        platforms,
+        testingFramework,
+        projectName: input.project,
+    }, username, accessKey, appPath);
     if (configInstructions) {
         instructions.push({ content: configInstructions, type: "config" });
     }

package/dist/tools/appautomate-utils/appium-sdk/languages/java.d.ts

@@ -1,8 +1,10 @@
 export declare const MAVEN_ARCHETYPE_GROUP_ID = "com.browserstack";
 export declare const MAVEN_ARCHETYPE_ARTIFACT_ID = "junit-archetype-integrate";
 export declare const MAVEN_ARCHETYPE_VERSION = "1.0";
+export declare const JAVA_APP_FRAMEWORK_VERSION_MAP: Record<string, string>;
 export declare const JAVA_APP_FRAMEWORK_MAP: Record<string, string>;
 export declare const GRADLE_APP_SETUP_INSTRUCTIONS = "\n**For Gradle setup:**\n1. Add browserstack-java-sdk to dependencies:\n   compileOnly 'com.browserstack:browserstack-java-sdk:latest.release'\n\n2. Add browserstackSDK path variable:\n   def browserstackSDKArtifact = configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.find { it.name == 'browserstack-java-sdk' }\n\n3. Add javaagent to gradle tasks:\n   jvmArgs \"-javaagent:${browserstackSDKArtifact.file}\"\n";
 export declare function getJavaAppInstructions(): string;
 export declare function getJavaAppFrameworkForMaven(framework: string): string;
+export declare function getJavaAppFrameworkVersion(framework: string): string;
 export declare function getJavaSDKCommand(framework: string, username: string, accessKey: string, appPath?: string): string;

package/dist/tools/appautomate-utils/appium-sdk/languages/java.js

@@ -4,15 +4,31 @@ import { createStep, combineInstructions, createEnvStep, PLATFORM_UTILS, } from
 export const MAVEN_ARCHETYPE_GROUP_ID = "com.browserstack";
 export const MAVEN_ARCHETYPE_ARTIFACT_ID = "junit-archetype-integrate";
 export const MAVEN_ARCHETYPE_VERSION = "1.0";
+// Version mapping for different frameworks
+export const JAVA_APP_FRAMEWORK_VERSION_MAP = {
+    testng: "1.4",
+    selenide: "1.4",
+    junit5: "1.0",
+    junit4: "1.0",
+    jbehave: "1.0",
+    cucumberTestng: "1.0",
+    cucumberJunit4: "1.0",
+    cucumberJunit5: "1.0",
+    cucumber: "1.0",
+    serenity: "1.0",
+};
 // Framework mapping for Java Maven archetype generation for App Automate
 export const JAVA_APP_FRAMEWORK_MAP = {
-    testng: "browserstack-sdk-archetype-integrate",
+    testng: "testng-archetype-integrate",
     junit5: "browserstack-sdk-archetype-integrate",
     selenide: "selenide-archetype-integrate",
     jbehave: "browserstack-sdk-archetype-integrate",
+    junit4: "browserstack-sdk-archetype-integrate",
     cucumberTestng: "browserstack-sdk-archetype-integrate",
     cucumberJunit4: "browserstack-sdk-archetype-integrate",
     cucumberJunit5: "browserstack-sdk-archetype-integrate",
+    cucumber: "browserstack-sdk-archetype-integrate",
+    serenity: "browserstack-sdk-archetype-integrate",
 };
 // Common Gradle setup instructions for App Automate (platform-independent)
 export const GRADLE_APP_SETUP_INSTRUCTIONS = `
@@ -35,53 +51,71 @@ mvn test
 export function getJavaAppFrameworkForMaven(framework) {
     return JAVA_APP_FRAMEWORK_MAP[framework] || framework;
 }
-function getMavenCommandForWindows(framework, mavenFramework, username, accessKey) {
-    return (`mvn archetype:generate -B ` +
+export function getJavaAppFrameworkVersion(framework) {
+    return JAVA_APP_FRAMEWORK_VERSION_MAP[framework] || MAVEN_ARCHETYPE_VERSION;
+}
+function getMavenCommandForWindows(framework, mavenFramework, version, username, accessKey, appPath) {
+    let command = `mvn archetype:generate -B ` +
         `-DarchetypeGroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
         `-DarchetypeArtifactId="${mavenFramework}" ` +
-        `-DarchetypeVersion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DarchetypeVersion="${version}" ` +
         `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
-        `-DartifactId="${MAVEN_ARCHETYPE_ARTIFACT_ID}" ` +
-        `-Dversion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DartifactId="${mavenFramework}" ` +
+        `-Dversion="${version}" ` +
         `-DBROWSERSTACK_USERNAME="${username}" ` +
-        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}" ` +
-        `-DBROWSERSTACK_FRAMEWORK="${framework}"`);
+        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}"`;
+    // Add framework parameter for browserstack-sdk-archetype-integrate
+    if (mavenFramework === "browserstack-sdk-archetype-integrate") {
+        command += ` -DBROWSERSTACK_FRAMEWORK="${framework}"`;
+    }
+    // Add app path if provided
+    if (appPath) {
+        command += ` -DBROWSERSTACK_APP="${appPath}"`;
+    }
+    return command;
 }
-function getMavenCommandForUnix(framework, mavenFramework, username, accessKey) {
-    return (`mvn archetype:generate -B ` +
+function getMavenCommandForUnix(framework, mavenFramework, version, username, accessKey, appPath) {
+    let command = `mvn archetype:generate -B ` +
         `-DarchetypeGroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
         `-DarchetypeArtifactId="${mavenFramework}" ` +
-        `-DarchetypeVersion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DarchetypeVersion="${version}" ` +
         `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
-        `-DartifactId="${MAVEN_ARCHETYPE_ARTIFACT_ID}" ` +
-        `-Dversion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DartifactId="${mavenFramework}" ` +
+        `-Dversion="${version}" ` +
         `-DBROWSERSTACK_USERNAME="${username}" ` +
-        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}" ` +
-        `-DBROWSERSTACK_FRAMEWORK="${framework}"`);
+        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}"`;
+    // Add framework parameter for browserstack-sdk-archetype-integrate
+    if (mavenFramework === "browserstack-sdk-archetype-integrate") {
+        command += ` -DBROWSERSTACK_FRAMEWORK="${framework}"`;
+    }
+    // Add app path if provided
+    if (appPath) {
+        command += ` -DBROWSERSTACK_APP="${appPath}"`;
+    }
+    return command;
 }
 export function getJavaSDKCommand(framework, username, accessKey, appPath) {
     const { isWindows = false, getPlatformLabel } = PLATFORM_UTILS || {};
     const mavenFramework = getJavaAppFrameworkForMaven(framework);
+    const version = getJavaAppFrameworkVersion(framework);
     let mavenCommand;
     if (isWindows) {
-        mavenCommand = getMavenCommandForWindows(framework, mavenFramework, username, accessKey);
-        if (appPath) {
-            mavenCommand += ` -DBROWSERSTACK_APP="${appPath}"`;
-        }
+        mavenCommand = getMavenCommandForWindows(framework, mavenFramework, version, username, accessKey, appPath);
     }
     else {
-        mavenCommand = getMavenCommandForUnix(framework, mavenFramework, username, accessKey);
-        if (appPath) {
-            mavenCommand += ` -DBROWSERSTACK_APP="${appPath}"`;
-        }
+        mavenCommand = getMavenCommandForUnix(framework, mavenFramework, version, username, accessKey, appPath);
     }
     const envStep = createEnvStep(username, accessKey, isWindows, getPlatformLabel());
     const mavenStep = createStep("Install BrowserStack SDK using Maven Archetype for App Automate", `Maven command for ${framework} (${getPlatformLabel()}):
-\`\`\`bash
-${mavenCommand}
-\`\`\`
+    \`\`\`bash
+    ${mavenCommand}
+    \`\`\`
 
-Alternative setup for Gradle users:
-${GRADLE_APP_SETUP_INSTRUCTIONS}`);
-    return combineInstructions(envStep, mavenStep);
+    Alternative setup for Gradle users:
+    ${GRADLE_APP_SETUP_INSTRUCTIONS}`);
+    const argsLineStep = createStep("Verifying dependency and argsLine", `Verify browserstack-java-sdk with LATEST is added as dependency and add this line in pom.xml if not added:
+    \`\`\`xml
+    <argLine>-javaagent:"\${com.browserstack:browserstack-java-sdk:jar}"</argLine>
+    \`\`\``);
+    return combineInstructions(envStep, mavenStep, argsLineStep);
 }

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

@@ -16,6 +16,7 @@ export declare enum AppSDKSupportedTestingFrameworkEnum {
     junit4 = "junit4",
     selenide = "selenide",
     jbehave = "jbehave",
+    serenity = "serenity",
     cucumberTestng = "cucumberTestng",
     cucumberJunit4 = "cucumberJunit4",
     cucumberJunit5 = "cucumberJunit5",
@@ -49,7 +50,7 @@ export interface AppSDKInstruction {
 export declare const SUPPORTED_CONFIGURATIONS: {
     appium: {
         ruby: string[];
-        java: never[];
+        java: string[];
         csharp: never[];
         python: string[];
         nodejs: string[];

package/dist/tools/appautomate-utils/appium-sdk/types.js

@@ -18,6 +18,7 @@ export var AppSDKSupportedTestingFrameworkEnum;
     AppSDKSupportedTestingFrameworkEnum["junit4"] = "junit4";
     AppSDKSupportedTestingFrameworkEnum["selenide"] = "selenide";
     AppSDKSupportedTestingFrameworkEnum["jbehave"] = "jbehave";
+    AppSDKSupportedTestingFrameworkEnum["serenity"] = "serenity";
     AppSDKSupportedTestingFrameworkEnum["cucumberTestng"] = "cucumberTestng";
     AppSDKSupportedTestingFrameworkEnum["cucumberJunit4"] = "cucumberJunit4";
     AppSDKSupportedTestingFrameworkEnum["cucumberJunit5"] = "cucumberJunit5";
@@ -46,7 +47,15 @@ export var AppSDKSupportedPlatformEnum;
 export const SUPPORTED_CONFIGURATIONS = {
     appium: {
         ruby: ["cucumberRuby"],
-        java: [],
+        java: [
+            "testng",
+            "cucumber",
+            "junit4",
+            "junit5",
+            "jbehave",
+            "selenide",
+            "serenity",
+        ],
         csharp: [],
         python: ["pytest", "robot", "behave", "lettuce"],
         nodejs: ["jest", "mocha", "cucumberJs", "webdriverio", "nightwatch"],

package/dist/tools/appautomate-utils/native-execution/constants.d.ts

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { AppTestPlatform } from "./types.js";
+import { AppSDKSupportedPlatformEnum } from "../appium-sdk/types.js";
 export declare const RUN_APP_AUTOMATE_DESCRIPTION = "Execute pre-built native mobile test suites (Espresso for Android, XCUITest for iOS) by direct upload to BrowserStack. ONLY for compiled .apk/.ipa test files. This is NOT for SDK integration or Appium tests. For Appium-based testing with SDK setup, use 'setupBrowserStackAppAutomateTests' instead.";
 export declare const RUN_APP_AUTOMATE_SCHEMA: {
     appPath: z.ZodString;
     testSuitePath: z.ZodString;
-    devices: z.ZodArray<z.ZodString, "many">;
+    devices: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodTuple<[z.ZodLiteral<AppSDKSupportedPlatformEnum.android>, z.ZodString, z.ZodString], null>, z.ZodTuple<[z.ZodLiteral<AppSDKSupportedPlatformEnum.ios>, z.ZodString, z.ZodString], null>]>, "many">>;
     project: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     detectedAutomationFramework: z.ZodNativeEnum<typeof AppTestPlatform>;
 };

package/dist/tools/appautomate-utils/native-execution/constants.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { AppTestPlatform } from "./types.js";
+import { AppSDKSupportedPlatformEnum } from "../appium-sdk/types.js";
 export const RUN_APP_AUTOMATE_DESCRIPTION = `Execute pre-built native mobile test suites (Espresso for Android, XCUITest for iOS) by direct upload to BrowserStack. ONLY for compiled .apk/.ipa test files. This is NOT for SDK integration or Appium tests. For Appium-based testing with SDK setup, use 'setupBrowserStackAppAutomateTests' instead.`;
 export const RUN_APP_AUTOMATE_SCHEMA = {
     appPath: z
@@ -23,8 +24,29 @@ export const RUN_APP_AUTOMATE_SCHEMA = {
         "  zip -r Tests.zip *.xctestrun *-Runner.app\n\n" +
         "If in other directory, provide existing test file path"),
     devices: z
-        .array(z.string())
-        .describe("List of devices to run the test on, e.g., ['Samsung Galaxy S20-10.0', 'iPhone 12 Pro-16.0']."),
+        .array(z.union([
+        // Android: [android, deviceName, osVersion]
+        z.tuple([
+            z
+                .literal(AppSDKSupportedPlatformEnum.android)
+                .describe("Platform identifier: 'android'"),
+            z
+                .string()
+                .describe("Device name, e.g. 'Samsung Galaxy S24', 'Google Pixel 8'"),
+            z.string().describe("Android version, e.g. '14', '16', 'latest'"),
+        ]),
+        // iOS: [ios, deviceName, osVersion]
+        z.tuple([
+            z
+                .literal(AppSDKSupportedPlatformEnum.ios)
+                .describe("Platform identifier: 'ios'"),
+            z.string().describe("Device name, e.g. 'iPhone 15', 'iPhone 14 Pro'"),
+            z.string().describe("iOS version, e.g. '17', '16', 'latest'"),
+        ]),
+    ]))
+        .max(3)
+        .default([])
+        .describe("Tuples describing target mobile devices. Add device only when user asks explicitly for it. Defaults to [] . Example: [['android', 'Samsung Galaxy S24', '14'], ['ios', 'iPhone 15', '17']]"),
     project: z
         .string()
         .optional()

package/dist/tools/appautomate.js

@@ -6,6 +6,7 @@ import { maybeCompressBase64 } from "../lib/utils.js";
 import { remote } from "webdriverio";
 import { AppTestPlatform } from "./appautomate-utils/native-execution/types.js";
 import { setupAppAutomateHandler } from "./appautomate-utils/appium-sdk/handler.js";
+import { validateAppAutomateDevices } from "./sdk-utils/common/device-validator.js";
 import { SETUP_APP_AUTOMATE_DESCRIPTION, SETUP_APP_AUTOMATE_SCHEMA, } from "./appautomate-utils/appium-sdk/constants.js";
 import { Platform, } from "./appautomate-utils/native-execution/types.js";
 import { getDevicesAndBrowsers, BrowserStackProducts, } from "../lib/device-cache.js";
@@ -105,6 +106,8 @@ async function runAppTestsOnBrowserStack(args, config) {
     if (!args.browserstackTestSuiteUrl && !args.testSuitePath) {
         throw new Error("testSuitePath is required when browserstackTestSuiteUrl is not provided");
     }
+    // Validate devices against real BrowserStack device data
+    await validateAppAutomateDevices(args.devices);
     switch (args.detectedAutomationFramework) {
         case AppTestPlatform.ESPRESSO: {
             try {
@@ -126,7 +129,12 @@ async function runAppTestsOnBrowserStack(args, config) {
                     test_suite_url = await uploadEspressoTestSuite(args.testSuitePath, config);
                     logger.info(`Test suite uploaded. URL: ${test_suite_url}`);
                 }
-                const build_id = await triggerEspressoBuild(app_url, test_suite_url, args.devices, args.project);
+                // Convert array format to string format for Espresso
+                const deviceStrings = args.devices.map((device) => {
+                    const [, deviceName, osVersion] = device;
+                    return `${deviceName}-${osVersion}`;
+                });
+                const build_id = await triggerEspressoBuild(app_url, test_suite_url, deviceStrings, args.project);
                 return {
                     content: [
                         {
@@ -161,7 +169,12 @@ async function runAppTestsOnBrowserStack(args, config) {
                     test_suite_url = await uploadXcuiTestSuite(args.testSuitePath, config);
                     logger.info(`Test suite uploaded. URL: ${test_suite_url}`);
                 }
-                const build_id = await triggerXcuiBuild(app_url, test_suite_url, args.devices, args.project, config);
+                // Convert array format to string format for XCUITest
+                const deviceStrings = args.devices.map((device) => {
+                    const [, deviceName, osVersion] = device;
+                    return `${deviceName}-${osVersion}`;
+                });
+                const build_id = await triggerXcuiBuild(app_url, test_suite_url, deviceStrings, args.project, config);
                 return {
                     content: [
                         {

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

@@ -39,7 +39,10 @@ async function extractScreenshotUrls(sessionId, sessionType, config) {
 //Converts screenshot URLs to base64 encoded images
 async function convertUrlsToBase64(urls) {
     const screenshots = await Promise.all(urls.map(async (url) => {
-        const response = await apiClient.get({ url });
+        const response = await apiClient.get({
+            url,
+            responseType: "arraybuffer",
+        });
         // Axios returns response.data as a Buffer for binary data
         const base64 = Buffer.from(response.data).toString("base64");
         // Compress the base64 image if needed

package/dist/tools/list-test-files.d.ts

@@ -1,2 +1,2 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-export declare function addListTestFiles(args: any): Promise<CallToolResult>;
+export declare function addListTestFiles(): Promise<CallToolResult>;

package/dist/tools/list-test-files.js

@@ -1,35 +1,59 @@
 import { listTestFiles } from "./percy-snapshot-utils/detect-test-files.js";
-import { testFilePathsMap } from "../lib/inmemory-store.js";
-import crypto from "crypto";
-export async function addListTestFiles(args) {
-    const { dirs, language, framework } = args;
-    let testFiles = [];
-    if (!dirs || dirs.length === 0) {
-        throw new Error("No directories provided to add the test files. Please provide test directories to add percy snapshot commands.");
+import { storedPercyResults } from "../lib/inmemory-store.js";
+import { updateFileAndStep } from "./percy-snapshot-utils/utils.js";
+import { percyWebSetupInstructions } from "./sdk-utils/percy-web/handler.js";
+export async function addListTestFiles() {
+    const storedResults = storedPercyResults.get();
+    if (!storedResults) {
+        throw new Error("No Framework details found. Please call expandPercyVisualTesting first to fetch the framework details.");
     }
-    for (const dir of dirs) {
-        const files = await listTestFiles({
-            language,
-            framework,
-            baseDir: dir,
-        });
+    const language = storedResults.detectedLanguage;
+    const framework = storedResults.detectedTestingFramework;
+    // Use stored paths from setUpPercy
+    const dirs = storedResults.folderPaths;
+    const files = storedResults.filePaths;
+    let testFiles = [];
+    if (files && files.length > 0) {
         testFiles = testFiles.concat(files);
     }
+    if (dirs && dirs.length > 0) {
+        for (const dir of dirs) {
+            const discoveredFiles = await listTestFiles({
+                language,
+                framework,
+                baseDir: dir,
+            });
+            testFiles = testFiles.concat(discoveredFiles);
+        }
+    }
+    // Validate that we have at least one test file
     if (testFiles.length === 0) {
-        throw new Error("No test files found");
+        throw new Error("No test files found. Please provide either specific file paths (files) or directory paths (dirs) containing test files.");
+    }
+    if (testFiles.length === 1) {
+        const result = await updateFileAndStep(testFiles[0], 0, 1, percyWebSetupInstructions);
+        return {
+            content: result,
+        };
     }
-    // Generate a UUID and store the test files in memory
-    const uuid = crypto.randomUUID();
-    testFilePathsMap.set(uuid, testFiles);
+    // For multiple files, store directly in testFiles
+    const fileStatusMap = {};
+    testFiles.forEach((file) => {
+        fileStatusMap[file] = false; // false = not updated, true = updated
+    });
+    // Update storedPercyResults with test files
+    const updatedStored = { ...storedResults };
+    updatedStored.testFiles = fileStatusMap;
+    storedPercyResults.set(updatedStored);
     return {
         content: [
             {
                 type: "text",
-                text: `The Test files are stored in memory with id ${uuid} and the total number of tests files found is ${testFiles.length}. You can use this UUID to retrieve the tests file paths later.`,
+                text: `The Test files are stored in memory and the total number of tests files found is ${testFiles.length}.`,
             },
             {
                 type: "text",
-                text: `You can now use the tool addPercySnapshotCommands to update the test file with Percy commands for visual testing with the UUID ${uuid}`,
+                text: `You can now use the tool addPercySnapshotCommands to update the test file with Percy commands for visual testing.`,
             },
         ],
     };

package/dist/tools/percy-sdk.js

@@ -5,14 +5,41 @@ import { runPercyScan } from "./run-percy-scan.js";
 import { SetUpPercyParamsShape } from "./sdk-utils/common/schema.js";
 import { updateTestsWithPercyCommands } from "./add-percy-snapshots.js";
 import { approveOrDeclinePercyBuild } from "./review-agent-utils/percy-approve-reject.js";
-import { setUpPercyHandler } from "./sdk-utils/handler.js";
-import { SETUP_PERCY_DESCRIPTION, LIST_TEST_FILES_DESCRIPTION, PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, } from "./sdk-utils/common/constants.js";
-import { ListTestFilesParamsShape, UpdateTestFileWithInstructionsParams, } from "./percy-snapshot-utils/constants.js";
+import { setUpPercyHandler, simulatePercyChangeHandler, } from "./sdk-utils/handler.js";
+import { z } from "zod";
+import { SETUP_PERCY_DESCRIPTION, LIST_TEST_FILES_DESCRIPTION, PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, SIMULATE_PERCY_CHANGE_DESCRIPTION, } from "./sdk-utils/common/constants.js";
+import { UpdateTestFileWithInstructionsParams } from "./percy-snapshot-utils/constants.js";
 import { RunPercyScanParamsShape, FetchPercyChangesParamsShape, ManagePercyBuildApprovalParamsShape, } from "./sdk-utils/common/schema.js";
 import { handleMCPError } from "../lib/utils.js";
 export function registerPercyTools(server, config) {
     const tools = {};
-    tools.setupPercyVisualTesting = server.tool("setupPercyVisualTesting", SETUP_PERCY_DESCRIPTION, SetUpPercyParamsShape, async (args) => {
+    server.prompt("integrate-percy", {
+        project_name: z
+            .string()
+            .describe("The name of the project to integrate with Percy"),
+    }, async ({ project_name }) => {
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `Integrate percy in this project ${project_name} using tool percyVisualTestIntegrationAgent.`,
+                    },
+                },
+            ],
+        };
+    });
+    tools.percyVisualTestIntegrationAgent = server.tool("percyVisualTestIntegrationAgent", SIMULATE_PERCY_CHANGE_DESCRIPTION, SetUpPercyParamsShape, async (args) => {
+        try {
+            trackMCP("VisualTestIntegrationAgent", server.server.getClientVersion(), config);
+            return simulatePercyChangeHandler(args, config);
+        }
+        catch (error) {
+            return handleMCPError("VisualTestIntegrationAgent", server, config, error);
+        }
+    });
+    tools.setupPercyVisualTesting = server.tool("expandPercyVisualTesting", SETUP_PERCY_DESCRIPTION, SetUpPercyParamsShape, async (args) => {
         try {
             trackMCP("setupPercyVisualTesting", server.server.getClientVersion(), config);
             return setUpPercyHandler(args, config);
@@ -30,10 +57,10 @@ export function registerPercyTools(server, config) {
             return handleMCPError("addPercySnapshotCommands", server, config, error);
         }
     });
-    tools.listTestFiles = server.tool("listTestFiles", LIST_TEST_FILES_DESCRIPTION, ListTestFilesParamsShape, async (args) => {
+    tools.listTestFiles = server.tool("listTestFiles", LIST_TEST_FILES_DESCRIPTION, {}, async () => {
         try {
             trackMCP("listTestFiles", server.server.getClientVersion(), config);
-            return addListTestFiles(args);
+            return addListTestFiles();
         }
         catch (error) {
             return handleMCPError("listTestFiles", server, config, error);

package/dist/tools/percy-snapshot-utils/constants.d.ts

@@ -2,14 +2,8 @@ import { z } from "zod";
 import { SDKSupportedLanguage } from "../sdk-utils/common/types.js";
 import { DetectionConfig } from "./types.js";
 export declare const UpdateTestFileWithInstructionsParams: {
-    uuid: z.ZodString;
     index: z.ZodNumber;
 };
-export declare const ListTestFilesParamsShape: {
-    dirs: z.ZodArray<z.ZodString, "many">;
-    language: z.ZodEnum<[string, ...string[]]>;
-    framework: z.ZodEnum<[string, ...string[]]>;
-};
 export declare const TEST_FILE_DETECTION: Record<SDKSupportedLanguage, DetectionConfig>;
 export declare const EXCLUDED_DIRS: Set<string>;
 export declare const backendIndicators: RegExp[];

package/dist/tools/percy-snapshot-utils/constants.js

@@ -1,22 +1,7 @@
 import { z } from "zod";
-import { SDKSupportedLanguages, SDKSupportedTestingFrameworks, } from "../sdk-utils/common/types.js";
 export const UpdateTestFileWithInstructionsParams = {
-    uuid: z
-        .string()
-        .describe("UUID referencing the in-memory array of test file paths"),
     index: z.number().describe("Index of the test file to update"),
 };
-export const ListTestFilesParamsShape = {
-    dirs: z
-        .array(z.string())
-        .describe("Array of directory paths to search for test files"),
-    language: z
-        .enum(SDKSupportedLanguages)
-        .describe("Programming language"),
-    framework: z
-        .enum(SDKSupportedTestingFrameworks)
-        .describe("Testing framework (optional)"),
-};
 export const TEST_FILE_DETECTION = {
     java: {
         extensions: [".java"],

package/dist/tools/rca-agent-utils/constants.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { TestStatus } from "./types.js";
 export declare const FETCH_RCA_PARAMS: {
-    testId: z.ZodArray<z.ZodString, "many">;
+    testId: z.ZodArray<z.ZodNumber, "many">;
 };
 export declare const GET_BUILD_ID_PARAMS: {
     browserStackProjectName: z.ZodString;

package/dist/tools/rca-agent-utils/constants.js

@@ -2,9 +2,9 @@ import { z } from "zod";
 import { TestStatus } from "./types.js";
 export const FETCH_RCA_PARAMS = {
     testId: z
-        .array(z.string())
+        .array(z.number().int())
         .max(3)
-        .describe("Array of test IDs to fetch RCA data for (maximum 3 IDs). If not provided, use the listTestIds tool get all failed testcases. If more than 3 IDs are provided, only the first 3 will be processed."),
+        .describe("Array of integer test IDs to fetch RCA data for (maximum 3 IDs). These must be numeric test IDs, not session IDs or strings. If not provided, use the listTestIds tool to get all failed testcases. If more than 3 IDs are provided, only the first 3 will be processed."),
 };
 export const GET_BUILD_ID_PARAMS = {
     browserStackProjectName: z

package/dist/tools/rca-agent-utils/rca-data.d.ts

@@ -5,5 +5,5 @@ interface ScanProgressContext {
         progressToken?: string | number;
     };
 }
-export declare function getRCAData(testIds: string[], authString: string, context?: ScanProgressContext): Promise<RCAResponse>;
+export declare function getRCAData(testIds: number[], authString: string, context?: ScanProgressContext): Promise<RCAResponse>;
 export {};

package/dist/tools/rca-agent-utils/rca-data.js

@@ -66,7 +66,7 @@ async function updateProgress(context, testCases, message) {
         : calculateProgress(resolvedCount, testCases.length));
 }
 async function fetchInitialRCA(testId, headers, baseUrl) {
-    const url = baseUrl.replace("{testId}", testId);
+    const url = baseUrl.replace("{testId}", testId.toString());
     try {
         const response = await fetch(url, { headers });
         if (!response.ok) {
@@ -125,7 +125,7 @@ async function pollRCAResults(testCases, headers, baseUrl, context, pollInterval
             }
             await Promise.allSettled(inProgressCases.map(async (tc) => {
                 try {
-                    const pollUrl = baseUrl.replace("{testId}", tc.id);
+                    const pollUrl = baseUrl.replace("{testId}", tc.id.toString());
                     const response = await fetch(pollUrl, { headers });
                     if (!response.ok) {
                         const errorText = await response.text();

package/dist/tools/rca-agent-utils/types.d.ts

@@ -18,7 +18,7 @@ export interface TestRun {
     };
 }
 export interface FailedTestInfo {
-    test_id: string;
+    test_id: number;
     test_name: string;
 }
 export declare enum RCAState {
@@ -34,8 +34,8 @@ export declare enum RCAState {
     TIMEOUT = "TIMEOUT"
 }
 export interface RCATestCase {
-    id: string;
-    testRunId: string;
+    id: number;
+    testRunId: number;
     state: RCAState;
     rcaData?: any;
 }

package/dist/tools/rca-agent.d.ts

@@ -5,7 +5,7 @@ import { TestStatus } from "./rca-agent-utils/types.js";
 import { BuildIdArgs } from "./rca-agent-utils/types.js";
 export declare function getBuildIdTool(args: BuildIdArgs, config: BrowserStackConfig): Promise<CallToolResult>;
 export declare function fetchRCADataTool(args: {
-    testId: string[];
+    testId: number[];
 }, config: BrowserStackConfig): Promise<CallToolResult>;
 export declare function listTestIdsTool(args: {
     buildId: string;