@browserstack/mcp-server 1.2.3 → 1.2.5

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

@@ -0,0 +1,7 @@
+import { ValidatedEnvironment } from "../../sdk-utils/common/device-validator.js";
+export declare function generateAppBrowserStackYMLInstructions(config: {
+    validatedEnvironments?: ValidatedEnvironment[];
+    platforms?: string[];
+    testingFramework?: string;
+    projectName?: string;
+}, username: string, accessKey: string, appPath?: string): string;

package/dist/tools/appautomate-utils/appium-sdk/config-generator.js

@@ -0,0 +1,70 @@
+import { APP_DEVICE_CONFIGS, AppSDKSupportedTestingFrameworkEnum, DEFAULT_APP_PATH, createStep, } from "./index.js";
+export function generateAppBrowserStackYMLInstructions(config, username, accessKey, appPath = DEFAULT_APP_PATH) {
+    if (config.testingFramework ===
+        AppSDKSupportedTestingFrameworkEnum.nightwatch ||
+        config.testingFramework ===
+            AppSDKSupportedTestingFrameworkEnum.webdriverio ||
+        config.testingFramework === AppSDKSupportedTestingFrameworkEnum.cucumberRuby) {
+        return "";
+    }
+    const platformConfigs = generatePlatformConfigs(config);
+    const projectName = config.projectName || "BrowserStack Sample";
+    const buildName = config.projectName
+        ? `${config.projectName}-AppAutomate-Build`
+        : "bstack-demo";
+    const configContent = `\`\`\`yaml
+userName: ${username}
+accessKey: ${accessKey}
+app: ${appPath}
+platforms:
+${platformConfigs}
+parallelsPerPlatform: 1
+browserstackLocal: true
+// TODO: replace projectName and buildName according to actual project
+projectName: ${projectName}
+buildName: ${buildName}
+debug: true
+networkLogs: true
+percy: false
+percyCaptureMode: auto
+accessibility: false
+\`\`\`
+
+**Important notes:**
+- Replace \`app: ${appPath}\` with the path to your actual app file (e.g., \`./SampleApp.apk\` for Android or \`./SampleApp.ipa\` for iOS)
+- You can upload your app using BrowserStack's App Upload API or manually through the dashboard
+- Set \`browserstackLocal: true\` if you need to test with local/staging servers
+- Adjust \`parallelsPerPlatform\` based on your subscription limits`;
+    const stepTitle = "Update browserstack.yml file with App Automate configuration:";
+    const stepDescription = `Create or update the browserstack.yml file in your project root with the following content:
+  ${configContent}`;
+    return createStep(stepTitle, stepDescription);
+}
+function generatePlatformConfigs(config) {
+    if (config.validatedEnvironments && config.validatedEnvironments.length > 0) {
+        return config.validatedEnvironments
+            .filter((env) => env.platform === "android" || env.platform === "ios")
+            .map((env) => {
+            return `  - platformName: ${env.platform}
+    deviceName: "${env.deviceName}"
+    platformVersion: "${env.osVersion}"`;
+        })
+            .join("\n");
+    }
+    else if (config.platforms && config.platforms.length > 0) {
+        return config.platforms
+            .map((platform) => {
+            const devices = APP_DEVICE_CONFIGS[platform];
+            if (!devices)
+                return "";
+            return devices
+                .map((device) => `  - platformName: ${platform}
+    deviceName: ${device.deviceName}
+    platformVersion: "${device.platformVersion}"`)
+                .join("\n");
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { AppSDKSupportedFrameworkEnum, AppSDKSupportedTestingFrameworkEnum, AppSDKSupportedLanguageEnum, AppSDKSupportedPlatformEnum } from "./index.js";
+export declare const APP_DEVICE_CONFIGS: {
+    android: {
+        deviceName: string;
+        platformVersion: string;
+    }[];
+    ios: {
+        deviceName: string;
+        platformVersion: string;
+    }[];
+};
+export declare const STEP_DELIMITER = "---STEP---";
+export declare const DEFAULT_APP_PATH = "bs://sample.app";
+export declare const SETUP_APP_AUTOMATE_DESCRIPTION = "Set up BrowserStack App Automate SDK integration for Appium-based mobile app testing. ONLY for Appium based framework . This tool configures SDK for various languages with appium. For pre-built Espresso or XCUITest test suites, use 'runAppTestsOnBrowserStack' instead.";
+export declare const SETUP_APP_AUTOMATE_SCHEMA: {
+    detectedFramework: z.ZodNativeEnum<typeof AppSDKSupportedFrameworkEnum>;
+    detectedTestingFramework: z.ZodNativeEnum<typeof AppSDKSupportedTestingFrameworkEnum>;
+    detectedLanguage: z.ZodNativeEnum<typeof AppSDKSupportedLanguageEnum>;
+    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">>;
+    appPath: z.ZodString;
+    project: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+};

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

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { AppSDKSupportedFrameworkEnum, AppSDKSupportedTestingFrameworkEnum, AppSDKSupportedLanguageEnum, AppSDKSupportedPlatformEnum, } from "./index.js";
+// App Automate specific device configurations
+export const APP_DEVICE_CONFIGS = {
+    android: [
+        { deviceName: "Samsung Galaxy S22 Ultra", platformVersion: "12.0" },
+        { deviceName: "Google Pixel 7 Pro", platformVersion: "13.0" },
+        { deviceName: "OnePlus 9", platformVersion: "11.0" },
+    ],
+    ios: [
+        { deviceName: "iPhone 14", platformVersion: "16" },
+        { deviceName: "iPhone 13", platformVersion: "15" },
+        { deviceName: "iPad Air 4", platformVersion: "14" },
+    ],
+};
+// Step delimiter for parsing instructions
+export const STEP_DELIMITER = "---STEP---";
+// Default app path for examples
+export const DEFAULT_APP_PATH = "bs://sample.app";
+// Tool description and schema for setupBrowserStackAppAutomateTests
+export const SETUP_APP_AUTOMATE_DESCRIPTION = "Set up BrowserStack App Automate SDK integration for Appium-based mobile app testing. ONLY for Appium based framework . This tool configures SDK for various languages with appium. For pre-built Espresso or XCUITest test suites, use 'runAppTestsOnBrowserStack' instead.";
+export const SETUP_APP_AUTOMATE_SCHEMA = {
+    detectedFramework: z
+        .nativeEnum(AppSDKSupportedFrameworkEnum)
+        .describe("The mobile automation framework configured in the project. Example: 'appium'"),
+    detectedTestingFramework: z
+        .nativeEnum(AppSDKSupportedTestingFrameworkEnum)
+        .describe("The testing framework used in the project. Be precise with framework selection Example: 'testng', 'behave', 'pytest', 'robot'"),
+    detectedLanguage: z
+        .nativeEnum(AppSDKSupportedLanguageEnum)
+        .describe("The programming language used in the project. Supports Java and C#. Example: 'java', 'csharp'"),
+    devices: z
+        .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']]"),
+    appPath: z
+        .string()
+        .describe("Path to the mobile app file (.apk for Android, .ipa for iOS). Can be a local file path or a BrowserStack app URL (bs://)"),
+    project: z
+        .string()
+        .optional()
+        .default("BStack-AppAutomate-Suite")
+        .describe("Project name for organizing test runs on BrowserStack."),
+};

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

@@ -0,0 +1,8 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function formatFinalAppInstructions(formattedInstructions: string): CallToolResult;
+export declare function createStep(title: string, content: string): string;
+export declare function combineInstructions(...instructionParts: string[]): string;
+export declare function formatEnvCommands(username: string, accessKey: string, isWindows: boolean): string;
+export declare function createEnvStep(username: string, accessKey: string, isWindows: boolean, platformLabel: string, title?: string): string;
+export declare function formatMultiLineCommand(command: string, isWindows?: boolean): string;
+export declare function formatAppInstructionsWithNumbers(instructions: string): string;

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

@@ -0,0 +1,59 @@
+import { STEP_DELIMITER } from "./constants.js";
+export function formatFinalAppInstructions(formattedInstructions) {
+    const fullInstructions = `
+⚠️ IMPORTANT: DO NOT SKIP ANY STEP
+All the setup steps described in this file MUST be executed regardless of any existing configuration or setup.
+This ensures proper BrowserStack App Automate SDK setup.
+Each step is compulsory and sequence needs to be maintained.
+
+${formattedInstructions}`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: fullInstructions,
+                isError: false,
+            },
+        ],
+    };
+}
+export function createStep(title, content) {
+    return `${STEP_DELIMITER}
+${title}
+
+${content}`;
+}
+export function combineInstructions(...instructionParts) {
+    return instructionParts.filter(Boolean).join("\n\n");
+}
+export function formatEnvCommands(username, accessKey, isWindows) {
+    if (isWindows) {
+        return `\`\`\`cmd
+setx BROWSERSTACK_USERNAME "${username}"
+setx BROWSERSTACK_ACCESS_KEY "${accessKey}"
+\`\`\``;
+    }
+    return `\`\`\`bash
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``;
+}
+export function createEnvStep(username, accessKey, isWindows, platformLabel, title = "Set BrowserStack credentials as environment variables:") {
+    return createStep(title, `**${platformLabel}:**
+${formatEnvCommands(username, accessKey, isWindows)}`);
+}
+export function formatMultiLineCommand(command, isWindows = process.platform === "win32") {
+    if (isWindows) {
+        // For Windows, keep commands on single line
+        return command.replace(/\s*\\\s*\n\s*/g, " ");
+    }
+    return command;
+}
+export function formatAppInstructionsWithNumbers(instructions) {
+    const steps = instructions
+        .split(STEP_DELIMITER)
+        .filter((step) => step.trim());
+    return steps
+        .map((step, index) => `**Step ${index + 1}:**\n${step.trim()}`)
+        .join("\n\n");
+}

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

@@ -0,0 +1,3 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../../lib/types.js";
+export declare function setupAppAutomateHandler(rawInput: unknown, config: BrowserStackConfig): Promise<CallToolResult>;

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

@@ -0,0 +1,66 @@
+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";
+export async function setupAppAutomateHandler(rawInput, config) {
+    const input = z.object(SETUP_APP_AUTOMATE_SCHEMA).parse(rawInput);
+    const auth = getBrowserStackAuth(config);
+    const [username, accessKey] = auth.split(":");
+    const instructions = [];
+    // Use variables for all major input properties
+    const testingFramework = input.detectedTestingFramework;
+    const language = input.detectedLanguage;
+    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({
+        validatedEnvironments,
+        platforms,
+        testingFramework,
+        projectName: input.project,
+    }, username, accessKey, appPath);
+    if (configInstructions) {
+        instructions.push({ content: configInstructions, type: "config" });
+    }
+    // Step 3: Generate app upload instruction
+    const appUploadInstruction = await getAppUploadInstruction(appPath, username, accessKey, testingFramework);
+    if (appUploadInstruction) {
+        instructions.push({ content: appUploadInstruction, type: "setup" });
+    }
+    // Step 4: Generate project configuration and run instructions
+    const projectInstructions = getAppInstructionsForProjectConfiguration(framework, testingFramework, language);
+    if (projectInstructions) {
+        instructions.push({ content: projectInstructions, type: "run" });
+    }
+    const combinedInstructions = instructions
+        .map((instruction) => instruction.content)
+        .join("\n\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatAppInstructionsWithNumbers(combinedInstructions),
+                isError: false,
+            },
+        ],
+        isError: false,
+    };
+}

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

@@ -0,0 +1,7 @@
+export { getAppSDKPrefixCommand, getAppInstructionsForProjectConfiguration, } from "./instructions.js";
+export { generateAppBrowserStackYMLInstructions } from "./config-generator.js";
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils.js";
+export * from "./instructions.js";
+export * from "./formatter.js";

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

@@ -0,0 +1,8 @@
+// Barrel exports for App BrowserStack module
+export { getAppSDKPrefixCommand, getAppInstructionsForProjectConfiguration, } from "./instructions.js";
+export { generateAppBrowserStackYMLInstructions } from "./config-generator.js";
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils.js";
+export * from "./instructions.js";
+export * from "./formatter.js";

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

@@ -0,0 +1,3 @@
+import { AppSDKSupportedLanguage, AppSDKSupportedTestingFramework } from "./index.js";
+export declare function getAppInstructionsForProjectConfiguration(framework: string, testingFramework: AppSDKSupportedTestingFramework, language: AppSDKSupportedLanguage): string;
+export declare function getAppSDKPrefixCommand(language: AppSDKSupportedLanguage, testingFramework: string, username: string, accessKey: string, appPath?: string): string;

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

@@ -0,0 +1,47 @@
+// Language-specific instruction imports
+import { getJavaAppInstructions } from "./languages/java.js";
+import { getCSharpAppInstructions } from "./languages/csharp.js";
+import { getNodejsAppInstructions } from "./languages/nodejs.js";
+import { getPythonAppInstructions } from "./languages/python.js";
+import { getRubyAppInstructions } from "./languages/ruby.js";
+// Language-specific command imports
+import { getCSharpSDKCommand } from "./languages/csharp.js";
+import { getJavaSDKCommand } from "./languages/java.js";
+import { getNodejsSDKCommand } from "./languages/nodejs.js";
+import { getPythonSDKCommand } from "./languages/python.js";
+import { getRubySDKCommand } from "./languages/ruby.js";
+export function getAppInstructionsForProjectConfiguration(framework, testingFramework, language) {
+    if (!framework || !testingFramework || !language) {
+        return "";
+    }
+    switch (language) {
+        case "java":
+            return getJavaAppInstructions();
+        case "nodejs":
+            return getNodejsAppInstructions(testingFramework);
+        case "python":
+            return getPythonAppInstructions(testingFramework);
+        case "ruby":
+            return getRubyAppInstructions();
+        case "csharp":
+            return getCSharpAppInstructions();
+        default:
+            return "";
+    }
+}
+export function getAppSDKPrefixCommand(language, testingFramework, username, accessKey, appPath) {
+    switch (language) {
+        case "csharp":
+            return getCSharpSDKCommand(username, accessKey);
+        case "java":
+            return getJavaSDKCommand(testingFramework, username, accessKey, appPath);
+        case "nodejs":
+            return getNodejsSDKCommand(testingFramework, username, accessKey);
+        case "python":
+            return getPythonSDKCommand(testingFramework, username, accessKey);
+        case "ruby":
+            return getRubySDKCommand(testingFramework, username, accessKey);
+        default:
+            return "";
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function getCSharpAppInstructions(): string;
+export declare function getCSharpSDKCommand(username: string, accessKey: string): string;

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

@@ -0,0 +1,78 @@
+// C# instructions and commands for App SDK utilities
+import { PLATFORM_UTILS, createStep, createEnvStep, combineInstructions, } from "../index.js";
+export function getCSharpAppInstructions() {
+    const { isWindows, isAppleSilicon, getPlatformLabel } = PLATFORM_UTILS;
+    let runCommand = "";
+    if (isWindows) {
+        runCommand = `\`\`\`cmd
+dotnet build
+dotnet test --filter <EXPRESSION> [other_args]
+\`\`\``;
+    }
+    else if (isAppleSilicon) {
+        runCommand = `\`\`\`bash
+dotnet build
+dotnet test --filter <EXPRESSION> [other_args]
+\`\`\`
+
+**Did not set the alias?**
+Use the absolute path to the dotnet installation to run your tests on Mac computers with Apple silicon chips:
+\`\`\`bash
+</absolute/path/to/location/of/dotnet/>/dotnet test
+\`\`\``;
+    }
+    else {
+        runCommand = `\`\`\`bash
+dotnet build
+dotnet test --filter <EXPRESSION> [other_args]
+\`\`\``;
+    }
+    const runStep = createStep("Run your C# test suite:", `**${getPlatformLabel()}:**
+${runCommand}
+
+**Debug Guidelines:**
+If you encounter the error: java.lang.IllegalArgumentException: Multiple entries with the same key,
+__Resolution:__
+- The app capability should only be set in one place: browserstack.yml.
+- Remove or comment out any code or configuration in your test setup (e.g., step definitions, runners, or capabilities setup) that sets the app path directly.`);
+    return runStep;
+}
+export function getCSharpSDKCommand(username, accessKey) {
+    const { isWindows = false, isAppleSilicon = false, getPlatformLabel = () => "Unknown", } = PLATFORM_UTILS || {};
+    if (!PLATFORM_UTILS) {
+        console.warn("PLATFORM_UTILS is undefined. Defaulting platform values.");
+    }
+    const envStep = createEnvStep(username, accessKey, isWindows, getPlatformLabel());
+    const installCommands = isWindows
+        ? `\`\`\`cmd
+dotnet add package BrowserStack.TestAdapter
+dotnet build
+dotnet browserstack-sdk setup --userName "${username}" --accessKey "${accessKey}"
+\`\`\``
+        : `\`\`\`bash
+dotnet add package BrowserStack.TestAdapter
+dotnet build
+dotnet browserstack-sdk setup --userName "${username}" --accessKey "${accessKey}"
+\`\`\``;
+    const installStep = createStep("Install BrowserStack SDK", `Run the following command to install the BrowserStack SDK and create a browserstack.yml file in the root directory of your project:
+
+**${getPlatformLabel()}:**
+${installCommands}`);
+    const appleSiliconNote = isAppleSilicon
+        ? createStep("[Only for Macs with Apple silicon] Install dotnet x64 on MacOS", `If you are using a Mac computer with Apple silicon chip (M1 or M2) architecture, use the given command:
+
+\`\`\`bash
+cd #(project folder Android or iOS)
+dotnet browserstack-sdk setup-dotnet --dotnet-path "<path>" --dotnet-version "<version>"
+\`\`\`
+
+- \`<path>\` - Mention the absolute path to the directory where you want to save dotnet x64
+- \`<version>\` - Mention the dotnet version which you want to use to run tests
+
+This command performs the following functions:
+- Installs dotnet x64
+- Installs the required version of dotnet x64 at an appropriate path
+- Sets alias for the dotnet installation location on confirmation (enter y option)`)
+        : "";
+    return combineInstructions(envStep, installStep, appleSiliconNote);
+}

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

