@browserstack/mcp-server 1.2.2 → 1.2.3-beta.1

package/dist/tools/accessiblity-utils/auth-config.js

@@ -0,0 +1,125 @@
+import { apiClient } from "../../lib/apiClient.js";
+import logger from "../../logger.js";
+export class AccessibilityAuthConfig {
+    auth;
+    setAuth(auth) {
+        this.auth = auth;
+    }
+    transformLocalUrl(url) {
+        try {
+            const parsed = new URL(url);
+            const localHosts = new Set(["127.0.0.1", "localhost", "0.0.0.0"]);
+            const BS_LOCAL_DOMAIN = "bs-local.com";
+            if (localHosts.has(parsed.hostname)) {
+                parsed.hostname = BS_LOCAL_DOMAIN;
+                return parsed.toString();
+            }
+            return url;
+        }
+        catch {
+            return url;
+        }
+    }
+    async createFormAuthConfig(name, authData) {
+        if (!this.auth?.username || !this.auth?.password) {
+            throw new Error("BrowserStack credentials are not set for AccessibilityAuthConfig.");
+        }
+        const transformedAuthData = {
+            ...authData,
+            url: this.transformLocalUrl(authData.url),
+        };
+        const requestBody = {
+            name,
+            type: "form",
+            authData: transformedAuthData,
+        };
+        try {
+            const response = await apiClient.post({
+                url: "https://api-accessibility.browserstack.com/api/website-scanner/v1/auth_configs",
+                headers: {
+                    Authorization: "Basic " +
+                        Buffer.from(`${this.auth.username}:${this.auth.password}`).toString("base64"),
+                    "Content-Type": "application/json",
+                },
+                body: requestBody,
+            });
+            const data = response.data;
+            logger.info(`The data returned from the API is: ${JSON.stringify(data)}`);
+            if (!data.success) {
+                throw new Error(`Unable to create auth config: ${data.errors?.join(", ")}`);
+            }
+            return data;
+        }
+        catch (err) {
+            logger.error(`Error creating form auth config: ${JSON.stringify(err?.response?.data)}`);
+            const msg = err?.response?.data?.error ||
+                err?.response?.data?.message ||
+                err?.message ||
+                String(err);
+            throw new Error(`Failed to create form auth config: ${msg}`);
+        }
+    }
+    async createBasicAuthConfig(name, authData) {
+        if (!this.auth?.username || !this.auth?.password) {
+            throw new Error("BrowserStack credentials are not set for AccessibilityAuthConfig.");
+        }
+        const transformedAuthData = {
+            ...authData,
+            url: this.transformLocalUrl(authData.url),
+        };
+        const requestBody = {
+            name,
+            type: "basic",
+            authData: transformedAuthData,
+        };
+        try {
+            const response = await apiClient.post({
+                url: "https://api-accessibility.browserstack.com/api/website-scanner/v1/auth_configs",
+                headers: {
+                    Authorization: "Basic " +
+                        Buffer.from(`${this.auth.username}:${this.auth.password}`).toString("base64"),
+                    "Content-Type": "application/json",
+                },
+                body: requestBody,
+            });
+            const data = response.data;
+            if (!data.success) {
+                throw new Error(`Unable to create auth config: ${data.errors?.join(", ")}`);
+            }
+            return data;
+        }
+        catch (err) {
+            const msg = err?.response?.data?.error ||
+                err?.response?.data?.message ||
+                err?.message ||
+                String(err);
+            throw new Error(`Failed to create basic auth config: ${msg}`);
+        }
+    }
+    async getAuthConfig(configId) {
+        if (!this.auth?.username || !this.auth?.password) {
+            throw new Error("BrowserStack credentials are not set for AccessibilityAuthConfig.");
+        }
+        try {
+            const response = await apiClient.get({
+                url: `https://api-accessibility.browserstack.com/api/website-scanner/v1/auth_configs/${configId}`,
+                headers: {
+                    Authorization: "Basic " +
+                        Buffer.from(`${this.auth.username}:${this.auth.password}`).toString("base64"),
+                },
+            });
+            const data = response.data;
+            if (!data.success) {
+                throw new Error(`Unable to get auth config: ${data.errors?.join(", ")}`);
+            }
+            return data;
+        }
+        catch (err) {
+            const msg = err?.response?.data?.error ||
+                err?.response?.data?.message ||
+                err?.message ||
+                String(err);
+            throw new Error(`Failed to get auth config: ${msg}`);
+        }
+    }
+}

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

@@ -19,7 +19,7 @@ export declare class AccessibilityScanner {
         username: string;
         password: string;
     }): void;
-    startScan(name: string, urlList: string[]): Promise<AccessibilityScanResponse>;
+    startScan(name: string, urlList: string[], authConfigId?: number): Promise<AccessibilityScanResponse>;
     pollStatus(scanId: string, scanRunId: string): Promise<AccessibilityScanStatus>;
     waitUntilComplete(scanId: string, scanRunId: string, context: any): Promise<string>;
 }

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

@@ -8,7 +8,7 @@ export class AccessibilityScanner {
     setAuth(auth) {
         this.auth = auth;
     }
-    async startScan(name, urlList) {
+    async startScan(name, urlList, authConfigId) {
         if (!this.auth?.username || !this.auth?.password) {
             throw new Error("BrowserStack credentials are not set for AccessibilityScanner.");
         }
@@ -47,6 +47,7 @@ export class AccessibilityScanner {
             name,
             urlList: transformedUrlList,
             recurring: false,
+            ...(authConfigId && { authConfigId }),
         };
         let requestBody = baseRequestBody;
         if (hasLocal) {

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

@@ -0,0 +1 @@
+export declare function generateAppBrowserStackYMLInstructions(platforms: string[], username: string, accessKey: string, appPath: string | undefined, testingFramework: string): string;

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

@@ -0,0 +1,50 @@
+// Configuration utilities for BrowserStack App SDK
+import { APP_DEVICE_CONFIGS, AppSDKSupportedTestingFrameworkEnum, DEFAULT_APP_PATH, createStep, } from "./index.js";
+export function generateAppBrowserStackYMLInstructions(platforms, username, accessKey, appPath = DEFAULT_APP_PATH, testingFramework) {
+    if (testingFramework === AppSDKSupportedTestingFrameworkEnum.nightwatch ||
+        testingFramework === AppSDKSupportedTestingFrameworkEnum.webdriverio ||
+        testingFramework === AppSDKSupportedTestingFrameworkEnum.cucumberRuby) {
+        return "";
+    }
+    // Generate platform and device configurations
+    const platformConfigs = 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");
+    // Construct YAML content
+    const configContent = `\`\`\`yaml
+userName: ${username}
+accessKey: ${accessKey}
+app: ${appPath}
+platforms:
+${platformConfigs}
+parallelsPerPlatform: 1
+browserstackLocal: true
+buildName: bstack-demo
+projectName: BrowserStack Sample
+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`;
+    // Return formatted step for instructions
+    return createStep("Update browserstack.yml file with App Automate configuration:", `Create or update the browserstack.yml file in your project root with the following content:
+
+${configContent}`);
+}

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>;
+    desiredPlatforms: z.ZodArray<z.ZodNativeEnum<typeof AppSDKSupportedPlatformEnum>, "many">;
+    appPath: z.ZodString;
+    project: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+};

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

@@ -0,0 +1,43 @@
+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'"),
+    desiredPlatforms: z
+        .array(z.nativeEnum(AppSDKSupportedPlatformEnum))
+        .describe("The mobile platforms the user wants to test on. Always ask this to the user, do not try to infer this. Example: ['android', 'ios']"),
+    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,52 @@
+import { z } from "zod";
+import { getBrowserStackAuth } from "../../../lib/get-auth.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 platforms = input.desiredPlatforms ?? ["android"];
+    const appPath = input.appPath;
+    const framework = input.detectedFramework;
+    //Validating if supported framework or not
+    validateSupportforAppAutomate(framework, language, testingFramework);
+    // 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);
+    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,8 @@
+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_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 getJavaSDKCommand(framework: string, username: string, accessKey: string, appPath?: string): string;

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

@@ -0,0 +1,87 @@
+// 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";
+// Framework mapping for Java Maven archetype generation for App Automate
+export const JAVA_APP_FRAMEWORK_MAP = {
+    testng: "browserstack-sdk-archetype-integrate",
+    junit5: "browserstack-sdk-archetype-integrate",
+    selenide: "selenide-archetype-integrate",
+    jbehave: "browserstack-sdk-archetype-integrate",
+    cucumberTestng: "browserstack-sdk-archetype-integrate",
+    cucumberJunit4: "browserstack-sdk-archetype-integrate",
+    cucumberJunit5: "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;
+}
+function getMavenCommandForWindows(framework, mavenFramework, username, accessKey) {
+    return (`mvn archetype:generate -B ` +
+        `-DarchetypeGroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DarchetypeArtifactId="${mavenFramework}" ` +
+        `-DarchetypeVersion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DartifactId="${MAVEN_ARCHETYPE_ARTIFACT_ID}" ` +
+        `-Dversion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DBROWSERSTACK_USERNAME="${username}" ` +
+        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}" ` +
+        `-DBROWSERSTACK_FRAMEWORK="${framework}"`);
+}
+function getMavenCommandForUnix(framework, mavenFramework, username, accessKey) {
+    return (`mvn archetype:generate -B ` +
+        `-DarchetypeGroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DarchetypeArtifactId="${mavenFramework}" ` +
+        `-DarchetypeVersion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DgroupId="${MAVEN_ARCHETYPE_GROUP_ID}" ` +
+        `-DartifactId="${MAVEN_ARCHETYPE_ARTIFACT_ID}" ` +
+        `-Dversion="${MAVEN_ARCHETYPE_VERSION}" ` +
+        `-DBROWSERSTACK_USERNAME="${username}" ` +
+        `-DBROWSERSTACK_ACCESS_KEY="${accessKey}" ` +
+        `-DBROWSERSTACK_FRAMEWORK="${framework}"`);
+}
+export function getJavaSDKCommand(framework, username, accessKey, appPath) {
+    const { isWindows = false, getPlatformLabel } = PLATFORM_UTILS || {};
+    const mavenFramework = getJavaAppFrameworkForMaven(framework);
+    let mavenCommand;
+    if (isWindows) {
+        mavenCommand = getMavenCommandForWindows(framework, mavenFramework, username, accessKey);
+        if (appPath) {
+            mavenCommand += ` -DBROWSERSTACK_APP="${appPath}"`;
+        }
+    }
+    else {
+        mavenCommand = getMavenCommandForUnix(framework, mavenFramework, username, accessKey);
+        if (appPath) {
+            mavenCommand += ` -DBROWSERSTACK_APP="${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}`);
+    return combineInstructions(envStep, mavenStep);
+}

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;