@@ -0,0 +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

@@ -0,0 +1,121 @@
+// Java instructions and commands for App SDK utilities
+import { createStep, combineInstructions, createEnvStep, PLATFORM_UTILS, } from "../index.js";
+// Java-specific constants and mappings
+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: "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 = `
+**For Gradle setup:**
+1. Add browserstack-java-sdk to dependencies:
+   compileOnly 'com.browserstack:browserstack-java-sdk:latest.release'
+
+2. Add browserstackSDK path variable:
+   def browserstackSDKArtifact = configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.find { it.name == 'browserstack-java-sdk' }
+
+3. Add javaagent to gradle tasks:
+   jvmArgs "-javaagent:\${browserstackSDKArtifact.file}"
+`;
+export function getJavaAppInstructions() {
+    const baseRunStep = createStep("Run your App Automate test suite:", `\`\`\`bash
+mvn test
+\`\`\``);
+    return baseRunStep;
+}
+export function getJavaAppFrameworkForMaven(framework) {
+    return JAVA_APP_FRAMEWORK_MAP[framework] || framework;
+}
+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="${version}" ` +
+        `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DartifactId="${mavenFramework}" ` +
+        `-Dversion="${version}" ` +
+        `-DBROWSERSTACK_USERNAME="${username}" ` +
+        `-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, version, username, accessKey, appPath) {
+    let command = `mvn archetype:generate -B ` +
+        `-DarchetypeGroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DarchetypeArtifactId="${mavenFramework}" ` +
+        `-DarchetypeVersion="${version}" ` +
+        `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DartifactId="${mavenFramework}" ` +
+        `-Dversion="${version}" ` +
+        `-DBROWSERSTACK_USERNAME="${username}" ` +
+        `-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, version, username, accessKey, appPath);
+    }
+    else {
+        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}
+    \`\`\`
+
+    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/languages/nodejs.d.ts

@@ -0,0 +1,3 @@
+import { AppSDKSupportedTestingFramework } from "../index.js";
+export declare function getNodejsSDKCommand(testingFramework: string, username: string, accessKey: string): string;
+export declare function getNodejsAppInstructions(testingFramework: AppSDKSupportedTestingFramework): string;